cs_result_defs.hpp

Go to the documentation of this file.

/*
 *      Copyright (c) 2023, an unpublished work by CodeSecure, Inc.
 *                      ALL RIGHTS RESERVED
 *
 *      Copyright (c) 2013-2023, an unpublished work by GrammaTech, Inc.
 *                      ALL RIGHTS RESERVED
 *
 *      This software is furnished under a license and may be used and
 *      copied only in accordance with the terms of such license and the
 *      inclusion of the above copyright notice.  This software or any
 *      other copies thereof may not be provided or otherwise made
 *      available to any other person.  Title to and ownership of the
 *      software is retained by CodeSecure, Inc.
 */
#ifdef CS_CPP_IMPL
const result result::SUCCESS = result(CS_SUCCESS);
const result result::OUT_OF_ELEMENTS = result(CS_OUT_OF_ELEMENTS);
const result result::TRUNCATED = result(CS_TRUNCATED);
const result result::ELEMENT_NOT_PRESENT = result(CS_ELEMENT_NOT_PRESENT);
const result result::ELEMENT_ALREADY_PRESENT = result(CS_ELEMENT_ALREADY_PRESENT);
const result result::REPLACED = result(CS_REPLACED);
const result result::NO_LOWER_BOUND = result(CS_NO_LOWER_BOUND);
const result result::NO_UPPER_BOUND = result(CS_NO_UPPER_BOUND);
const result result::NO_BOUNDS = result(CS_NO_BOUNDS);
const result result::NOT_A_MANGLED_NAME = result(CS_NOT_A_MANGLED_NAME);
const result result::DEMANGLE_FAILED = result(CS_DEMANGLE_FAILED);
const result result::GENERATED_COMPILATION = result(CS_GENERATED_COMPILATION);
const result result::NO_SOURCE_CORRESPONDENCE = result(CS_NO_SOURCE_CORRESPONDENCE);
const result result::FILTERED_OUT = result(CS_FILTERED_OUT);
const result result::ABS_LOC_HAS_NO_PARENT = result(CS_ABS_LOC_HAS_NO_PARENT);
const result result::ABS_LOC_HAS_NO_INLINE_SOURCE = result(CS_ABS_LOC_HAS_NO_INLINE_SOURCE);
const result result::DECLARATIONS_UNKNOWN = result(CS_DECLARATIONS_UNKNOWN);
const result result::NO_PRIMARY_DECLARATION = result(CS_NO_PRIMARY_DECLARATION);
const result result::ABS_LOC_NOT_FUNCTION = result(CS_ABS_LOC_NOT_FUNCTION);
const result result::ABS_LOC_HAS_NO_PDG = result(CS_ABS_LOC_HAS_NO_PDG);
const result result::NO_REPRESENTED_STRING = result(CS_NO_REPRESENTED_STRING);
const result result::ABS_LOC_IS_GLOBAL = result(CS_ABS_LOC_IS_GLOBAL);
const result result::ABS_LOC_PDG_UNDEFINED = result(CS_ABS_LOC_PDG_UNDEFINED);
const result result::PDG_NOT_FOUND = result(CS_PDG_NOT_FOUND);
const result result::PDG_IS_UNDEFINED = result(CS_PDG_IS_UNDEFINED);
const result result::PDG_VERTEX_HAS_NO_SYMBOL = result(CS_PDG_VERTEX_HAS_NO_SYMBOL);
const result result::PDG_VERTEX_HAS_ZERO_OR_MULTIPLE_SUCCESSORS = result(CS_PDG_VERTEX_HAS_ZERO_OR_MULTIPLE_SUCCESSORS);
const result result::PDG_VERTEX_HAS_ZERO_OR_MULTIPLE_PREDECESSORS = result(CS_PDG_VERTEX_HAS_ZERO_OR_MULTIPLE_PREDECESSORS);
const result result::PDGV_NOT_IN_BASIC_BLOCK = result(CS_PDGV_NOT_IN_BASIC_BLOCK);
const result result::NO_SUCH_BASIC_BLOCK = result(CS_NO_SUCH_BASIC_BLOCK);
const result result::NO_SUCH_PDG_VERTEX = result(CS_NO_SUCH_PDG_VERTEX);
const result result::NO_SUCH_PDG = result(CS_NO_SUCH_PDG);
const result result::PDG_HAS_NO_NORMAL_EXIT = result(CS_PDG_HAS_NO_NORMAL_EXIT);
const result result::PDG_HAS_NO_NORMAL_RETURN = result(CS_PDG_HAS_NO_NORMAL_RETURN);
const result result::VERTEX_HAS_NO_RANK = result(CS_VERTEX_HAS_NO_RANK);
const result result::NO_POSITION = result(CS_NO_POSITION);
const result result::NOT_IMPLEMENTED = result(CS_NOT_IMPLEMENTED);
const result result::CALLER_SHOULD_HANDLE = result(CS_CALLER_SHOULD_HANDLE);
const result result::FRONT_END_DOES_NOT_IMPLEMENT_FEATURE = result(CS_FRONT_END_DOES_NOT_IMPLEMENT_FEATURE);
const result result::DISCRETIONARY_ERROR_IO_PARTIAL_READ = result(CS_DISCRETIONARY_ERROR_IO_PARTIAL_READ);
const result result::ERROR_INVALID_SDG = result(CS_ERROR_INVALID_SDG);
const result result::PATH_INFEASIBLE = result(CS_PATH_INFEASIBLE);
const result result::ERROR_INVALID_SDG_STORE = result(CS_ERROR_INVALID_SDG_STORE);
const result result::ERROR_INVALID_OPERATOR = result(CS_ERROR_INVALID_OPERATOR);
const result result::ERROR_INVALID_ATTRIBUTE = result(CS_ERROR_INVALID_ATTRIBUTE);
const result result::ERROR_SDG_NOT_PRESENT = result(CS_ERROR_SDG_NOT_PRESENT);
const result result::ERROR_AN_SDG_ALREADY_PRESENT = result(CS_ERROR_AN_SDG_ALREADY_PRESENT);
const result result::ERROR_NO_CFG_EDGES = result(CS_ERROR_NO_CFG_EDGES);
const result result::ERROR_NO_INTER_CFG_EDGES = result(CS_ERROR_NO_INTER_CFG_EDGES);
const result result::ERROR_NO_USE_DEF_SETS = result(CS_ERROR_NO_USE_DEF_SETS);
const result result::ERROR_NO_BACKWARD_CFG_EDGES = result(CS_ERROR_NO_BACKWARD_CFG_EDGES);
const result result::ERROR_NO_BASIC_BLOCKS = result(CS_ERROR_NO_BASIC_BLOCKS);
const result result::ERROR_NO_POINTER_ANALYSIS = result(CS_ERROR_NO_POINTER_ANALYSIS);
const result result::ERROR_NO_DECL_VERTICES = result(CS_ERROR_NO_DECL_VERTICES);
const result result::ERROR_NO_GMOD = result(CS_ERROR_NO_GMOD);
const result result::ERROR_NO_DATA_DEPENDENCE = result(CS_ERROR_NO_DATA_DEPENDENCE);
const result result::ERROR_NO_CONTROL_DEPENDENCE = result(CS_ERROR_NO_CONTROL_DEPENDENCE);
const result result::ERROR_NO_CONTROL_DEPENDENCE_LABELS = result(CS_ERROR_NO_CONTROL_DEPENDENCE_LABELS);
const result result::ERROR_NO_DEPENDENCES = result(CS_ERROR_NO_DEPENDENCES);
const result result::ERROR_NO_SUB_OBJECT_ABS_LOCS = result(CS_ERROR_NO_SUB_OBJECT_ABS_LOCS);
const result result::ERROR_NOT_IN_BATCH_MODE = result(CS_ERROR_NOT_IN_BATCH_MODE);
const result result::ERROR_IMMUTABLE_DATA_STRUCTURE = result(CS_ERROR_IMMUTABLE_DATA_STRUCTURE);
const result result::ERROR_CANNOT_FIND_PATH = result(CS_ERROR_CANNOT_FIND_PATH);
const result result::ERROR_INVALID_SFID = result(CS_ERROR_INVALID_SFID);
const result result::ERROR_INVALID_SFID_STRING = result(CS_ERROR_INVALID_SFID_STRING);
const result result::ERROR_INVALID_UNITLINE = result(CS_ERROR_INVALID_UNITLINE);
const result result::ERROR_LANGUAGE_NOT_FOUND = result(CS_ERROR_LANGUAGE_NOT_FOUND);
const result result::ERROR_NO_LICENSE = result(CS_ERROR_NO_LICENSE);
const result result::ERROR_LICENSE_VERIFICATION_FAILED = result(CS_ERROR_LICENSE_VERIFICATION_FAILED);
const result result::ERROR_LICENSE_LOCK_LOST = result(CS_ERROR_LICENSE_LOCK_LOST);
const result result::ERROR_NO_BUILDER_LICENSE = result(CS_ERROR_NO_BUILDER_LICENSE);
const result result::ERROR_NONINCR_TO_INCR = result(CS_ERROR_NONINCR_TO_INCR);
const result result::ERROR_PARAM_EVAL_ORDER_DIFFER = result(CS_ERROR_PARAM_EVAL_ORDER_DIFFER);
const result result::ERROR_CFG_EDGES_DIFFER = result(CS_ERROR_CFG_EDGES_DIFFER);
const result result::ERROR_BASIC_BLOCKS_DIFFER = result(CS_ERROR_BASIC_BLOCKS_DIFFER);
const result result::ERROR_DISPLAY_USES_EXPRS_DIFFER = result(CS_ERROR_DISPLAY_USES_EXPRS_DIFFER);
const result result::ERROR_BINARIES_PRESENT_DIFFER = result(CS_ERROR_BINARIES_PRESENT_DIFFER);
const result result::ERROR_PDG_VERTEX_TO_AST_MAPPING_DIFFER = result(CS_ERROR_PDG_VERTEX_TO_AST_MAPPING_DIFFER);
const result result::ERROR_RETAIN_UNNORMALIZED_C_AST_DIFFER = result(CS_ERROR_RETAIN_UNNORMALIZED_C_AST_DIFFER);
const result result::ERROR_COMPUTE_SSA_DIFFER = result(CS_ERROR_COMPUTE_SSA_DIFFER);
const result result::ERROR_PI_NODES_DIFFER = result(CS_ERROR_PI_NODES_DIFFER);
const result result::ERROR_NORM_DISJUNCTIVES_DIFFER = result(CS_ERROR_NORM_DISJUNCTIVES_DIFFER);
const result result::ERROR_INVALID_SET_KIND = result(CS_ERROR_INVALID_SET_KIND);
const result result::ERROR_INVALID_ABS_LOC_KIND = result(CS_ERROR_INVALID_ABS_LOC_KIND);
const result result::ERROR_UNKNOWN_ABS_LOC_KIND = result(CS_ERROR_UNKNOWN_ABS_LOC_KIND);
const result result::ERROR_INVALID_PDG_KIND = result(CS_ERROR_INVALID_PDG_KIND);
const result result::ERROR_INVALID_VERTEX_KIND = result(CS_ERROR_INVALID_VERTEX_KIND);
const result result::ERROR_INVALID_VERTEX_SYNTAX_KIND = result(CS_ERROR_INVALID_VERTEX_SYNTAX_KIND);
const result result::ERROR_INVALID_VERTEX_SYNTAX_ELEMENT = result(CS_ERROR_INVALID_VERTEX_SYNTAX_ELEMENT);
const result result::ERROR_INVALID_PDG_EDGE_KIND = result(CS_ERROR_INVALID_PDG_EDGE_KIND);
const result result::ERROR_INVALID_FILTER_PDG_DIRECTIVE = result(CS_ERROR_INVALID_FILTER_PDG_DIRECTIVE);
const result result::ERROR_INVALID_FILTER_PDG_VERTEX_DIRECTIVE = result(CS_ERROR_INVALID_FILTER_PDG_VERTEX_DIRECTIVE);
const result result::ERROR_INVALID_PS_ENUM = result(CS_ERROR_INVALID_PS_ENUM);
const result result::ERROR_NEGATIVE_THRESHOLD = result(CS_ERROR_NEGATIVE_THRESHOLD);
const result result::ERROR_FATOBJ_STORE_OPEN_FAILED = result(CS_ERROR_FATOBJ_STORE_OPEN_FAILED);
const result result::ERROR_FATOBJ_STORE_DIRTY = result(CS_ERROR_FATOBJ_STORE_DIRTY);
const result result::ERROR_IO_OPEN_FILE_TO_READ = result(CS_ERROR_IO_OPEN_FILE_TO_READ);
const result result::ERROR_IO_OPEN_FILE_TO_WRITE = result(CS_ERROR_IO_OPEN_FILE_TO_WRITE);
const result result::ERROR_IO_OPEN_FILE_LOCK_FAILURE = result(CS_ERROR_IO_OPEN_FILE_LOCK_FAILURE);
const result result::ERROR_IO_LOCK = result(CS_ERROR_IO_LOCK);
const result result::ERROR_IO_LOCKED_BY_OTHER = result(CS_ERROR_IO_LOCKED_BY_OTHER);
const result result::ERROR_IO_SEEK = result(CS_ERROR_IO_SEEK);
const result result::ERROR_IO_SEEK_TO_EOF = result(CS_ERROR_IO_SEEK_TO_EOF);
const result result::ERROR_IO_FLUSH = result(CS_ERROR_IO_FLUSH);
const result result::ERROR_IO_READ = result(CS_ERROR_IO_READ);
const result result::ERROR_IO_READ_ZERO = result(CS_ERROR_IO_READ_ZERO);
const result result::ERROR_IO_READ_TOO_MUCH = result(CS_ERROR_IO_READ_TOO_MUCH);
const result result::ERROR_IO_WRITE = result(CS_ERROR_IO_WRITE);
const result result::ERROR_IO_WRITE_ZERO = result(CS_ERROR_IO_WRITE_ZERO);
const result result::ERROR_IO_WRITE_TOO_MUCH = result(CS_ERROR_IO_WRITE_TOO_MUCH);
const result result::ERROR_IO_WRITE_TO_READ_ONLY = result(CS_ERROR_IO_WRITE_TO_READ_ONLY);
const result result::ERROR_IO_READ_PAST_EOF = result(CS_ERROR_IO_READ_PAST_EOF);
const result result::ERROR_IO_WRITE_PAST_EOF = result(CS_ERROR_IO_WRITE_PAST_EOF);
const result result::ERROR_IO_SEEK_PAST_EOF = result(CS_ERROR_IO_SEEK_PAST_EOF);
const result result::ERROR_IO_STAT = result(CS_ERROR_IO_STAT);
const result result::ERROR_IO_MOVE_EOF = result(CS_ERROR_IO_MOVE_EOF);
const result result::ERROR_IO_GET_EOF = result(CS_ERROR_IO_GET_EOF);
const result result::ERROR_IO_GET_POSITION = result(CS_ERROR_IO_GET_POSITION);
const result result::ERROR_IO_CLOSE = result(CS_ERROR_IO_CLOSE);
const result result::ERROR_IO_READ_BAD_CHECKSUM = result(CS_ERROR_IO_READ_BAD_CHECKSUM);
const result result::ERROR_IO_RENAME = result(CS_ERROR_IO_RENAME);
const result result::ERROR_INVALID_SEEK_RETURN_RANGE = result(CS_ERROR_INVALID_SEEK_RETURN_RANGE);
const result result::ERROR_INVALID_LINE_POSITION = result(CS_ERROR_INVALID_LINE_POSITION);
const result result::ERROR_PARAMETER_TOO_LARGE = result(CS_ERROR_PARAMETER_TOO_LARGE);
const result result::ERROR_FOREIGN_EXCEPTION = result(CS_ERROR_FOREIGN_EXCEPTION);
const result result::ERROR_FORK_FAILED = result(CS_ERROR_FORK_FAILED);
const result result::ERROR_CREATE_THREAD_FAILED = result(CS_ERROR_CREATE_THREAD_FAILED);
const result result::ERROR_NOT_A_CALL_SITE = result(CS_ERROR_NOT_A_CALL_SITE);
const result result::ERROR_NOT_AN_ACTUAL_IN = result(CS_ERROR_NOT_AN_ACTUAL_IN);
const result result::ERROR_NOT_AN_ACTUAL_OUT = result(CS_ERROR_NOT_AN_ACTUAL_OUT);
const result result::ERROR_NO_EXCEPTIONS_OR_ABNORMAL_EXITS = result(CS_ERROR_NO_EXCEPTIONS_OR_ABNORMAL_EXITS);
const result result::ERROR_DISALLOWED_SET_KIND = result(CS_ERROR_DISALLOWED_SET_KIND);
const result result::ERROR_NO_SUMMARY_EDGES = result(CS_ERROR_NO_SUMMARY_EDGES);
const result result::ERROR_NO_SCC = result(CS_ERROR_NO_SCC);
const result result::ERROR_UID_NOT_FOUND = result(CS_ERROR_UID_NOT_FOUND);
const result result::ERROR_INVALID_OFFSET = result(CS_ERROR_INVALID_OFFSET);
const result result::ERROR_COUNT_UNKNOWN_BUT_POSITIVE = result(CS_ERROR_COUNT_UNKNOWN_BUT_POSITIVE);
const result result::ERROR_COUNT_UNKNOWN = result(CS_ERROR_COUNT_UNKNOWN);
const result result::ERROR_INVALID_SFID_OR_LINE = result(CS_ERROR_INVALID_SFID_OR_LINE);
const result result::ERROR_INVALID_COLORING_ID = result(CS_ERROR_INVALID_COLORING_ID);
const result result::ERROR_INVALID_SYNTAX_KIND = result(CS_ERROR_INVALID_SYNTAX_KIND);
const result result::ERROR_INVALID_TOKDEF_KIND = result(CS_ERROR_INVALID_TOKDEF_KIND);
const result result::ERROR_NO_CONTAINER = result(CS_ERROR_NO_CONTAINER);
const result result::ERROR_GET_HOST_NAME_FAILED = result(CS_ERROR_GET_HOST_NAME_FAILED);
const result result::ERROR_GET_COMPUTER_NAME_FAILED = result(CS_ERROR_GET_COMPUTER_NAME_FAILED);
const result result::ERROR_GET_PW_UID_FAILED = result(CS_ERROR_GET_PW_UID_FAILED);
const result result::ERROR_GET_USER_NAME_FAILED = result(CS_ERROR_GET_USER_NAME_FAILED);
const result result::ERROR_INVALID_ARGUMENT = result(CS_ERROR_INVALID_ARGUMENT);
const result result::ERROR_OVERFLOW = result(CS_ERROR_OVERFLOW);
const result result::ERROR_OUT_OF_MEMORY = result(CS_ERROR_OUT_OF_MEMORY);
const result result::ERROR_INVALID_TYPE = result(CS_ERROR_INVALID_TYPE);
const result result::ERROR_NO_SUCH_PDG_HAMMOCK = result(CS_ERROR_NO_SUCH_PDG_HAMMOCK);
const result result::ERROR_HAMMOCK_NUM_EXIT_EDGE_SETS = result(CS_ERROR_HAMMOCK_NUM_EXIT_EDGE_SETS);
const result result::INTERNAL_STOP_TRAVERSAL = result(CS_INTERNAL_STOP_TRAVERSAL);
const result result::INCOMPATIBLE_ARGUMENTS = result(CS_INCOMPATIBLE_ARGUMENTS);
const result result::INVALID_DATA_FORMAT = result(CS_INVALID_DATA_FORMAT);
const result result::ERROR_GRAN_MISMATCH = result(CS_ERROR_GRAN_MISMATCH);
const result result::METRIC_NOT_COMPUTED = result(CS_METRIC_NOT_COMPUTED);
const result result::TIMEOUT = result(CS_TIMEOUT);
const result result::ERROR_MISMATCH = result(CS_ERROR_MISMATCH);
const result result::ERROR_INVALID_SLAVE_OPERATION = result(CS_ERROR_INVALID_SLAVE_OPERATION);
const result result::ERROR_INVALID_PHASE_FOR_OPERATION = result(CS_ERROR_INVALID_PHASE_FOR_OPERATION);
const result result::DISABLED = result(CS_DISABLED);
const result result::ERROR_CODESURFER_ONLY = result(CS_ERROR_CODESURFER_ONLY);
const result result::ERROR_CODESONAR_ONLY = result(CS_ERROR_CODESONAR_ONLY);
const result result::ERROR_INCOMPATIBLE_VERSION = result(CS_ERROR_INCOMPATIBLE_VERSION);
const result result::AMC_IS_BOTTOM = result(CS_AMC_IS_BOTTOM);
const result result::AMC_NOT_AVAILABLE = result(CS_AMC_NOT_AVAILABLE);
const result result::NOT_MACHINE_CODE = result(CS_NOT_MACHINE_CODE);
const result result::MODULE_IR_NOT_AVAILABLE = result(CS_MODULE_IR_NOT_AVAILABLE);
const result result::ERROR_ANALYSIS_NOT_RUN = result(CS_ERROR_ANALYSIS_NOT_RUN);
const result result::ERROR_INVALID_AST_CLASS = result(CS_ERROR_INVALID_AST_CLASS);
const result result::ERROR_INVALID_KIND = result(CS_ERROR_INVALID_KIND);
const result result::ERROR_INVALID_FAMILY = result(CS_ERROR_INVALID_FAMILY);
const result result::ERROR_INVALID_LANGUAGE = result(CS_ERROR_INVALID_LANGUAGE);
const result result::ERROR_INVALID_LINE = result(CS_ERROR_INVALID_LINE);
const result result::ERROR_INVALID_LINK_TYPE = result(CS_ERROR_INVALID_LINK_TYPE);
const result result::ERROR_INVALID_FLAG = result(CS_ERROR_INVALID_FLAG);
const result result::ERROR_ARGUMENT_CANNOT_BE_NULL = result(CS_ERROR_ARGUMENT_CANNOT_BE_NULL);
const result result::ERROR_ARGUMENT_CANNOT_BE_EMPTY = result(CS_ERROR_ARGUMENT_CANNOT_BE_EMPTY);
const result result::ERROR_RANGE_CANNOT_BE_EMPTY = result(CS_ERROR_RANGE_CANNOT_BE_EMPTY);
const result result::ERROR_NOT_A_GLOBAL = result(CS_ERROR_NOT_A_GLOBAL);
const result result::ERROR_COMPUNIT_HAS_NO_SFILEINST = result(CS_ERROR_COMPUNIT_HAS_NO_SFILEINST);
const result result::ERROR_NOT_INITIALIZED = result(CS_ERROR_NOT_INITIALIZED);
const result result::ERROR_LAUNCHD_NO_HOME = result(CS_ERROR_LAUNCHD_NO_HOME);
const result result::ERROR_LAUNCHD_QUOTA_EXCEEDED = result(CS_ERROR_LAUNCHD_QUOTA_EXCEEDED);
const result result::INTERNAL_ERROR_BAD_ABS_LOC_KIND = result(CS_INTERNAL_ERROR_BAD_ABS_LOC_KIND);
const result result::INTERNAL_ERROR_BAD_ABS_LOC_UID = result(CS_INTERNAL_ERROR_BAD_ABS_LOC_UID);
const result result::INTERNAL_ERROR_NULL_ABS_LOC_FIELD = result(CS_INTERNAL_ERROR_NULL_ABS_LOC_FIELD);
const result result::INTERNAL_ERROR_NULL_ABS_LOC_FIELDS = result(CS_INTERNAL_ERROR_NULL_ABS_LOC_FIELDS);
const result result::INTERNAL_ERROR_NULL_INL_TARGET = result(CS_INTERNAL_ERROR_NULL_INL_TARGET);
const result result::INTERNAL_ERROR_NULL_INL_TARGETS = result(CS_INTERNAL_ERROR_NULL_INL_TARGETS);
const result result::INTERNAL_ERROR_NULL_LAST_VERTEX = result(CS_INTERNAL_ERROR_NULL_LAST_VERTEX);
const result result::INTERNAL_ERROR_NULL_LAST_VERTEX_2 = result(CS_INTERNAL_ERROR_NULL_LAST_VERTEX_2);
const result result::INTERNAL_ERROR_ABS_LOC_SET_CLOSE = result(CS_INTERNAL_ERROR_ABS_LOC_SET_CLOSE);
const result result::INTERNAL_ERROR_BB_SET_CLOSE = result(CS_INTERNAL_ERROR_BB_SET_CLOSE);
const result result::INTERNAL_ERROR_PDGV_SET_CLOSE = result(CS_INTERNAL_ERROR_PDGV_SET_CLOSE);
const result result::INTERNAL_ERROR_IP_SET_CLOSE = result(CS_INTERNAL_ERROR_IP_SET_CLOSE);
const result result::INTERNAL_ERROR_IP_MAP_COMPUTE_FAIL = result(CS_INTERNAL_ERROR_IP_MAP_COMPUTE_FAIL);
const result result::INTERNAL_ERROR_BAD_FORMAL = result(CS_INTERNAL_ERROR_BAD_FORMAL);
const result result::INTERNAL_ERROR_PDG_MISSING = result(CS_INTERNAL_ERROR_PDG_MISSING);
const result result::INTERNAL_ERROR_PDG_MISSING_02 = result(CS_INTERNAL_ERROR_PDG_MISSING_02);
const result result::INTERNAL_ERROR_AIN_NO_CALL = result(CS_INTERNAL_ERROR_AIN_NO_CALL);
const result result::INTERNAL_ERROR_PDG_CALL_NO_CALLEE = result(CS_INTERNAL_ERROR_PDG_CALL_NO_CALLEE);
const result result::INTERNAL_ERROR_PDG_CALL_NO_CALLEE_2 = result(CS_INTERNAL_ERROR_PDG_CALL_NO_CALLEE_2);
const result result::INTERNAL_ERROR_PDG_CALL_NO_CALLEE_3 = result(CS_INTERNAL_ERROR_PDG_CALL_NO_CALLEE_3);
const result result::INTERNAL_ERROR_GET_ISET = result(CS_INTERNAL_ERROR_GET_ISET);
const result result::INTERNAL_ERROR_GET_LENGTH = result(CS_INTERNAL_ERROR_GET_LENGTH);
const result result::INTERNAL_ERROR_UNION_P_FAILS = result(CS_INTERNAL_ERROR_UNION_P_FAILS);
const result result::INTERNAL_ERROR_UID_SFID_HANDLES_NOT_DEFINED = result(CS_INTERNAL_ERROR_UID_SFID_HANDLES_NOT_DEFINED);
const result result::INTERNAL_ERROR_UID_SFID_HANDLES_NOT_LIST = result(CS_INTERNAL_ERROR_UID_SFID_HANDLES_NOT_LIST);
const result result::INTERNAL_ERROR_UID_SFID_HANDLES_NOT_PAIR = result(CS_INTERNAL_ERROR_UID_SFID_HANDLES_NOT_PAIR);
const result result::INTERNAL_ERROR_UID_SFID_HANDLES_NOT_SHANDLE = result(CS_INTERNAL_ERROR_UID_SFID_HANDLES_NOT_SHANDLE);
const result result::INTERNAL_ERROR_UID_SFID_HANDLES_NOT_SFID = result(CS_INTERNAL_ERROR_UID_SFID_HANDLES_NOT_SFID);
const result result::INTERNAL_ERROR_UID_SFID_HANDLES_MISSING_TMPDIR = result(CS_INTERNAL_ERROR_UID_SFID_HANDLES_MISSING_TMPDIR);
const result result::INTERNAL_ERROR_U2S_MISSING_TMPDIR = result(CS_INTERNAL_ERROR_U2S_MISSING_TMPDIR);
const result result::INTERNAL_ERROR_TRY_AGAIN_LATER = result(CS_INTERNAL_ERROR_TRY_AGAIN_LATER);
const result result::INTERNAL_ERROR_GETCWD_FAILED = result(CS_INTERNAL_ERROR_GETCWD_FAILED);
const result result::INTERNAL_ERROR_GETCURRENTDIRECTORY_FAILED = result(CS_INTERNAL_ERROR_GETCURRENTDIRECTORY_FAILED);
const result result::INTERNAL_ERROR_UNEXPECTED_RESPONSE_CODE = result(CS_INTERNAL_ERROR_UNEXPECTED_RESPONSE_CODE);
const result result::INTERNAL_ERROR_UNEXPECTED_MESSAGE = result(CS_INTERNAL_ERROR_UNEXPECTED_MESSAGE);
const result result::INTERNAL_ERROR_CONNECTION_FAILED = result(CS_INTERNAL_ERROR_CONNECTION_FAILED);
const result result::INTERNAL_ERROR_OPENSCMANAGER_FAILED = result(CS_INTERNAL_ERROR_OPENSCMANAGER_FAILED);
const result result::INTERNAL_ERROR_CREATESERVICE_FAILED = result(CS_INTERNAL_ERROR_CREATESERVICE_FAILED);
const result result::INTERNAL_ERROR_OPENSERVICE_FAILED = result(CS_INTERNAL_ERROR_OPENSERVICE_FAILED);
const result result::INTERNAL_ERROR_STARTSERVICE_FAILED = result(CS_INTERNAL_ERROR_STARTSERVICE_FAILED);
const result result::INTERNAL_ERROR_SERVICE_DID_NOT_START = result(CS_INTERNAL_ERROR_SERVICE_DID_NOT_START);
const result result::INTERNAL_ERROR_SERVICE_UNEXPECTED_STATE = result(CS_INTERNAL_ERROR_SERVICE_UNEXPECTED_STATE);
const result result::INTERNAL_ERROR_QUERYSERVICESTATUS_FAILED = result(CS_INTERNAL_ERROR_QUERYSERVICESTATUS_FAILED);
const result result::INTERNAL_ERROR_DELETESERVICE_FAILED = result(CS_INTERNAL_ERROR_DELETESERVICE_FAILED);
const result result::INTERNAL_ERROR_TERMINAL_SERVER_NOT_OK = result(CS_INTERNAL_ERROR_TERMINAL_SERVER_NOT_OK);
const result result::INTERNAL_ERROR_KERNEL_OBJECT_NAME_UNKNOWN = result(CS_INTERNAL_ERROR_KERNEL_OBJECT_NAME_UNKNOWN);
const result result::INTERNAL_ERROR_GET_NTDLL_BASE_FAILED = result(CS_INTERNAL_ERROR_GET_NTDLL_BASE_FAILED);
const result result::INTERNAL_ERROR_UNFAMILIAR_SYSCALL = result(CS_INTERNAL_ERROR_UNFAMILIAR_SYSCALL);
const result result::INTERNAL_ERROR_DRVHOOKCS_CONFIGURE = result(CS_INTERNAL_ERROR_DRVHOOKCS_CONFIGURE);
const result result::INTERNAL_ERROR_DRVHOOKCS_ACTIVATE = result(CS_INTERNAL_ERROR_DRVHOOKCS_ACTIVATE);
const result result::INTERNAL_ERROR_DRVHOOKCS_FLTLIB_LOADLIBRARY = result(CS_INTERNAL_ERROR_DRVHOOKCS_FLTLIB_LOADLIBRARY);
const result result::INTERNAL_ERROR_DRVHOOKCS_FLTLIB_GETPROCADDRESS = result(CS_INTERNAL_ERROR_DRVHOOKCS_FLTLIB_GETPROCADDRESS);
const result result::INTERNAL_ERROR_MULTIBYTETOWIDECHAR = result(CS_INTERNAL_ERROR_MULTIBYTETOWIDECHAR);
const result result::INTERNAL_ERROR_ABS_LOC_FUNCTION_TO_PDG_NO_PDG = result(CS_INTERNAL_ERROR_ABS_LOC_FUNCTION_TO_PDG_NO_PDG);
const result result::INTERNAL_ERROR_REGISTRY_WRITE_FAILED = result(CS_INTERNAL_ERROR_REGISTRY_WRITE_FAILED);
const result result::INTERNAL_ERROR_DRVHOOKCS_SINGLE_PARSE_VERSION = result(CS_INTERNAL_ERROR_DRVHOOKCS_SINGLE_PARSE_VERSION);
const result result::INTERNAL_ERROR_DRVHOOKCS_INCOMPATIBLE_VERSION = result(CS_INTERNAL_ERROR_DRVHOOKCS_INCOMPATIBLE_VERSION);
const result result::INTERNAL_ERROR_VALUESET_NOT_FOUND = result(CS_INTERNAL_ERROR_VALUESET_NOT_FOUND);
const result result::INTERNAL_ERROR_NO_VALUESET_INTERFACE = result(CS_INTERNAL_ERROR_NO_VALUESET_INTERFACE);
const result result::ON_BAD_FILE_SYSTEM = result(CS_ON_BAD_FILE_SYSTEM);
const result result::ACCESS_DENIED = result(CS_ACCESS_DENIED);
const result result::SSL_CERTIFICATE_HOSTNAME_MISMATCH = result(CS_SSL_CERTIFICATE_HOSTNAME_MISMATCH);
const result result::SSL_CERTIFICATE_ERROR = result(CS_SSL_CERTIFICATE_ERROR);
const result result::ERROR_LICENSE_EXPIRED = result(CS_ERROR_LICENSE_EXPIRED);
const result result::INTERNAL_ERROR_UNKNOWN = result(CS_INTERNAL_ERROR_UNKNOWN);
#endif