update examples

Author: cs01

README.md

@@ -1,16 +1,16 @@
 # Nullsafe C: An experimental C/C++ compiler
 
-[![Test Null-Safety](https://github.com/cs01/llvm-project/actions/workflows/test-null-safety.yml/badge.svg)](https://github.com/cs01/llvm-project/actions/workflows/test-null-safety.yml)
+[![Test Null-Safety](https://github.com/cs01/llvm-project/actions/workflows/test-null-safety.yml/badge.svg)](https://github.com/cs01/llvm-project/actions/workflows/test-null-safety.yml)    [![Try Online](https://img.shields.io/badge/try-online-brightgreen)](https://cs01.github.io/llvm-project/)
+
+> **Try it online:** [Interactive Playground](https://cs01.github.io/llvm-project/) - See null-safety warnings in real-time 
 
 Nullsafe C adds NULL checks to catch errors at compile-time. It is 100% compatible with existing C codebases and can be used incrementally to identify safety issues at compile-time. 
 
 This provides the following benefits:
-* This makes the code safer by reducing the number of potential runtime null dereferences
-* Improves developer experience by shifting errors left
-* Makes the code more readable
-* Adds type errors that other more modern languages have (Rust, TypeScript, Kotlin)
-
-**Try it online:** [Interactive Playground](https://cs01.github.io/llvm-project/) - See null-safety warnings in real-time in your browser!
+* Catches errors at compile-time rather than runtime, reducing crashes
+* Improves developer experience by shifting errors left and showing issues in the IDE as you code
+* Makes code more readable and maintainable, including annotations with `_Nonnull`
+* Adds type checking that more modern languages have (Rust, TypeScript, Kotlin)
 
 Nullsafe C treats all pointers as potentially null ('nullable') unless it is certain they are not. It does this in two ways. 
 
@@ -20,14 +20,18 @@ The second is by using Clang's [`Nullability`](https://clang.llvm.org/docs/Attri
 
 If using a compiler other than clang, you can add `#define _Nonnull` as a no-op. You will not get the same compile checks as with Nullsafe C (clang fork), but the compillation will still succeed without error.
 
+When a function is called, it will reset any type refinements, assuming there may be side effects. If the variable is marked `const` in the function signature the type narrowing is maintained, because it is guaranteed to not be made null within the function.
+
+Note that this does not change any of the generated code. There are no performance impacts, it strictly does compile-time checks.
+
 ## Examples
 
 ```c
 void unsafe(int *data) {
   *data = 42; // warning: dereferencing nullable pointer of type 'int * _Nullable'
 }
 ```
-[Try it in the interactive playground](https://cs01.github.io/llvm-project/?code=dm9pZCB1bnNhZmUoaW50ICpkYXRhKSB7CiAgKmRhdGEgPSA0MjsgLy8gd2FybmluZzogZGVyZWZlcmVuY2luZyBudWxsYWJsZSBwb2ludGVyIG9mIHR5cGUgJ2ludCAqIF9OdWxsYWJsZScKfQ%3D%3D)
+*[Try it in the interactive playground](https://cs01.github.io/llvm-project/?code=dm9pZCB1bnNhZmUoaW50ICpkYXRhKSB7CiAgKmRhdGEgPSA0MjsgLy8gd2FybmluZzogZGVyZWZlcmVuY2luZyBudWxsYWJsZSBwb2ludGVyIG9mIHR5cGUgJ2ludCAqIF9OdWxsYWJsZScKfQ%3D%3D)*
 
 Type narrowing:
 ```c
@@ -37,15 +41,15 @@ void safe(int *data) {
   }
 }
 ```
-[Try it in the interactive playground](https://cs01.github.io/llvm-project/?code=dm9pZCBzYWZlKGludCAqZGF0YSkgewogIGlmIChkYXRhKSB7CiAgICAqZGF0YSA9IDQyOyAvLyBPSyAtIGRhdGEgaXMgbm9uLW51bGwgaGVyZQogIH0KfQ%3D%3D)
+*[Try it in the interactive playground](https://cs01.github.io/llvm-project/?code=dm9pZCBzYWZlKGludCAqZGF0YSkgewogIGlmIChkYXRhKSB7CiAgICAqZGF0YSA9IDQyOyAvLyBPSyAtIGRhdGEgaXMgbm9uLW51bGwgaGVyZQogIH0KfQ%3D%3D)*
 
 Anontated with `_Nonnull`:
 ```c
 void safe_typed(int *_Nonnull data) {
   *data = 42; // OK - we know data is not null so we can derefernce it
 }
 ```
-[Try it in the interactive playground](https://cs01.github.io/llvm-project/?code=dm9pZCBzYWZlX3R5cGVkKGludCAqX05vbm51bGwgZGF0YSkgewogICpkYXRhID0gNDI7IC8vIE9LIC0gd2Uga25vdyBkYXRhIGlzIG5vdCBudWxsIHNvIHdlIGNhbiBkZXJlZmVybmNlIGl0Cn0%3D)
+*[Try it in the interactive playground](https://cs01.github.io/llvm-project/?code=dm9pZCBzYWZlX3R5cGVkKGludCAqX05vbm51bGwgZGF0YSkgewogICpkYXRhID0gNDI7IC8vIE9LIC0gd2Uga25vdyBkYXRhIGlzIG5vdCBudWxsIHNvIHdlIGNhbiBkZXJlZmVybmNlIGl0Cn0%3D)*
 
 
 ## Installation
@@ -78,7 +82,7 @@ Each release includes:
 
 Once installed, configure your editor to use the null-safe `clangd`. Install the `clangd` extension from llvm and set the path to the clangd binary you just downloaded.
 
-**VSCode:**
+**VS Code:**
 ```json
 // settings.json
 {
@@ -107,11 +111,11 @@ Do not that this is not a comprehensive solution, since Null pointer dereference
 | Double-free             | ❌ Unsafe  | ❌ Unsafe                            |
 | Uninitialized memory    | ❌ Unsafe  | ❌ Unsafe                            |
 
-Although this doesn't fix all memory safety issues, it catches Null pointer dereferences for free.
+Although this doesn't fix all memory safety issues, it catches Null pointer dereferences for free. For additional memory safety, consider a language other than C. 
 
 ### Why you still might want to try this
 
-While Null-Safe Clang doesn't solve all memory safety issues, null pointer dereferences are a significant problem:
+While Null-Safe Clang doesn't solve all memory safety issues in C, null pointer dereferences are a significant problem:
 
 - Many memory safety bugs involve null pointer dereferences
 - Easier to adopt than rewriting in Rust (100% compatible with existing C code)
@@ -124,11 +128,11 @@ While Null-Safe Clang doesn't solve all memory safety issues, null pointer deref
 Basic usage (warnings enabled by default):
 ```bash
 # Warnings for nullable dereferences
-clang mycode.c
+clang -fsyntax-only mycode.c
 # Treat nullability issues as errors
-clang -Werror=nullability mycode.c
+clang -fsyntax-only -Werror=nullability mycode.c
 # Turn off nullability checking
-clang -fno-strict-nullability mycode.c
+clang -fsyntax-only -fno-strict-nullability mycode.c
 ```
 
 

nullsafe-playground/examples/cjson-escape.c

@@ -2,23 +2,7 @@ void process(int* _Nonnull data) {
     *data = 42;
 }
 
-void example(int* _Nullable  x, int* _Nonnull y) {
-    process(x);
-    process(y);
+void example(int* x, int* _Nonnull y) {
+    process(x);  // error
+    process(y);  // OK
 }
-
-void deref_twice_unsafe(int* _Nullable * _Nullable pp) {
-    **pp = 42;
-}
-
-void deref_twice_safe(int* _Nullable * _Nullable pp) {
-    if (pp && *pp) {
-        **pp = 42;
-    }
-}
-
-void deref_twice_partial(int* _Nullable * _Nullable pp) {
-    if (pp) {
-        **pp = 42;
-    }
-}

nullsafe-playground/examples/dereference-context.c

@@ -7,7 +7,3 @@ void safe(int *data) {
     *data = 42; // OK - data is non-null here
   }
 }
-
-void safe_typed(int *_Nonnull data) {
-  *data = 42; // OK - data is known to be non-null by the compiler
-}

nullsafe-playground/examples/loop-narrowing.c

@@ -564,20 +564,13 @@ <h1>Nullsafe C Playground</h1>
         </button>
 
         <select id="examplesSelect" class="examples-select" title="Load example code to see Nullsafe C in action">
-            <option value="null-check" selected>1. Basic Null Check</option>
-            <option value="early-return">2. Early Return Pattern</option>
-            <option value="pure-function">3. Const Functions Preserve Narrowing</option>
-            <option value="function-invalidates">4. Function Invalidates Narrowing</option>
+            <option value="null-check" selected>1. Raw pointer Dereference</option>
+            <option value="early-return">2. Early Return</option>
+            <option value="and-pattern">3. AND Pattern Narrowing</option>
+            <option value="else-branch">4. Else Branch Narrowing</option>
             <option value="nonnull-annotation">5. _Nonnull Annotations</option>
-            <option value="multi-level">6. Multi-Level Pointers</option>
-            <option value="and-pattern">7. AND Pattern Narrowing</option>
-            <option value="else-branch">8. Else Branch Narrowing</option>
-            <option value="loop-narrowing">9. Loop Condition Narrowing</option>
-            <option value="dereference-context">10. Null Check Before Deref</option>
-            <optgroup label="Real-World Bugs">
-                <option value="redis-sds">11. Redis: sdssetlen() pointer arithmetic</option>
-                <option value="cjson-escape">12. cJSON: print_string_ptr() escaping</option>
-            </optgroup>
+            <option value="function-invalidates">6. Function Invalidates Narrowing</option>
+            <option value="multi-level">7. Multi-Level Pointers</option>
         </select>
 
         <button id="shareBtn" class="btn btn-secondary" title="Copy a shareable link with your code to clipboard">