• cs_true if uid1 is equal to uid2;
• cs_false otherwise.

If you do not need hash values to be stable across analyses, use cs_uid_hash(): it has better performance.

• N<0 if uid_a considered less than uid_b
• N==0 if uid_a considered equal to uid_b
• N>0 if uid_a considered greater than uid_b

The comparison is stable in the following sense. Suppose there are two analyses A1 and A2 generated with exactly the same inputs (including identical analyzed code, underlying build commands and ordering, command line and configuration settings, increment order and contents). Let a1 and b1 be two cs_uid values in A1, and a2 and b2 be the cs_uid values in A2 that correspond to a1 and b1 respectively. Then cs_uid_stable_compare(a1,b1)==cs_uid_stable_compare(a2,b2).

If you do not need comparison results to be stable across different analyses, use cs_uid_compare(): it has better performance.

• cs_true if uid is null,
• cs_false otherwise.

• CS_TRUNCATED if out_string is not large enough to hold the entire string representation of sfid (and so the string was truncated),
• CS_SUCCESS otherwise.

Call this function with out_string NULL and capacity_bytes 0 (zero) to determine the memory needed to hold the entire representation.

• CS_ERROR_INVALID_SFID_STRING if str does not have the right format;
• CS_SUCCESS otherwise.

• CS_TRUNCATED if out_string is not large enough to hold the entire string representation of sfid (and so the string was truncated),
• CS_SUCCESS otherwise.

When use_private_use_area is cs_true, bytes 128 or higher will be escaped as code point 0xe000 + byte. They will appear in the XML as &#xe080..&#xe0ff. The CodeSonar hub expects XML to be encoded in this fashion.

If use_private_use_area is cs_false, the bytes will appear as-is in the XML. XML parsers will reject this XML if they do not use a character encoding matching the data.

When use_private_use_area is cs_true, bytes 128 or higher will be escaped as code point 0xe000 + byte. They will appear in the XML as &#xe080..&#xe0ff. The CodeSonar hub expects XML to be encoded in this fashion.

If use_private_use_area is cs_false, the bytes will appear as-is in the XML. XML parsers will reject this XML if they do not use a character encoding matching the data.

• CS_TRUNCATED if out is not large enough to hold the entire decoded string
• CS_SUCCESS otherwise.

• cs_true if file_path1 is equal to file_path2;
• cs_false otherwise.

• CS_ERROR_INVALID_SET_KIND if kind is not valid,
• CS_SUCCESS otherwise.

• CS_SUCCESS on success,
• CS_TRUNCATED if the whole user name does not fit in in buf,
• (Windows) CS_ERROR_GET_USER_NAME_FAILED if system call GetUserName failed,
• (Solaris, Linux) CS_ERROR_GET_PW_UID_FAILED if system call getpwuid failed.

• CS_SUCCESS on success,
• CS_TRUNCATED if the whole machine name does not fit in in buf,
• (Windows) CS_ERROR_GET_COMPUTER_NAME_FAILED if system call GetComputerName failed,
• (Solaris, Linux) CS_ERROR_GET_HOST_NAME_FAILED if system call gethostname failed.

If called with a value less than the current number of bytes in use by resident objects, then objects will be paged out immediately.

• Too low a value may cause thrashing.
• Too high a value may cause the tool to exhaust virtual address space.

The new value does not take effect until the next time cs_s_read_sdg() is called.

• CS_ERROR_SDG_NOT_PRESENT if no allocation has been done,
• CS_SUCCESS otherwise.

• CS_ERROR_SDG_NOT_PRESENT if no allocation has been done,
• CS_SUCCESS otherwise.

• cs_true if sf1 and sf2 are the same cs_sf;
• cs_false if not.

• N<0 if sf_a is considered less than sf_b
• N==0 if sf_a and sf_b are the same cs_sf
• N>0 if sf_a is considered greater than sf_b

For fixed cs_sf values a and b in a single analysis, cs_sf_compare(a,b) will always return the same value. However, cs_sf_compare() will not necessarily return this same value when called on the corresponding cs_sf values a' and b' in a different analysis. Function cs_sf_stable_compare() provides some degree of stability across analyses, although restrictions still apply. If you do not need comparison results to be stable across different analyses, use cs_sf_compare(): it has better performance.

• cs_true if sf is null;
• cs_false otherwise.

• cs_true if sfid1 and sfid2 are the same cs_sfid;
• cs_false if not.

• N<0 if sfid_a is considered less than sfid_b
• N==0 if sfid_a and sfid_b are the same cs_sfid
• N>0 if sfid_a is considered greater than sfid_b

For fixed cs_sfid values a and b in a single analysis, cs_sfid_compare(a,b) will always return the same value. However, cs_sfid_compare() will not necessarily return this same value when called on the corresponding cs_sfid values a' and b' in a different analysis. Function cs_sfid_stable_compare() provides some degree of stability across analyses, although restrictions still apply. If you do not need comparison results to be stable across different analyses, use cs_sfid_compare(): it has better performance.

• cs_true if all bits of sfid are zeroed;
• cs_false otherwise.

• N<0 if uid_a is considered less than uid_b
• N==0 if uid_a and uid_b are the same cs_uid
• N>0 if uid_a is considered greater than uid_b

For fixed cs_uid values a and b in a single analysis, cs_uid_compare(a,b) will always return the same value. However, cs_uid_compare() will not necessarily return this same value when called on the corresponding cs_uid values a' and b' in a different analysis. Function cs_uid_stable_compare() provides some degree of stability across analyses, although restrictions still apply. If you do not need comparison results to be stable across different analyses, use cs_uid_compare(): it has better performance.

• cs_true if s is null;
• cs_false otherwise.