Add more string.h rules

rules/cstring/src.c

@@ -1,7 +1,9 @@
 // Copyright (c) 2022-present INESC-ID.
 // Distributed under the MIT license that can be found in the LICENSE file.
 
+#define _GNU_SOURCE
 #include <string.h>
+#include <strings.h>
 
 void *f1(void *dst, const void *src, size_t n) { return memcpy(dst, src, n); }
 
@@ -12,3 +14,29 @@ int f3(const void *s1, const void *s2, size_t n) { return memcmp(s1, s2, n); }
 void *f4(void *dst, const void *src, size_t n) { return memmove(dst, src, n); }
 
 char *f5(const char *a0, int a1) { return strchr(a0, a1); }
+
+size_t f7(const char *a0) { return strlen(a0); }
+
+int f8(const char *a0, const char *a1) { return strcmp(a0, a1); }
+
+int f9(const char *a0, const char *a1, size_t a2) { return strncmp(a0, a1, a2); }
+
+void *f10(const void *a0, int a1, size_t a2) { return memchr(a0, a1, a2); }
+
+char *f11(const char *a0, int a1) { return strrchr(a0, a1); }
+
+char *f15(const char *a0) { return strdup(a0); }
+
+size_t f16(const char *a0, const char *a1) { return strcspn(a0, a1); }
+
+size_t f17(const char *a0, const char *a1) { return strspn(a0, a1); }
+
+char *f18(const char *a0, const char *a1) { return strstr(a0, a1); }
+
+char *f21(const char *a0, const char *a1) { return strpbrk(a0, a1); }
+
+#if defined(__linux__)
+void *f24(const void *a0, int a1, size_t a2) { return memrchr(a0, a1, a2); }
+#endif
+
+int f27(const char *a0, const char *a1) { return strcasecmp(a0, a1); }

rules/cstring/src.cpp

@@ -4,3 +4,23 @@
 #include <string.h>
 
 const char *f6(const char *a0, int a1) { return strchr(a0, a1); }
+
+const void *f12(const void *a0, int a1, size_t a2) { return memchr(a0, a1, a2); }
+
+const char *f13(const char *a0, int a1) { return strrchr(a0, a1); }
+
+char *f14(char *a0, int a1) { return strrchr(a0, a1); }
+
+const char *f19(const char *a0, const char *a1) { return strstr(a0, a1); }
+
+char *f20(char *a0, const char *a1) { return strstr(a0, a1); }
+
+const char *f22(const char *a0, const char *a1) { return strpbrk(a0, a1); }
+
+char *f23(char *a0, const char *a1) { return strpbrk(a0, a1); }
+
+#if defined(__linux__)
+const void *f25(const void *a0, int a1, size_t a2) { return memrchr(a0, a1, a2); }
+
+void *f26(void *a0, int a1, size_t a2) { return memrchr(a0, a1, a2); }
+#endif

rules/cstring/tgt_unsafe.rs

@@ -43,3 +43,90 @@ unsafe fn f5(a0: *const u8, a1: i32) -> *mut u8 {
 unsafe fn f6(a0: *const u8, a1: i32) -> *const u8 {
     libc::strchr(a0 as *const i8, a1) as *const u8
 }
+
+unsafe fn f7(a0: *const u8) -> u64 {
+    libc::strlen(a0 as *const i8) as u64
+}
+
+unsafe fn f8(a0: *const u8, a1: *const u8) -> i32 {
+    libc::strcmp(a0 as *const i8, a1 as *const i8)
+}
+
+unsafe fn f9(a0: *const u8, a1: *const u8, a2: usize) -> i32 {
+    libc::strncmp(a0 as *const i8, a1 as *const i8, a2 as usize)
+}
+
+unsafe fn f10(a0: *const u8, a1: i32, a2: usize) -> *mut ::libc::c_void {
+    libc::memchr(a0 as *const ::libc::c_void, a1, a2 as usize)
+}
+
+unsafe fn f11(a0: *const u8, a1: i32) -> *mut u8 {
+    libc::strrchr(a0 as *const i8, a1) as *mut u8
+}
+
+unsafe fn f12(a0: *const u8, a1: i32, a2: usize) -> *const ::libc::c_void {
+    libc::memchr(a0 as *const ::libc::c_void, a1, a2 as usize) as *const ::libc::c_void
+}
+
+unsafe fn f13(a0: *const u8, a1: i32) -> *const u8 {
+    libc::strrchr(a0 as *const i8, a1) as *const u8
+}
+
+unsafe fn f14(a0: *mut u8, a1: i32) -> *mut u8 {
+    libc::strrchr(a0 as *const i8, a1) as *mut u8
+}
+
+unsafe fn f15(a0: *const u8) -> *mut u8 {
+    libc::strdup(a0 as *const i8) as *mut u8
+}
+
+unsafe fn f16(a0: *const u8, a1: *const u8) -> u64 {
+    libc::strcspn(a0 as *const i8, a1 as *const i8) as u64
+}
+
+unsafe fn f17(a0: *const u8, a1: *const u8) -> u64 {
+    libc::strspn(a0 as *const i8, a1 as *const i8) as u64
+}
+
+unsafe fn f18(a0: *const u8, a1: *const u8) -> *mut u8 {
+    libc::strstr(a0 as *const i8, a1 as *const i8) as *mut u8
+}
+
+unsafe fn f19(a0: *const u8, a1: *const u8) -> *const u8 {
+    libc::strstr(a0 as *const i8, a1 as *const i8) as *const u8
+}
+
+unsafe fn f20(a0: *mut u8, a1: *const u8) -> *mut u8 {
+    libc::strstr(a0 as *const i8, a1 as *const i8) as *mut u8
+}
+
+unsafe fn f21(a0: *const u8, a1: *const u8) -> *mut u8 {
+    libc::strpbrk(a0 as *const i8, a1 as *const i8) as *mut u8
+}
+
+unsafe fn f22(a0: *const u8, a1: *const u8) -> *const u8 {
+    libc::strpbrk(a0 as *const i8, a1 as *const i8) as *const u8
+}
+
+unsafe fn f23(a0: *mut u8, a1: *const u8) -> *mut u8 {
+    libc::strpbrk(a0 as *const i8, a1 as *const i8) as *mut u8
+}
+
+#[cfg(target_os = "linux")]
+unsafe fn f24(a0: *const u8, a1: i32, a2: usize) -> *mut ::libc::c_void {
+    libc::memrchr(a0 as *const ::libc::c_void, a1, a2 as usize)
+}
+
+#[cfg(target_os = "linux")]
+unsafe fn f25(a0: *const u8, a1: i32, a2: usize) -> *const ::libc::c_void {
+    libc::memrchr(a0 as *const ::libc::c_void, a1, a2 as usize) as *const ::libc::c_void
+}
+
+#[cfg(target_os = "linux")]
+unsafe fn f26(a0: *mut u8, a1: i32, a2: usize) -> *mut ::libc::c_void {
+    libc::memrchr(a0 as *const ::libc::c_void, a1, a2 as usize)
+}
+
+unsafe fn f27(a0: *const u8, a1: *const u8) -> i32 {
+    libc::strcasecmp(a0 as *const i8, a1 as *const i8)
+}

tests/unit/cstring.cpp

@@ -0,0 +1,183 @@
+// no-compile: refcount
+#define _GNU_SOURCE
+#include <cassert>
+#include <cstdlib>
+#include <cstring>
+#include <strings.h>
+
+static void test_memcpy() {
+  const char src[] = "hello";
+  char dst[6] = {0};
+  void *r = std::memcpy(dst, src, 6);
+  assert(r == dst);
+  assert(dst[0] == 'h' && dst[1] == 'e' && dst[2] == 'l');
+  assert(dst[3] == 'l' && dst[4] == 'o' && dst[5] == '\0');
+}
+
+static void test_memset() {
+  char buf[4];
+  void *r = std::memset(buf, 'x', 4);
+  assert(r == buf);
+  assert(buf[0] == 'x' && buf[1] == 'x' && buf[2] == 'x' && buf[3] == 'x');
+}
+
+static void test_memcmp() {
+  const char a[] = {1, 2, 3, 4};
+  const char b[] = {1, 2, 3, 4};
+  const char c[] = {1, 2, 9, 4};
+  assert(std::memcmp(a, b, 4) == 0);
+  assert(std::memcmp(a, c, 4) < 0);
+  assert(std::memcmp(c, a, 4) > 0);
+}
+
+static void test_memmove() {
+  char buf[6] = {'a', 'b', 'c', 'd', 'e', '\0'};
+  void *r = std::memmove(buf + 1, buf, 4);
+  assert(r == buf + 1);
+  assert(buf[0] == 'a' && buf[1] == 'a' && buf[2] == 'b');
+  assert(buf[3] == 'c' && buf[4] == 'd' && buf[5] == '\0');
+}
+
+static void test_strchr() {
+  const char *s = "hello world";
+  const char *r = std::strchr(s, 'w');
+  assert(r != nullptr);
+  assert(*r == 'w');
+  assert(std::strchr(s, 'z') == nullptr);
+}
+
+static void test_strlen() {
+  assert(std::strlen("") == 0);
+  assert(std::strlen("hello") == 5);
+  assert(std::strlen("hello world") == 11);
+}
+
+static void test_strcmp() {
+  assert(std::strcmp("abc", "abc") == 0);
+  assert(std::strcmp("abc", "abd") < 0);
+  assert(std::strcmp("abd", "abc") > 0);
+  const char *p = "abc";
+  const char *q = "abd";
+  char buf[] = {'a', 'b', 'c', '\0'};
+  assert(std::strcmp(p, p) == 0);
+  assert(std::strcmp(p, q) < 0);
+  assert(std::strcmp(buf, p) == 0);
+}
+
+static void test_strncmp() {
+  assert(std::strncmp("abcdef", "abcxyz", 3) == 0);
+  assert(std::strncmp("abcdef", "abcxyz", 4) < 0);
+  assert(std::strncmp("abcxyz", "abcdef", 4) > 0);
+  const char *p = "abcdef";
+  const char *q = "abcxyz";
+  char buf[] = {'a', 'b', 'c', 'd', 'e', 'f', '\0'};
+  std::size_t n = 3;
+  assert(std::strncmp(p, q, n) == 0);
+  assert(std::strncmp(p, q, n + 1) < 0);
+  assert(std::strncmp(buf, p, 6) == 0);
+}
+
+static void test_memchr() {
+  const char data[] = {0x10, 0x20, 0x30, 0x40};
+  const void *r = std::memchr(data, 0x30, 4);
+  assert(r == &data[2]);
+  assert(std::memchr(data, 0x99, 4) == nullptr);
+  const void *p = data;
+  std::size_t n = 4;
+  assert(std::memchr(p, 0x10, n) == p);
+}
+
+static void test_strrchr() {
+  const char *s = "hello world";
+  const char *r = std::strrchr(s, 'l');
+  assert(r != nullptr);
+  assert(*r == 'l');
+  assert(r == s + 9);
+  assert(std::strrchr(s, 'z') == nullptr);
+  char buf[] = {'a', 'b', 'a', '\0'};
+  assert(std::strrchr(buf, 'a') == &buf[2]);
+}
+
+static void test_strdup() {
+  char *d = strdup("hello");
+  assert(d != nullptr);
+  assert(std::strcmp(d, "hello") == 0);
+  std::free(d);
+  const char *p = "world";
+  char buf[] = {'a', 'b', 'c', '\0'};
+  char *d2 = strdup(p);
+  assert(d2 != nullptr);
+  assert(std::strcmp(d2, p) == 0);
+  std::free(d2);
+  char *d3 = strdup(buf);
+  assert(d3 != nullptr);
+  assert(std::strcmp(d3, buf) == 0);
+  std::free(d3);
+}
+
+static void test_strcspn() {
+  assert(std::strcspn("hello", "el") == 1);
+  assert(std::strcspn("abc", "xyz") == 3);
+  assert(std::strcspn("", "abc") == 0);
+  const char *s = "hello";
+  const char *rej = "el";
+  assert(std::strcspn(s, rej) == 1);
+}
+
+static void test_strspn() {
+  assert(std::strspn("hello", "hel") == 4);
+  assert(std::strspn("abc", "xyz") == 0);
+  assert(std::strspn("aaa", "a") == 3);
+  const char *s = "hello";
+  const char *acc = "hel";
+  assert(std::strspn(s, acc) == 4);
+}
+
+static void test_strstr() {
+  const char *h = "hello world";
+  const char *r = std::strstr(h, "world");
+  assert(r != nullptr);
+  assert(r == h + 6);
+  assert(std::strstr(h, "xyz") == nullptr);
+  char buf[] = {'h', 'e', 'l', 'l', 'o', '\0'};
+  assert(std::strstr(buf, "ll") == &buf[2]);
+}
+
+static void test_strpbrk() {
+  const char *s = "hello world";
+  const char *r = std::strpbrk(s, "wo");
+  assert(r != nullptr);
+  assert(r == s + 4);
+  assert(std::strpbrk(s, "xyz") == nullptr);
+  char buf[] = {'a', 'b', 'c', '\0'};
+  assert(std::strpbrk(buf, "b") == &buf[1]);
+}
+
+static void test_strcasecmp() {
+  assert(strcasecmp("HELLO", "hello") == 0);
+  assert(strcasecmp("abc", "abd") < 0);
+  assert(strcasecmp("abd", "abc") > 0);
+  const char *p = "FOO";
+  const char *q = "foo";
+  assert(strcasecmp(p, q) == 0);
+}
+
+int main() {
+  test_memcpy();
+  test_memset();
+  test_memcmp();
+  test_memmove();
+  test_strchr();
+  test_strlen();
+  test_strcmp();
+  test_strncmp();
+  test_memchr();
+  test_strrchr();
+  test_strdup();
+  test_strcspn();
+  test_strspn();
+  test_strstr();
+  test_strpbrk();
+  test_strcasecmp();
+  return 0;
+}