# TODO: windows generator on cmake always uses msvc, even if we plan to build with icc
if(MSVC OR MSVC_IDE)
message(STATUS "Building for Windows")
+
if (MSVC_VERSION LESS 1700)
message(FATAL_ERROR "The project requires C++11 features.")
else()
if (WINDOWS_ICC)
- set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /O3 /Qstd=c99 /Qrestrict /QxHost /wd4267 /Qdiag-disable:remark")
+ set(ARCH_C_FLAGS "/QxHost")
+ set(ARCH_CXX_FLAGS "/QxHost")
+ set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /O3 /Qstd=c99 /Qrestrict /wd4267 /Qdiag-disable:remark")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /O2 /Qstd=c++11 /Qrestrict /QxHost /wd4267 /wd4800 /Qdiag-disable:remark -DBOOST_DETAIL_NO_CONTAINER_FWD -D_SCL_SECURE_NO_WARNINGS")
else()
- #TODO: don't hardcode arch
- set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /O2 /arch:AVX /wd4267")
- set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /O2 /arch:AVX /wd4244 /wd4267 /wd4800 -DBOOST_DETAIL_NO_CONTAINER_FWD -D_SCL_SECURE_NO_WARNINGS")
+ # todo: change these as required
+ set(ARCH_C_FLAGS "/arch:AVX2")
+ set(ARCH_CXX_FLAGS "/arch:AVX2")
+ set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /O2 /wd4244 /wd4267")
+ set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /O2 /wd4244 /wd4267 /wd4800 -DBOOST_DETAIL_NO_CONTAINER_FWD -D_SCL_SECURE_NO_WARNINGS")
endif()
string(REPLACE "/RTC1" "" CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG}")
string(REPLACE "/RTC1" "" CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG}")
set(CMAKE_C_FLAGS_DEBUG "/DNDEBUG ${CMAKE_C_FLAGS_DEBUG}")
set(CMAKE_CXX_FLAGS_DEBUG "/DNDEBUG ${CMAKE_CXX_FLAGS_DEBUG}")
endif ()
+
+ # flags only used to build hs libs
+ set(HS_C_FLAGS "/Gv")
+ set(HS_CXX_FLAGS "/Gv")
endif()
else()
# only set these after all tests are done
if (NOT FAT_RUNTIME)
-set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_C_FLAGS}")
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${EXTRA_CXX_FLAGS}")
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_C_FLAGS} ${HS_C_FLAGS}")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${EXTRA_CXX_FLAGS} ${HS_CXX_FLAGS}")
else()
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_C_FLAGS}")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${EXTRA_CXX_FLAGS}")
/*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2017, Intel Corporation
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
}
HS_PUBLIC_API
-hs_error_t hs_set_allocator(hs_alloc_t allocfunc, hs_free_t freefunc) {
+hs_error_t HS_CDECL hs_set_allocator(hs_alloc_t allocfunc, hs_free_t freefunc) {
hs_set_database_allocator(allocfunc, freefunc);
hs_set_misc_allocator(allocfunc, freefunc);
hs_set_stream_allocator(allocfunc, freefunc);
}
HS_PUBLIC_API
-hs_error_t hs_set_database_allocator(hs_alloc_t allocfunc, hs_free_t freefunc) {
+hs_error_t HS_CDECL hs_set_database_allocator(hs_alloc_t allocfunc,
+ hs_free_t freefunc) {
hs_database_alloc = normalise_alloc(allocfunc);
hs_database_free = normalise_free(freefunc);
}
HS_PUBLIC_API
-hs_error_t hs_set_misc_allocator(hs_alloc_t allocfunc, hs_free_t freefunc) {
+hs_error_t HS_CDECL hs_set_misc_allocator(hs_alloc_t allocfunc,
+ hs_free_t freefunc) {
hs_misc_alloc = normalise_alloc(allocfunc);
hs_misc_free = normalise_free(freefunc);
}
HS_PUBLIC_API
-hs_error_t hs_set_scratch_allocator(hs_alloc_t allocfunc, hs_free_t freefunc) {
+hs_error_t HS_CDECL hs_set_scratch_allocator(hs_alloc_t allocfunc,
+ hs_free_t freefunc) {
hs_scratch_alloc = normalise_alloc(allocfunc);
hs_scratch_free = normalise_free(freefunc);
}
HS_PUBLIC_API
-hs_error_t hs_set_stream_allocator(hs_alloc_t allocfunc, hs_free_t freefunc) {
+hs_error_t HS_CDECL hs_set_stream_allocator(hs_alloc_t allocfunc,
+ hs_free_t freefunc) {
hs_stream_alloc = normalise_alloc(allocfunc);
hs_stream_free = normalise_free(freefunc);
}
HS_PUBLIC_API
-hs_error_t hs_free_database(hs_database_t *db) {
+hs_error_t HS_CDECL hs_free_database(hs_database_t *db) {
if (db && db->magic != HS_DB_MAGIC) {
return HS_INVALID;
}
}
HS_PUBLIC_API
-hs_error_t hs_serialize_database(const hs_database_t *db, char **bytes,
- size_t *serialized_length) {
+hs_error_t HS_CDECL hs_serialize_database(const hs_database_t *db, char **bytes,
+ size_t *serialized_length) {
if (!db || !bytes || !serialized_length) {
return HS_INVALID;
}
}
HS_PUBLIC_API
-hs_error_t hs_deserialize_database_at(const char *bytes, const size_t length,
- hs_database_t *db) {
+hs_error_t HS_CDECL hs_deserialize_database_at(const char *bytes,
+ const size_t length,
+ hs_database_t *db) {
if (!bytes || !db) {
return HS_INVALID;
}
}
HS_PUBLIC_API
-hs_error_t hs_deserialize_database(const char *bytes, const size_t length,
- hs_database_t **db) {
+hs_error_t HS_CDECL hs_deserialize_database(const char *bytes,
+ const size_t length,
+ hs_database_t **db) {
if (!bytes || !db) {
return HS_INVALID;
}
}
HS_PUBLIC_API
-hs_error_t hs_database_size(const hs_database_t *db, size_t *size) {
+hs_error_t HS_CDECL hs_database_size(const hs_database_t *db, size_t *size) {
if (!size) {
return HS_INVALID;
}
}
HS_PUBLIC_API
-hs_error_t hs_serialized_database_size(const char *bytes, const size_t length,
- size_t *size) {
+hs_error_t HS_CDECL hs_serialized_database_size(const char *bytes,
+ const size_t length,
+ size_t *size) {
// Decode and check the header
hs_database_t header;
hs_error_t ret = db_decode_header(&bytes, length, &header);
}
HS_PUBLIC_API
-hs_error_t hs_serialized_database_info(const char *bytes, size_t length,
- char **info) {
+hs_error_t HS_CDECL hs_serialized_database_info(const char *bytes,
+ size_t length, char **info) {
if (!info) {
return HS_INVALID;
}
}
HS_PUBLIC_API
-hs_error_t hs_database_info(const hs_database_t *db, char **info) {
+hs_error_t HS_CDECL hs_database_info(const hs_database_t *db, char **info) {
if (!info) {
return HS_INVALID;
}
} // namespace ue2
extern "C" HS_PUBLIC_API
-hs_error_t hs_compile(const char *expression, unsigned flags, unsigned mode,
- const hs_platform_info_t *platform, hs_database_t **db,
- hs_compile_error_t **error) {
+hs_error_t HS_CDECL hs_compile(const char *expression, unsigned flags,
+ unsigned mode,
+ const hs_platform_info_t *platform,
+ hs_database_t **db, hs_compile_error_t **error) {
if (expression == nullptr) {
*db = nullptr;
*error = generateCompileError("Invalid parameter: expression is NULL",
}
extern "C" HS_PUBLIC_API
-hs_error_t hs_compile_multi(const char * const *expressions,
- const unsigned *flags, const unsigned *ids,
- unsigned elements, unsigned mode,
- const hs_platform_info_t *platform,
- hs_database_t **db, hs_compile_error_t **error) {
+hs_error_t HS_CDECL hs_compile_multi(const char *const *expressions,
+ const unsigned *flags, const unsigned *ids,
+ unsigned elements, unsigned mode,
+ const hs_platform_info_t *platform,
+ hs_database_t **db,
+ hs_compile_error_t **error) {
const hs_expr_ext * const *ext = nullptr; // unused for this call.
return hs_compile_multi_int(expressions, flags, ids, ext, elements, mode,
platform, db, error, Grey());
}
extern "C" HS_PUBLIC_API
-hs_error_t hs_compile_ext_multi(const char * const *expressions,
- const unsigned *flags, const unsigned *ids,
- const hs_expr_ext * const *ext,
- unsigned elements, unsigned mode,
- const hs_platform_info_t *platform,
- hs_database_t **db,
- hs_compile_error_t **error) {
+hs_error_t HS_CDECL hs_compile_ext_multi(const char * const *expressions,
+ const unsigned *flags, const unsigned *ids,
+ const hs_expr_ext * const *ext,
+ unsigned elements, unsigned mode,
+ const hs_platform_info_t *platform,
+ hs_database_t **db,
+ hs_compile_error_t **error) {
return hs_compile_multi_int(expressions, flags, ids, ext, elements, mode,
platform, db, error, Grey());
}
}
extern "C" HS_PUBLIC_API
-hs_error_t hs_expression_info(const char *expression, unsigned int flags,
- hs_expr_info_t **info,
- hs_compile_error_t **error) {
+hs_error_t HS_CDECL hs_expression_info(const char *expression,
+ unsigned int flags,
+ hs_expr_info_t **info,
+ hs_compile_error_t **error) {
return hs_expression_info_int(expression, flags, nullptr, HS_MODE_BLOCK,
info, error);
}
extern "C" HS_PUBLIC_API
-hs_error_t hs_expression_ext_info(const char *expression, unsigned int flags,
- const hs_expr_ext_t *ext,
- hs_expr_info_t **info,
- hs_compile_error_t **error) {
+hs_error_t HS_CDECL hs_expression_ext_info(const char *expression,
+ unsigned int flags,
+ const hs_expr_ext_t *ext,
+ hs_expr_info_t **info,
+ hs_compile_error_t **error) {
return hs_expression_info_int(expression, flags, ext, HS_MODE_BLOCK, info,
error);
}
extern "C" HS_PUBLIC_API
-hs_error_t hs_populate_platform(hs_platform_info_t *platform) {
+hs_error_t HS_CDECL hs_populate_platform(hs_platform_info_t *platform) {
if (!platform) {
return HS_INVALID;
}
}
extern "C" HS_PUBLIC_API
-hs_error_t hs_free_compile_error(hs_compile_error_t *error) {
+hs_error_t HS_CDECL hs_free_compile_error(hs_compile_error_t *error) {
#if defined(FAT_RUNTIME)
if (!check_ssse3()) {
return HS_ARCH_ERROR;
#ifndef HS_COMMON_H_
#define HS_COMMON_H_
+#if defined(_WIN32)
+#define HS_CDECL __cdecl
+#else
+#define HS_CDECL
+#endif
#include <stdlib.h>
/**
* @return
* @ref HS_SUCCESS on success, other values on failure.
*/
-hs_error_t hs_free_database(hs_database_t *db);
+hs_error_t HS_CDECL hs_free_database(hs_database_t *db);
/**
* Serialize a pattern database to a stream of bytes.
* @ref HS_SUCCESS on success, @ref HS_NOMEM if the byte array cannot be
* allocated, other values may be returned if errors are detected.
*/
-hs_error_t hs_serialize_database(const hs_database_t *db, char **bytes,
- size_t *length);
+hs_error_t HS_CDECL hs_serialize_database(const hs_database_t *db, char **bytes,
+ size_t *length);
/**
* Reconstruct a pattern database from a stream of bytes previously generated
* @return
* @ref HS_SUCCESS on success, other values on failure.
*/
-hs_error_t hs_deserialize_database(const char *bytes, const size_t length,
- hs_database_t **db);
+hs_error_t HS_CDECL hs_deserialize_database(const char *bytes,
+ const size_t length,
+ hs_database_t **db);
/**
* Reconstruct a pattern database from a stream of bytes previously generated
* @return
* @ref HS_SUCCESS on success, other values on failure.
*/
-hs_error_t hs_deserialize_database_at(const char *bytes, const size_t length,
- hs_database_t *db);
+hs_error_t HS_CDECL hs_deserialize_database_at(const char *bytes,
+ const size_t length,
+ hs_database_t *db);
/**
* Provides the size of the stream state allocated by a single stream opened
* @return
* @ref HS_SUCCESS on success, other values on failure.
*/
-hs_error_t hs_stream_size(const hs_database_t *database, size_t *stream_size);
+hs_error_t HS_CDECL hs_stream_size(const hs_database_t *database,
+ size_t *stream_size);
/**
* Provides the size of the given database in bytes.
* @return
* @ref HS_SUCCESS on success, other values on failure.
*/
-hs_error_t hs_database_size(const hs_database_t *database,
- size_t *database_size);
+hs_error_t HS_CDECL hs_database_size(const hs_database_t *database,
+ size_t *database_size);
/**
* Utility function for reporting the size that would be required by a
* @return
* @ref HS_SUCCESS on success, other values on failure.
*/
-hs_error_t hs_serialized_database_size(const char *bytes, const size_t length,
- size_t *deserialized_size);
+hs_error_t HS_CDECL hs_serialized_database_size(const char *bytes,
+ const size_t length,
+ size_t *deserialized_size);
/**
* Utility function providing information about a database.
* @return
* @ref HS_SUCCESS on success, other values on failure.
*/
-hs_error_t hs_database_info(const hs_database_t *database, char **info);
+hs_error_t HS_CDECL hs_database_info(const hs_database_t *database,
+ char **info);
/**
* Utility function providing information about a serialized database.
* @return
* @ref HS_SUCCESS on success, other values on failure.
*/
-hs_error_t hs_serialized_database_info(const char *bytes, size_t length,
- char **info);
+hs_error_t HS_CDECL hs_serialized_database_info(const char *bytes,
+ size_t length, char **info);
/**
* The type of the callback function that will be used by Hyperscan to allocate
* @return
* A pointer to the region of memory allocated, or NULL on error.
*/
-typedef void *(*hs_alloc_t)(size_t size);
+typedef void *(HS_CDECL *hs_alloc_t)(size_t size);
/**
* The type of the callback function that will be used by Hyperscan to free
* @param ptr
* The region of memory to be freed.
*/
-typedef void (*hs_free_t)(void *ptr);
+typedef void (HS_CDECL *hs_free_t)(void *ptr);
/**
* Set the allocate and free functions used by Hyperscan for allocating
* @return
* @ref HS_SUCCESS on success, other values on failure.
*/
-hs_error_t hs_set_allocator(hs_alloc_t alloc_func, hs_free_t free_func);
+hs_error_t HS_CDECL hs_set_allocator(hs_alloc_t alloc_func,
+ hs_free_t free_func);
/**
* Set the allocate and free functions used by Hyperscan for allocating memory
* @return
* @ref HS_SUCCESS on success, other values on failure.
*/
-hs_error_t hs_set_database_allocator(hs_alloc_t alloc_func,
- hs_free_t free_func);
+hs_error_t HS_CDECL hs_set_database_allocator(hs_alloc_t alloc_func,
+ hs_free_t free_func);
/**
* Set the allocate and free functions used by Hyperscan for allocating memory
* @return
* @ref HS_SUCCESS on success, other values on failure.
*/
-hs_error_t hs_set_misc_allocator(hs_alloc_t alloc_func, hs_free_t free_func);
+hs_error_t HS_CDECL hs_set_misc_allocator(hs_alloc_t alloc_func,
+ hs_free_t free_func);
/**
* Set the allocate and free functions used by Hyperscan for allocating memory
* @return
* @ref HS_SUCCESS on success, other values on failure.
*/
-hs_error_t hs_set_scratch_allocator(hs_alloc_t alloc_func, hs_free_t free_func);
+hs_error_t HS_CDECL hs_set_scratch_allocator(hs_alloc_t alloc_func,
+ hs_free_t free_func);
/**
* Set the allocate and free functions used by Hyperscan for allocating memory
* @return
* @ref HS_SUCCESS on success, other values on failure.
*/
-hs_error_t hs_set_stream_allocator(hs_alloc_t alloc_func, hs_free_t free_func);
+hs_error_t HS_CDECL hs_set_stream_allocator(hs_alloc_t alloc_func,
+ hs_free_t free_func);
/**
* Utility function for identifying this release version.
* date of the build. It is allocated statically, so it does not need to
* be freed by the caller.
*/
-const char *hs_version(void);
+const char * HS_CDECL hs_version(void);
/**
* Utility function to test the current system architecture.
* @ref HS_SUCCESS on success, @ref HS_ARCH_ERROR if system does not
* support Hyperscan.
*/
-hs_error_t hs_valid_platform(void);
+hs_error_t HS_CDECL hs_valid_platform(void);
/**
* @defgroup HS_ERROR hs_error_t values
* HS_COMPILER_ERROR on failure, with details provided in the error
* parameter.
*/
-hs_error_t hs_compile(const char *expression, unsigned int flags,
- unsigned int mode, const hs_platform_info_t *platform,
- hs_database_t **db, hs_compile_error_t **error);
+hs_error_t HS_CDECL hs_compile(const char *expression, unsigned int flags,
+ unsigned int mode,
+ const hs_platform_info_t *platform,
+ hs_database_t **db, hs_compile_error_t **error);
/**
* The multiple regular expression compiler.
* parameter.
*
*/
-hs_error_t hs_compile_multi(const char *const *expressions,
- const unsigned int *flags, const unsigned int *ids,
- unsigned int elements, unsigned int mode,
- const hs_platform_info_t *platform,
- hs_database_t **db, hs_compile_error_t **error);
+hs_error_t HS_CDECL hs_compile_multi(const char *const *expressions,
+ const unsigned int *flags,
+ const unsigned int *ids,
+ unsigned int elements, unsigned int mode,
+ const hs_platform_info_t *platform,
+ hs_database_t **db,
+ hs_compile_error_t **error);
/**
* The multiple regular expression compiler with extended parameter support.
* parameter.
*
*/
-hs_error_t hs_compile_ext_multi(const char *const *expressions,
+hs_error_t HS_CDECL hs_compile_ext_multi(const char *const *expressions,
const unsigned int *flags,
const unsigned int *ids,
const hs_expr_ext_t *const *ext,
* @return
* @ref HS_SUCCESS on success, other values on failure.
*/
-hs_error_t hs_free_compile_error(hs_compile_error_t *error);
+hs_error_t HS_CDECL hs_free_compile_error(hs_compile_error_t *error);
/**
* Utility function providing information about a regular expression. The
* HS_COMPILER_ERROR on failure, with details provided in the error
* parameter.
*/
-hs_error_t hs_expression_info(const char *expression, unsigned int flags,
- hs_expr_info_t **info,
- hs_compile_error_t **error);
+hs_error_t HS_CDECL hs_expression_info(const char *expression,
+ unsigned int flags,
+ hs_expr_info_t **info,
+ hs_compile_error_t **error);
/**
* Utility function providing information about a regular expression, with
* HS_COMPILER_ERROR on failure, with details provided in the error
* parameter.
*/
-hs_error_t hs_expression_ext_info(const char *expression, unsigned int flags,
- const hs_expr_ext_t *ext,
- hs_expr_info_t **info,
- hs_compile_error_t **error);
+hs_error_t HS_CDECL hs_expression_ext_info(const char *expression,
+ unsigned int flags,
+ const hs_expr_ext_t *ext,
+ hs_expr_info_t **info,
+ hs_compile_error_t **error);
/**
* Populates the platform information based on the current host.
* @return
* @ref HS_SUCCESS on success, other values on failure.
*/
-hs_error_t hs_populate_platform(hs_platform_info_t *platform);
+hs_error_t HS_CDECL hs_populate_platform(hs_platform_info_t *platform);
/**
* @defgroup HS_PATTERN_FLAG Pattern flags
/*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2017, Intel Corporation
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* @return
* @ref HS_SUCCESS on success, other values on failure.
*/
-hs_error_t hs_open_stream(const hs_database_t *db, unsigned int flags,
- hs_stream_t **stream);
+hs_error_t HS_CDECL hs_open_stream(const hs_database_t *db, unsigned int flags,
+ hs_stream_t **stream);
/**
* Write data to be scanned to the opened stream.
* match callback indicated that scanning should stop; other values on
* error.
*/
-hs_error_t hs_scan_stream(hs_stream_t *id, const char *data,
- unsigned int length, unsigned int flags,
- hs_scratch_t *scratch, match_event_handler onEvent,
- void *ctxt);
+hs_error_t HS_CDECL hs_scan_stream(hs_stream_t *id, const char *data,
+ unsigned int length, unsigned int flags,
+ hs_scratch_t *scratch,
+ match_event_handler onEvent, void *ctxt);
/**
* Close a stream.
* @return
* Returns @ref HS_SUCCESS on success, other values on failure.
*/
-hs_error_t hs_close_stream(hs_stream_t *id, hs_scratch_t *scratch,
- match_event_handler onEvent, void *ctxt);
+hs_error_t HS_CDECL hs_close_stream(hs_stream_t *id, hs_scratch_t *scratch,
+ match_event_handler onEvent, void *ctxt);
/**
* Reset a stream to an initial state.
* @return
* @ref HS_SUCCESS on success, other values on failure.
*/
-hs_error_t hs_reset_stream(hs_stream_t *id, unsigned int flags,
- hs_scratch_t *scratch, match_event_handler onEvent,
- void *context);
+hs_error_t HS_CDECL hs_reset_stream(hs_stream_t *id, unsigned int flags,
+ hs_scratch_t *scratch,
+ match_event_handler onEvent, void *context);
/**
* Duplicate the given stream. The new stream will have the same state as the
* @return
* @ref HS_SUCCESS on success, other values on failure.
*/
-hs_error_t hs_copy_stream(hs_stream_t **to_id, const hs_stream_t *from_id);
+hs_error_t HS_CDECL hs_copy_stream(hs_stream_t **to_id,
+ const hs_stream_t *from_id);
/**
* Duplicate the given 'from' stream state onto the 'to' stream. The 'to' stream
* @return
* @ref HS_SUCCESS on success, other values on failure.
*/
-hs_error_t hs_reset_and_copy_stream(hs_stream_t *to_id,
- const hs_stream_t *from_id,
- hs_scratch_t *scratch,
- match_event_handler onEvent,
- void *context);
+hs_error_t HS_CDECL hs_reset_and_copy_stream(hs_stream_t *to_id,
+ const hs_stream_t *from_id,
+ hs_scratch_t *scratch,
+ match_event_handler onEvent,
+ void *context);
/**
* The block (non-streaming) regular expression scanner.
* match callback indicated that scanning should stop; other values on
* error.
*/
-hs_error_t hs_scan(const hs_database_t *db, const char *data,
- unsigned int length, unsigned int flags,
- hs_scratch_t *scratch, match_event_handler onEvent,
- void *context);
+hs_error_t HS_CDECL hs_scan(const hs_database_t *db, const char *data,
+ unsigned int length, unsigned int flags,
+ hs_scratch_t *scratch, match_event_handler onEvent,
+ void *context);
/**
* The vectored regular expression scanner.
* Returns @ref HS_SUCCESS on success; @ref HS_SCAN_TERMINATED if the match
* callback indicated that scanning should stop; other values on error.
*/
-hs_error_t hs_scan_vector(const hs_database_t *db, const char *const *data,
- const unsigned int *length, unsigned int count,
- unsigned int flags, hs_scratch_t *scratch,
- match_event_handler onEvent, void *context);
+hs_error_t HS_CDECL hs_scan_vector(const hs_database_t *db,
+ const char *const *data,
+ const unsigned int *length,
+ unsigned int count, unsigned int flags,
+ hs_scratch_t *scratch,
+ match_event_handler onEvent, void *context);
/**
* Allocate a "scratch" space for use by Hyperscan.
* allocation fails. Other errors may be returned if invalid parameters
* are specified.
*/
-hs_error_t hs_alloc_scratch(const hs_database_t *db, hs_scratch_t **scratch);
+hs_error_t HS_CDECL hs_alloc_scratch(const hs_database_t *db,
+ hs_scratch_t **scratch);
/**
* Allocate a scratch space that is a clone of an existing scratch space.
* @ref HS_SUCCESS on success; @ref HS_NOMEM if the allocation fails.
* Other errors may be returned if invalid parameters are specified.
*/
-hs_error_t hs_clone_scratch(const hs_scratch_t *src, hs_scratch_t **dest);
+hs_error_t HS_CDECL hs_clone_scratch(const hs_scratch_t *src,
+ hs_scratch_t **dest);
/**
* Provides the size of the given scratch space.
* @return
* @ref HS_SUCCESS on success, other values on failure.
*/
-hs_error_t hs_scratch_size(const hs_scratch_t *scratch, size_t *scratch_size);
+hs_error_t HS_CDECL hs_scratch_size(const hs_scratch_t *scratch,
+ size_t *scratch_size);
/**
* Free a scratch block previously allocated by @ref hs_alloc_scratch() or @ref
* @return
* @ref HS_SUCCESS on success, other values on failure.
*/
-hs_error_t hs_free_scratch(hs_scratch_t *scratch);
+hs_error_t HS_CDECL hs_free_scratch(hs_scratch_t *scratch);
/**
* Callback 'from' return value, indicating that the start of this match was
/*
- * Copyright (c) 2016, Intel Corporation
+ * Copyright (c) 2016-2017, Intel Corporation
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
#include "util/cpuid_flags.h"
HS_PUBLIC_API
-hs_error_t hs_valid_platform(void) {
+hs_error_t HS_CDECL hs_valid_platform(void) {
/* Hyperscan requires SSSE3, anything else is a bonus */
if (check_ssse3()) {
return HS_SUCCESS;
/*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2017, Intel Corporation
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
#include "hs_version.h"
HS_PUBLIC_API
-const char *hs_version(void) {
+const char * HS_CDECL hs_version(void) {
return HS_VERSION_STRING;
}
}
HS_PUBLIC_API
-hs_error_t hs_scan(const hs_database_t *db, const char *data, unsigned length,
- unsigned flags, hs_scratch_t *scratch,
- match_event_handler onEvent, void *userCtx) {
+hs_error_t HS_CDECL hs_scan(const hs_database_t *db, const char *data,
+ unsigned length, unsigned flags,
+ hs_scratch_t *scratch, match_event_handler onEvent,
+ void *userCtx) {
if (unlikely(!scratch || !data)) {
return HS_INVALID;
}
}
HS_PUBLIC_API
-hs_error_t hs_open_stream(const hs_database_t *db, UNUSED unsigned flags,
- hs_stream_t **stream) {
+hs_error_t HS_CDECL hs_open_stream(const hs_database_t *db,
+ UNUSED unsigned flags,
+ hs_stream_t **stream) {
if (unlikely(!stream)) {
return HS_INVALID;
}
}
HS_PUBLIC_API
-hs_error_t hs_copy_stream(hs_stream_t **to_id, const hs_stream_t *from_id) {
+hs_error_t HS_CDECL hs_copy_stream(hs_stream_t **to_id,
+ const hs_stream_t *from_id) {
if (!to_id) {
return HS_INVALID;
}
}
HS_PUBLIC_API
-hs_error_t hs_reset_and_copy_stream(hs_stream_t *to_id,
- const hs_stream_t *from_id,
- hs_scratch_t *scratch,
- match_event_handler onEvent,
- void *context) {
+hs_error_t HS_CDECL hs_reset_and_copy_stream(hs_stream_t *to_id,
+ const hs_stream_t *from_id,
+ hs_scratch_t *scratch,
+ match_event_handler onEvent,
+ void *context) {
if (!from_id || !from_id->rose) {
return HS_INVALID;
}
}
HS_PUBLIC_API
-hs_error_t hs_scan_stream(hs_stream_t *id, const char *data, unsigned length,
- unsigned flags, hs_scratch_t *scratch,
- match_event_handler onEvent, void *context) {
+hs_error_t HS_CDECL hs_scan_stream(hs_stream_t *id, const char *data,
+ unsigned length, unsigned flags,
+ hs_scratch_t *scratch,
+ match_event_handler onEvent, void *context) {
if (unlikely(!id || !scratch || !data ||
!validScratch(id->rose, scratch))) {
return HS_INVALID;
}
HS_PUBLIC_API
-hs_error_t hs_close_stream(hs_stream_t *id, hs_scratch_t *scratch,
- match_event_handler onEvent, void *context) {
+hs_error_t HS_CDECL hs_close_stream(hs_stream_t *id, hs_scratch_t *scratch,
+ match_event_handler onEvent,
+ void *context) {
if (!id) {
return HS_INVALID;
}
}
HS_PUBLIC_API
-hs_error_t hs_reset_stream(hs_stream_t *id, UNUSED unsigned int flags,
- hs_scratch_t *scratch, match_event_handler onEvent,
- void *context) {
+hs_error_t HS_CDECL hs_reset_stream(hs_stream_t *id, UNUSED unsigned int flags,
+ hs_scratch_t *scratch,
+ match_event_handler onEvent,
+ void *context) {
if (!id) {
return HS_INVALID;
}
}
HS_PUBLIC_API
-hs_error_t hs_stream_size(const hs_database_t *db, size_t *stream_size) {
+hs_error_t HS_CDECL hs_stream_size(const hs_database_t *db,
+ size_t *stream_size) {
if (!stream_size) {
return HS_INVALID;
}
#endif
HS_PUBLIC_API
-hs_error_t hs_scan_vector(const hs_database_t *db, const char * const * data,
- const unsigned int *length, unsigned int count,
- UNUSED unsigned int flags, hs_scratch_t *scratch,
- match_event_handler onEvent, void *context) {
+hs_error_t HS_CDECL hs_scan_vector(const hs_database_t *db,
+ const char * const * data,
+ const unsigned int *length,
+ unsigned int count,
+ UNUSED unsigned int flags,
+ hs_scratch_t *scratch,
+ match_event_handler onEvent, void *context) {
if (unlikely(!scratch || !data || !length)) {
return HS_INVALID;
}
/*
- * Copyright (c) 2015-2016, Intel Corporation
+ * Copyright (c) 2015-2017, Intel Corporation
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
}
HS_PUBLIC_API
-hs_error_t hs_alloc_scratch(const hs_database_t *db, hs_scratch_t **scratch) {
+hs_error_t HS_CDECL hs_alloc_scratch(const hs_database_t *db,
+ hs_scratch_t **scratch) {
if (!db || !scratch) {
return HS_INVALID;
}
}
HS_PUBLIC_API
-hs_error_t hs_clone_scratch(const hs_scratch_t *src, hs_scratch_t **dest) {
+hs_error_t HS_CDECL hs_clone_scratch(const hs_scratch_t *src,
+ hs_scratch_t **dest) {
if (!dest || !src || !ISALIGNED_CL(src) || src->magic != SCRATCH_MAGIC) {
return HS_INVALID;
}
}
HS_PUBLIC_API
-hs_error_t hs_free_scratch(hs_scratch_t *scratch) {
+hs_error_t HS_CDECL hs_free_scratch(hs_scratch_t *scratch) {
if (scratch) {
/* has to be aligned before we can do anything with it */
if (!ISALIGNED_CL(scratch)) {
}
HS_PUBLIC_API
-hs_error_t hs_scratch_size(const hs_scratch_t *scratch, size_t *size) {
+hs_error_t HS_CDECL hs_scratch_size(const hs_scratch_t *scratch, size_t *size) {
if (!size || !scratch || !ISALIGNED_CL(scratch) ||
scratch->magic != SCRATCH_MAGIC) {
return HS_INVALID;
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-array-bounds")
endif()
-add_library(gtest STATIC ${gtest_SOURCES})
-
add_definitions(-DGTEST_HAS_PTHREAD=0 -DSRCDIR=${PROJECT_SOURCE_DIR})
+set(unit_hyperscan_SOURCES
+ ${gtest_SOURCES}
+ hyperscan/allocators.cpp
+ hyperscan/arg_checks.cpp
+ hyperscan/bad_patterns.cpp
+ hyperscan/bad_patterns.txt
+ hyperscan/behaviour.cpp
+ hyperscan/expr_info.cpp
+ hyperscan/extparam.cpp
+ hyperscan/identical.cpp
+ hyperscan/main.cpp
+ hyperscan/multi.cpp
+ hyperscan/order.cpp
+ hyperscan/scratch_op.cpp
+ hyperscan/scratch_in_use.cpp
+ hyperscan/serialize.cpp
+ hyperscan/single.cpp
+ hyperscan/som.cpp
+ hyperscan/stream_op.cpp
+ hyperscan/test_util.cpp
+ hyperscan/test_util.h
+ )
+add_executable(unit-hyperscan ${unit_hyperscan_SOURCES})
+if (BUILD_STATIC_AND_SHARED OR BUILD_SHARED_LIBS)
+target_link_libraries(unit-hyperscan hs_shared expressionutil)
+else()
+target_link_libraries(unit-hyperscan hs expressionutil)
+endif()
+
+
if (NOT (RELEASE_BUILD OR FAT_RUNTIME))
set(unit_internal_SOURCES
+ ${gtest_SOURCES}
internal/bitfield.cpp
internal/bitutils.cpp
internal/charreach.cpp
internal/util_string.cpp
internal/vermicelli.cpp
internal/main.cpp
-)
+ )
add_executable(unit-internal ${unit_internal_SOURCES})
-target_link_libraries(unit-internal hs gtest corpusomatic)
+set_target_properties(unit-internal PROPERTIES COMPILE_FLAGS "${HS_CXX_FLAGS}")
+target_link_libraries(unit-internal hs corpusomatic)
endif(NOT (RELEASE_BUILD OR FAT_RUNTIME))
-set(unit_hyperscan_SOURCES
- hyperscan/allocators.cpp
- hyperscan/arg_checks.cpp
- hyperscan/bad_patterns.cpp
- hyperscan/bad_patterns.txt
- hyperscan/behaviour.cpp
- hyperscan/expr_info.cpp
- hyperscan/extparam.cpp
- hyperscan/identical.cpp
- hyperscan/main.cpp
- hyperscan/multi.cpp
- hyperscan/order.cpp
- hyperscan/scratch_op.cpp
- hyperscan/scratch_in_use.cpp
- hyperscan/serialize.cpp
- hyperscan/single.cpp
- hyperscan/som.cpp
- hyperscan/stream_op.cpp
- hyperscan/test_util.cpp
- hyperscan/test_util.h
- )
-add_executable(unit-hyperscan ${unit_hyperscan_SOURCES})
-if (BUILD_STATIC_AND_SHARED OR BUILD_SHARED_LIBS)
-target_link_libraries(unit-hyperscan hs_shared gtest expressionutil)
-else()
-target_link_libraries(unit-hyperscan hs gtest expressionutil)
-endif()
-
#
# build target to run unit tests
#
/*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2017, Intel Corporation
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*/
#include "gtest/gtest.h"
+#include "hs_common.h"
// Driver: run all the tests (defined in other source files in this directory)
-int main(int argc, char **argv) {
+int HS_CDECL main(int argc, char **argv) {
testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
/*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2017, Intel Corporation
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
TEST_P(ValidUtf8Test, check) {
const auto &info = GetParam();
- ASSERT_EQ(info.is_valid, isValidUtf8(info.str.c_str()))
- << "String is: " << printable(info.str) << std::endl;
+ SCOPED_TRACE(testing::Message() << "String is: " << printable(info.str));
+ ASSERT_EQ(info.is_valid, isValidUtf8(info.str.c_str()));
}
CHECK_FUNCTION_EXISTS(mmap HAVE_MMAP)
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${EXTRA_CXX_FLAGS}")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${EXTRA_CXX_FLAGS} ${HS_CXX_FLAGS}")
include_directories(${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR}
${PROJECT_SOURCE_DIR})
/*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2017, Intel Corporation
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
#ifndef EXPRESSIONPARSER_H
#define EXPRESSIONPARSER_H
+#include "hs_common.h"
+
#include <string>
struct hs_expr_ext;
-bool readExpression(const std::string &line, std::string &expr,
- unsigned int *flags, hs_expr_ext *ext,
- bool *must_be_ordered = nullptr);
+bool HS_CDECL readExpression(const std::string &line, std::string &expr,
+ unsigned int *flags, hs_expr_ext *ext,
+ bool *must_be_ordered = nullptr);
#endif
ext->max_offset = MAX_OFFSET;
}
-bool readExpression(const std::string &input, std::string &expr,
- unsigned int *flags, hs_expr_ext *ext,
- bool *must_be_ordered) {
+bool HS_CDECL readExpression(const std::string &input, std::string &expr,
+ unsigned int *flags, hs_expr_ext *ext,
+ bool *must_be_ordered) {
assert(flags);
assert(ext);
#define S_ISDIR(st_m) (_S_IFDIR & (st_m))
#define S_ISREG(st_m) (_S_IFREG & (st_m))
#endif
-void loadExpressionsFromFile(const string &fname, ExpressionMap &exprMap) {
+void HS_CDECL loadExpressionsFromFile(const string &fname, ExpressionMap &exprMap) {
struct stat st;
if (stat(fname.c_str(), &st) != 0) {
return;
}
}
#else // windows TODO: improve
-void loadExpressions(const string &inPath, ExpressionMap &exprMap) {
+void HS_CDECL loadExpressions(const string &inPath, ExpressionMap &exprMap) {
// Is our input path a file or a directory?
struct stat st;
if (stat(inPath.c_str(), &st) != 0) {
}
#endif
-void loadSignatureList(const string &inFile,
- SignatureSet &signatures) {
+void HS_CDECL loadSignatureList(const string &inFile,
+ SignatureSet &signatures) {
ifstream f(inFile.c_str());
if (!f.good()) {
cerr << "Can't open file: '" << inFile << "'" << endl;
#ifndef EXPRESSIONS_H
#define EXPRESSIONS_H
+#include "hs_common.h"
+
#include <map>
#include <string>
#include <vector>
// load all of the expressions from the given directory into the given
// expression map. Exits on failure.
-void loadExpressions(const std::string &inDir, ExpressionMap &exprMap);
+void HS_CDECL loadExpressions(const std::string &inDir, ExpressionMap &exprMap);
-void loadExpressionsFromFile(const std::string &fname, ExpressionMap &exprMap);
+void HS_CDECL loadExpressionsFromFile(const std::string &fname, ExpressionMap &exprMap);
// load a list of signature IDs
-void loadSignatureList(const std::string &inFile, SignatureSet &signatures);
+void HS_CDECL loadSignatureList(const std::string &inFile, SignatureSet &signatures);
// trim expression map to only the given signatures, returning result
ExpressionMap limitToSignatures(const ExpressionMap &exprMap,
projects / thirdparty / vectorscan.git / commitdiff
