clang_EvalResult_getAsCXString impl

clang/include/clang-c/CXString.h

@@ -14,6 +14,7 @@
 #ifndef LLVM_CLANG_C_CXSTRING_H
 #define LLVM_CLANG_C_CXSTRING_H
 
+#include <stddef.h>
 #include "clang-c/ExternC.h"
 #include "clang-c/Platform.h"
 
@@ -36,6 +37,7 @@ LLVM_CLANG_C_EXTERN_C_BEGIN
  */
 typedef struct {
   const void *data;
+  size_t length;
   unsigned private_flags;
 } CXString;
 
@@ -52,6 +54,7 @@ typedef struct {
  * to `std::string::c_str()`.
  */
 CINDEX_LINKAGE const char *clang_getCString(CXString string);
+CINDEX_LINKAGE const char *clang_getCString2(CXString string, size_t *length);
 
 /**
  * Free the given string.

clang/include/clang-c/Index.h

@@ -5918,12 +5918,19 @@ clang_EvalResult_getAsUnsigned(CXEvalResult E);
 CINDEX_LINKAGE double clang_EvalResult_getAsDouble(CXEvalResult E);
 
 /**
- * Returns the evaluation result as a constant string if the
- * kind is other than Int or float. User must not free this pointer,
- * instead call clang_EvalResult_dispose on the CXEvalResult returned
- * by clang_Cursor_Evaluate.
+ * This function behaves the same as clang_EvalResult_getAsCXString, with 2
+ * exceptions:
+ * - the string literal will be truncated if a nul byte is found in the string.
+ * For this reason clang_EvalResult_getAsCXString is recommended.
+ * - User must not free this pointer, instead call clang_EvalResult_dispose on
+ * the CXEvalResult returned by clang_Cursor_Evaluate.
  */
 CINDEX_LINKAGE const char *clang_EvalResult_getAsStr(CXEvalResult E);
+/**
+ * Returns the evaluation result as a constant string if the
+ * kind is other than Int or float. This might include zero bytes.
+ */
+CINDEX_LINKAGE CXString clang_EvalResult_getAsCXString(CXEvalResult E);
 
 /**
  * Disposes the created Eval memory.

clang/tools/libclang/CIndex.cpp

@@ -4589,13 +4589,13 @@ struct ExprEvalResult {
     unsigned long long unsignedVal;
     long long intVal;
     double floatVal;
-    char *stringVal;
+    CXString stringVal;
   } EvalData;
   bool IsUnsignedInt;
   ~ExprEvalResult() {
     if (EvalType != CXEval_UnExposed && EvalType != CXEval_Float &&
         EvalType != CXEval_Int) {
-      delete[] EvalData.stringVal;
+      clang_disposeString(EvalData.stringVal);
     }
   }
 };
@@ -4651,7 +4651,17 @@ const char *clang_EvalResult_getAsStr(CXEvalResult E) {
   if (!E) {
     return nullptr;
   }
-  return ((ExprEvalResult *)E)->EvalData.stringVal;
+  return clang_getCString(((ExprEvalResult *)E)->EvalData.stringVal);
+}
+
+CXString clang_EvalResult_getAsCXString(CXEvalResult E) {
+  if (!E) {
+    return cxstring::createNull();
+  }
+  size_t length;
+  auto data =
+      clang_getCString2(((ExprEvalResult *)E)->EvalData.stringVal, &length);
+  return cxstring::createDup(StringRef(data, length));
 }
 
 static const ExprEvalResult *evaluateExpr(Expr *expr, CXCursor C) {
@@ -4716,11 +4726,7 @@ static const ExprEvalResult *evaluateExpr(Expr *expr, CXCursor C) {
         result->EvalType = CXEval_StrLiteral;
       }
 
-      std::string strRef(StrE->getString().str());
-      result->EvalData.stringVal = new char[strRef.size() + 1];
-      strncpy((char *)result->EvalData.stringVal, strRef.c_str(),
-              strRef.size());
-      result->EvalData.stringVal[strRef.size()] = '\0';
+      result->EvalData.stringVal = cxstring::createDup(StrE->getString());
       return result.release();
     }
   } else if (expr->getStmtClass() == Stmt::ObjCStringLiteralClass ||
@@ -4737,10 +4743,7 @@ static const ExprEvalResult *evaluateExpr(Expr *expr, CXCursor C) {
       result->EvalType = CXEval_StrLiteral;
     }
 
-    std::string strRef(StrE->getString().str());
-    result->EvalData.stringVal = new char[strRef.size() + 1];
-    strncpy((char *)result->EvalData.stringVal, strRef.c_str(), strRef.size());
-    result->EvalData.stringVal[strRef.size()] = '\0';
+    result->EvalData.stringVal = cxstring::createDup(StrE->getString());
     return result.release();
   }
 
@@ -4754,13 +4757,8 @@ static const ExprEvalResult *evaluateExpr(Expr *expr, CXCursor C) {
       callExpr = static_cast<CallExpr *>(CC->getSubExpr());
       StringLiteral *S = getCFSTR_value(callExpr);
       if (S) {
-        std::string strLiteral(S->getString().str());
         result->EvalType = CXEval_CFStr;
-
-        result->EvalData.stringVal = new char[strLiteral.size() + 1];
-        strncpy((char *)result->EvalData.stringVal, strLiteral.c_str(),
-                strLiteral.size());
-        result->EvalData.stringVal[strLiteral.size()] = '\0';
+        result->EvalData.stringVal = cxstring::createDup(S->getString());
         return result.release();
       }
     }
@@ -4780,24 +4778,18 @@ static const ExprEvalResult *evaluateExpr(Expr *expr, CXCursor C) {
 
       StringLiteral *S = getCFSTR_value(callExpr);
       if (S) {
-        std::string strLiteral(S->getString().str());
         result->EvalType = CXEval_CFStr;
-        result->EvalData.stringVal = new char[strLiteral.size() + 1];
-        strncpy((char *)result->EvalData.stringVal, strLiteral.c_str(),
-                strLiteral.size());
-        result->EvalData.stringVal[strLiteral.size()] = '\0';
+        result->EvalData.stringVal = cxstring::createDup(S->getString());
         return result.release();
       }
     }
   } else if (expr->getStmtClass() == Stmt::DeclRefExprClass) {
     DeclRefExpr *D = static_cast<DeclRefExpr *>(expr);
     ValueDecl *V = D->getDecl();
     if (V->getKind() == Decl::Function) {
-      std::string strName = V->getNameAsString();
       result->EvalType = CXEval_Other;
-      result->EvalData.stringVal = new char[strName.size() + 1];
-      strncpy(result->EvalData.stringVal, strName.c_str(), strName.size());
-      result->EvalData.stringVal[strName.size()] = '\0';
+      result->EvalData.stringVal =
+          cxstring::createDup(StringRef(V->getNameAsString()));
       return result.release();
     }
   }

clang/tools/libclang/CXString.cpp

@@ -43,13 +43,15 @@ namespace cxstring {
 CXString createEmpty() {
   CXString Str;
   Str.data = "";
+  Str.length = 0;
   Str.private_flags = CXS_Unmanaged;
   return Str;
 }
 
 CXString createNull() {
   CXString Str;
   Str.data = nullptr;
+  Str.length = 0;
   Str.private_flags = CXS_Unmanaged;
   return Str;
 }
@@ -60,6 +62,7 @@ CXString createRef(const char *String) {
 
   CXString Str;
   Str.data = String;
+  Str.length = -1;
   Str.private_flags = CXS_Unmanaged;
   return Str;
 }
@@ -71,10 +74,7 @@ CXString createDup(const char *String) {
   if (String[0] == '\0')
     return createEmpty();
 
-  CXString Str;
-  Str.data = strdup(String);
-  Str.private_flags = CXS_Malloc;
-  return Str;
+  return createDup(StringRef(String));
 }
 
 CXString createRef(StringRef String) {
@@ -91,18 +91,21 @@ CXString createRef(StringRef String) {
 }
 
 CXString createDup(StringRef String) {
-  CXString Result;
   char *Spelling = static_cast<char *>(llvm::safe_malloc(String.size() + 1));
-  memmove(Spelling, String.data(), String.size());
+  memcpy(Spelling, String.data(), String.size());
   Spelling[String.size()] = 0;
+
+  CXString Result;
   Result.data = Spelling;
+  Result.length = String.size();
   Result.private_flags = (unsigned) CXS_Malloc;
   return Result;
 }
 
 CXString createCXString(CXStringBuf *buf) {
   CXString Str;
   Str.data = buf;
+  Str.length = -1;
   Str.private_flags = (unsigned) CXS_StringBuf;
   return Str;
 }
@@ -164,6 +167,13 @@ const char *clang_getCString(CXString string) {
   return static_cast<const char *>(string.data);
 }
 
+const char *clang_getCString2(CXString string, size_t *length) {
+  auto ret = clang_getCString(string);
+  *length =
+      string.length == static_cast<size_t>(-1) ? strlen(ret) : string.length;
+  return ret;
+}
+
 void clang_disposeString(CXString string) {
   switch ((CXStringFlag) string.private_flags) {
     case CXS_Unmanaged:

clang/tools/libclang/libclang.map

@@ -438,6 +438,12 @@ LLVM_20 {
     clang_visitCXXMethods;
 };
 
+LLVM_21 {
+  global:
+    clang_getCString2;
+    clang_EvalResult_getAsCXString;
+};
+
 # Example of how to add a new symbol version entry.  If you do add a new symbol
 # version, please update the example to depend on the version you added.
 # LLVM_X {

clang/unittests/libclang/LibclangTest.cpp

@@ -623,6 +623,47 @@ TEST_F(LibclangParseTest, EvaluateChildExpression) {
       nullptr);
 }
 
+TEST_F(LibclangParseTest, StringLiteralWithZeros) {
+  const char testSource[] = R"cpp(
+const char str[] = "pika\0chu";
+)cpp";
+  std::string fileName = "main.cpp";
+  WriteFile(fileName, testSource);
+
+  const char *Args[] = {"-xc++"};
+  ClangTU = clang_parseTranslationUnit(Index, fileName.c_str(), Args, 1,
+                                       nullptr, 0, TUFlags);
+
+  int nodes = 0;
+
+  Traverse([&nodes](CXCursor cursor, CXCursor parent) -> CXChildVisitResult {
+    if (cursor.kind == CXCursor_StringLiteral) {
+      CXEvalResult RE = clang_Cursor_Evaluate(cursor);
+      EXPECT_NE(RE, nullptr);
+      EXPECT_EQ(clang_EvalResult_getKind(RE), CXEval_StrLiteral);
+
+      const char expected[] = "pika\0chu";
+      size_t expected_size = sizeof(expected) - 1;
+
+      auto lit = clang_EvalResult_getAsCXString(RE);
+      size_t length;
+      auto str = clang_getCString2(lit, &length);
+
+      EXPECT_TRUE(length == expected_size &&
+                  memcmp(str, expected, length) == 0);
+
+      clang_disposeString(lit);
+      clang_EvalResult_dispose(RE);
+
+      nodes++;
+      return CXChildVisit_Continue;
+    }
+    return CXChildVisit_Recurse;
+  });
+
+  EXPECT_EQ(nodes, 1);
+}
+
 class LibclangReparseTest : public LibclangParseTest {
 public:
   void DisplayDiagnostics() {