[c] ir-generator now evalutes nullability in spine-cpp based on pointer (nullable) or reference (non-nullable)

spine-c/codegen/src/c-types.ts

@@ -5,6 +5,7 @@ export interface CParameter {
     cType: string;         // C type (e.g., "float*", "spine_bone")
     cppType: string;       // Original C++ type (e.g., "float&", "Bone*")
     isOutput: boolean;     // true for non-const references that become output params
+    isNullable: boolean;   // true for pointer types (can be null), false for references/values
 }
 
 export interface CMethod {
@@ -12,6 +13,7 @@ export interface CMethod {
     returnType: string;    // C return type
     parameters: CParameter[];
     body: string;          // The actual implementation code (e.g., "return ((Bone*)self)->getX();")
+    returnTypeNullable: boolean;  // true if return type can be null (pointer types)
 }
 
 export interface CClassOrStruct {

spine-c/codegen/src/c-writer.ts

@@ -150,12 +150,14 @@ export class CWriter {
 
     private writeMethodDeclaration(method: CMethod): string {
         const params = this.formatParameters(method.parameters);
-        return `SPINE_C_API ${method.returnType} ${method.name}(${params});`;
+        const returnTypeWithAnnotation = method.returnTypeNullable ? `/*@null*/ ${method.returnType}` : method.returnType;
+        return `SPINE_C_API ${returnTypeWithAnnotation} ${method.name}(${params});`;
     }
 
     private writeMethodImplementation(method: CMethod): string {
         const params = this.formatParameters(method.parameters);
-        const signature = `${method.returnType} ${method.name}(${params})`;
+        const returnTypeWithAnnotation = method.returnTypeNullable ? `/*@null*/ ${method.returnType}` : method.returnType;
+        const signature = `${returnTypeWithAnnotation} ${method.name}(${params})`;
 
         return `${signature} {
     ${method.body}
@@ -168,7 +170,10 @@ export class CWriter {
         }
 
         return parameters
-            .map(p => `${p.cType} ${p.name}`)
+            .map(p => {
+                const typeWithAnnotation = p.isNullable ? `/*@null*/ ${p.cType}` : p.cType;
+                return `${typeWithAnnotation} ${p.name}`;
+            })
             .join(', ');
     }
 

spine-c/codegen/src/ir-generator.ts

@@ -2,7 +2,7 @@ import { scanArraySpecializations } from './array-scanner';
 import type { CClassOrStruct, CEnum, CEnumValue, CMethod, CParameter } from './c-types';
 import { isFieldExcluded, isFieldGetterExcluded, isFieldSetterExcluded } from './exclusions';
 import type { ArraySpecialization, Exclusion } from './types';
-import { type ClassOrStruct, type Constructor, checkTypeSupport, type Enum, type Field, isPrimitive, type Method, type Parameter, type Type, toCFunctionName, toCTypeName, toSnakeCase } from './types';
+import { type ClassOrStruct, type Constructor, checkTypeSupport, type Enum, type Field, isPrimitive, isNullable, type Method, type Parameter, type Type, toCFunctionName, toCTypeName, toSnakeCase } from './types';
 
 /**
  * Checks if a type inherits from SpineObject (directly or indirectly)
@@ -103,7 +103,8 @@ export function generateConstructors(type: ClassOrStruct, knownTypeNames: Set<st
                 name: `${cTypeName}_create`,
                 returnType: cTypeName,
                 parameters: [],
-                body: `return (${cTypeName}) new (__FILE__, __LINE__) ${cppTypeName}();`
+                body: `return (${cTypeName}) new (__FILE__, __LINE__) ${cppTypeName}();`,
+                returnTypeNullable: false  // Constructors never return null on success
             });
         } else {
             // Parameterized constructor
@@ -117,7 +118,8 @@ export function generateConstructors(type: ClassOrStruct, knownTypeNames: Set<st
                 name: `${cTypeName}_create${suffix}`,
                 returnType: cTypeName,
                 parameters: cParams,
-                body: `return (${cTypeName}) new (__FILE__, __LINE__) ${cppTypeName}(${cppArgs});`
+                body: `return (${cTypeName}) new (__FILE__, __LINE__) ${cppTypeName}(${cppArgs});`,
+                returnTypeNullable: false  // Constructors never return null on success
             });
         }
         i++;
@@ -150,9 +152,11 @@ export function generateDestructor(type: ClassOrStruct, exclusions: Exclusion[])
             name: 'self',
             cType: cTypeName,
             cppType: `${cppTypeName}*`,
-            isOutput: false
+            isOutput: false,
+            isNullable: false  // Self parameter must never be null (would crash)
         }],
-        body: `delete (${cppTypeName}*)self;`
+        body: `delete (${cppTypeName}*)self;`,
+        returnTypeNullable: false  // void return type cannot be null
     };
 }
 
@@ -222,7 +226,8 @@ export function generateMethods(type: ClassOrStruct, knownTypeNames: Set<string>
             name: `${cTypeName}_rtti`,
             returnType: 'spine_rtti',
             parameters: [],
-            body: `return (spine_rtti)&${cppTypeName}::rtti;`
+            body: `return (spine_rtti)&${cppTypeName}::rtti;`,
+            returnTypeNullable: false  // RTTI method returns a reference address, never null
         });
     }
 
@@ -270,9 +275,11 @@ export function generateFieldAccessors(type: ClassOrStruct, knownTypeNames: Set<
                         name: 'self',
                         cType: cTypeName,
                         cppType: `${cppTypeName}*`,
-                        isOutput: false
+                        isOutput: false,
+                        isNullable: false  // Self parameter must never be null (would crash)
                     }],
-                    body: generateFieldGetterBody(field, cppTypeName, knownTypeNames)
+                    body: generateFieldGetterBody(field, cppTypeName, knownTypeNames),
+                    returnTypeNullable: isNullable(field.type)  // Field return type nullability depends on field type
                 });
             } catch (e) {
                 console.warn(`  Skipping getter for field ${type.name}::${field.name}: ${e}`);
@@ -295,16 +302,19 @@ export function generateFieldAccessors(type: ClassOrStruct, knownTypeNames: Set<
                             name: 'self',
                             cType: cTypeName,
                             cppType: `${cppTypeName}*`,
-                            isOutput: false
+                            isOutput: false,
+                            isNullable: false  // Self parameter must never be null (would crash)
                         },
                         {
                             name: 'value',
                             cType: cParamType,
                             cppType: field.type,
-                            isOutput: false
+                            isOutput: false,
+                            isNullable: isNullable(field.type)  // Value parameter nullability depends on field type
                         }
                     ],
-                    body: generateFieldSetterBody(field, cppTypeName, knownTypeNames)
+                    body: generateFieldSetterBody(field, cppTypeName, knownTypeNames),
+                    returnTypeNullable: false  // void return type cannot be null
                 });
             } catch (e) {
                 console.warn(`  Skipping setter for field ${type.name}::${field.name}: ${e}`);
@@ -413,7 +423,8 @@ export function generateArrayType(spec: ArraySpecialization, arrayType: ClassOrS
             name: `${cTypeName}_create`,
             returnType: cTypeName,
             parameters: [],
-            body: `return (${cTypeName}) new (__FILE__, __LINE__) Array<${spec.elementType}>();`
+            body: `return (${cTypeName}) new (__FILE__, __LINE__) Array<${spec.elementType}>();`,
+            returnTypeNullable: false  // Array constructors never return null on success
         },
         {
             name: `${cTypeName}_create_with_capacity`,
@@ -422,9 +433,11 @@ export function generateArrayType(spec: ArraySpecialization, arrayType: ClassOrS
                 name: 'initialCapacity',
                 cType: 'size_t',
                 cppType: 'size_t',
-                isOutput: false
+                isOutput: false,
+                isNullable: false  // size_t cannot be null
             }],
-            body: `return (${cTypeName}) new (__FILE__, __LINE__) Array<${spec.elementType}>(initialCapacity);`
+            body: `return (${cTypeName}) new (__FILE__, __LINE__) Array<${spec.elementType}>(initialCapacity);`,
+            returnTypeNullable: false  // Array constructors never return null on success
         }
     ];
 
@@ -436,9 +449,11 @@ export function generateArrayType(spec: ArraySpecialization, arrayType: ClassOrS
             name: 'array',
             cType: cTypeName,
             cppType: `Array<${spec.elementType}>*`,
-            isOutput: false
+            isOutput: false,
+            isNullable: false  // Array parameter must never be null (would crash)
         }],
-        body: `delete (Array<${spec.elementType}>*)array;`
+        body: `delete (Array<${spec.elementType}>*)array;`,
+        returnTypeNullable: false  // void return type cannot be null
     };
 
     // Generate array methods
@@ -529,12 +544,14 @@ function convertParameters(params: Parameter[], knownTypeNames: Set<string>): CP
     for (const param of params) {
         const cType = toCTypeName(param.type, knownTypeNames);
         const isOutput = isOutputParameter(param.type);
+        const paramIsNullable = isNullable(param.type);
 
         cParams.push({
             name: param.name,
             cType,
             cppType: param.type,
-            isOutput
+            isOutput,
+            isNullable: paramIsNullable
         });
     }
 
@@ -650,7 +667,8 @@ function generateMethod(type: ClassOrStruct, method: Method, cTypeName: string,
                 name: 'self',
                 cType: cTypeName,
                 cppType: `${cppTypeName}*`,
-                isOutput: false
+                isOutput: false,
+                isNullable: false  // Self parameter must never be null (would crash)
             });
         }
 
@@ -680,7 +698,8 @@ function generateMethod(type: ClassOrStruct, method: Method, cTypeName: string,
             name: cMethodName,
             returnType: cReturnType,
             parameters: cParams,
-            body
+            body,
+            returnTypeNullable: isNullable(method.returnType)
         };
     } catch (e) {
         console.warn(`Skipping method ${type.name}::${method.name}: ${e}`);
@@ -807,7 +826,8 @@ function generateArrayMethod(cTypeName: string, method: Method, cppElementType:
             name: 'array',
             cType: cTypeName,
             cppType: `Array<${cppElementType}>*`,
-            isOutput: false
+            isOutput: false,
+            isNullable: false  // Array parameter must never be null (would crash)
         });
 
         // Add method parameters
@@ -822,7 +842,8 @@ function generateArrayMethod(cTypeName: string, method: Method, cppElementType:
             name: cMethodName,
             returnType: cReturnType,
             parameters: cParams,
-            body
+            body,
+            returnTypeNullable: isNullable(method.returnType)
         };
     } catch (e) {
         console.warn(`Skipping array method ${method.name}: ${e}`);

spine-c/codegen/src/types.ts

@@ -298,6 +298,38 @@ export function toCTypeName(cppType: string, knownTypeNames: Set<string>): strin
     return `spine_${toSnakeCase(normalizedType)}`;
 }
 
+/**
+ * Determines if a C++ type represents a nullable value (pointer types).
+ * Based on spine-cpp convention: pointers are nullable, references are not.
+ *
+ * @param cppType The C++ type to check
+ * @returns true if the type can be null (pointer types), false otherwise
+ *
+ * Examples:
+ * - "Bone*" → true (pointer, can be null)
+ * - "const Bone*" → true (pointer, can be null)
+ * - "Bone&" → false (reference, cannot be null)
+ * - "const Bone&" → false (reference, cannot be null)
+ * - "int" → false (value type, cannot be null)
+ * - "float*" → true (pointer to primitive, can be null)
+ */
+export function isNullable(cppType: string): boolean {
+    const normalizedType = cppType.replace(/\s+/g, ' ').trim();
+    
+    // Pointer types are nullable
+    if (normalizedType.includes('*')) {
+        return true;
+    }
+    
+    // Reference types are NOT nullable
+    if (normalizedType.includes('&')) {
+        return false;
+    }
+    
+    // Value types and primitives are NOT nullable
+    return false;
+}
+
 /**
  * Checks if a C++ type can be represented in the C API.
  * Returns null if the type can be handled, or an error message if not.

spine-c/src/generated/alpha_timeline.cpp

@@ -16,7 +16,7 @@ spine_rtti spine_alpha_timeline_get_rtti(spine_alpha_timeline self) {
 	return (spine_rtti) &_self->getRTTI();
 }
 
-void spine_alpha_timeline_apply(spine_alpha_timeline self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents,
+void spine_alpha_timeline_apply(spine_alpha_timeline self, spine_skeleton skeleton, float lastTime, float time, /*@null*/ spine_array_event pEvents,
 								float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
 	AlphaTimeline *_self = (AlphaTimeline *) self;
 	_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) pEvents, alpha, (MixBlend) blend, (MixDirection) direction,

spine-c/src/generated/alpha_timeline.h

@@ -14,8 +14,9 @@ SPINE_C_API spine_alpha_timeline spine_alpha_timeline_create(size_t frameCount,
 SPINE_C_API void spine_alpha_timeline_dispose(spine_alpha_timeline self);
 
 SPINE_C_API spine_rtti spine_alpha_timeline_get_rtti(spine_alpha_timeline self);
-SPINE_C_API void spine_alpha_timeline_apply(spine_alpha_timeline self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents,
-											float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose);
+SPINE_C_API void spine_alpha_timeline_apply(spine_alpha_timeline self, spine_skeleton skeleton, float lastTime, float time,
+											/*@null*/ spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction,
+											bool appliedPose);
 SPINE_C_API int spine_alpha_timeline_get_slot_index(spine_alpha_timeline self);
 SPINE_C_API void spine_alpha_timeline_set_slot_index(spine_alpha_timeline self, int inValue);
 SPINE_C_API void spine_alpha_timeline_set_frame(spine_alpha_timeline self, size_t frame, float time, float value);

spine-c/src/generated/animation.cpp

@@ -3,7 +3,7 @@
 
 using namespace spine;
 
-spine_animation spine_animation_create(const char *name, spine_array_timeline timelines, float duration) {
+spine_animation spine_animation_create(const char *name, /*@null*/ spine_array_timeline timelines, float duration) {
 	return (spine_animation) new (__FILE__, __LINE__) Animation(String(name), *((Array<Timeline *> *) timelines), duration);
 }
 
@@ -11,12 +11,12 @@ void spine_animation_dispose(spine_animation self) {
 	delete (Animation *) self;
 }
 
-spine_array_timeline spine_animation_get_timelines(spine_animation self) {
+/*@null*/ spine_array_timeline spine_animation_get_timelines(spine_animation self) {
 	Animation *_self = (Animation *) self;
 	return (spine_array_timeline) &_self->getTimelines();
 }
 
-void spine_animation_set_timelines(spine_animation self, spine_array_timeline timelines) {
+void spine_animation_set_timelines(spine_animation self, /*@null*/ spine_array_timeline timelines) {
 	Animation *_self = (Animation *) self;
 	_self->setTimelines(*((Array<Timeline *> *) timelines));
 }
@@ -36,7 +36,7 @@ void spine_animation_set_duration(spine_animation self, float inValue) {
 	_self->setDuration(inValue);
 }
 
-void spine_animation_apply(spine_animation self, spine_skeleton skeleton, float lastTime, float time, bool loop, spine_array_event pEvents,
+void spine_animation_apply(spine_animation self, spine_skeleton skeleton, float lastTime, float time, bool loop, /*@null*/ spine_array_event pEvents,
 						   float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
 	Animation *_self = (Animation *) self;
 	_self->apply(*((Skeleton *) skeleton), lastTime, time, loop, (Array<Event *> *) pEvents, alpha, (MixBlend) blend, (MixDirection) direction,

spine-c/src/generated/animation.h

@@ -9,17 +9,17 @@
 extern "C" {
 #endif
 
-SPINE_C_API spine_animation spine_animation_create(const char *name, spine_array_timeline timelines, float duration);
+SPINE_C_API spine_animation spine_animation_create(const char *name, /*@null*/ spine_array_timeline timelines, float duration);
 
 SPINE_C_API void spine_animation_dispose(spine_animation self);
 
-SPINE_C_API spine_array_timeline spine_animation_get_timelines(spine_animation self);
-SPINE_C_API void spine_animation_set_timelines(spine_animation self, spine_array_timeline timelines);
+SPINE_C_API /*@null*/ spine_array_timeline spine_animation_get_timelines(spine_animation self);
+SPINE_C_API void spine_animation_set_timelines(spine_animation self, /*@null*/ spine_array_timeline timelines);
 SPINE_C_API bool spine_animation_has_timeline(spine_animation self, spine_array_property_id ids);
 SPINE_C_API float spine_animation_get_duration(spine_animation self);
 SPINE_C_API void spine_animation_set_duration(spine_animation self, float inValue);
 SPINE_C_API void spine_animation_apply(spine_animation self, spine_skeleton skeleton, float lastTime, float time, bool loop,
-									   spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction,
+									   /*@null*/ spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction,
 									   bool appliedPose);
 SPINE_C_API const char *spine_animation_get_name(spine_animation self);
 SPINE_C_API spine_array_int spine_animation_get_bones(spine_animation self);

spine-c/src/generated/animation_state.cpp

@@ -3,7 +3,7 @@
 
 using namespace spine;
 
-spine_animation_state spine_animation_state_create(spine_animation_state_data data) {
+spine_animation_state spine_animation_state_create(/*@null*/ spine_animation_state_data data) {
 	return (spine_animation_state) new (__FILE__, __LINE__) AnimationState((AnimationStateData *) data);
 }
 
@@ -36,7 +36,8 @@ spine_track_entry spine_animation_state_set_animation_1(spine_animation_state se
 	return (spine_track_entry) &_self->setAnimation(trackIndex, String(animationName), loop);
 }
 
-spine_track_entry spine_animation_state_set_animation_2(spine_animation_state self, size_t trackIndex, spine_animation animation, bool loop) {
+spine_track_entry spine_animation_state_set_animation_2(spine_animation_state self, size_t trackIndex, /*@null*/ spine_animation animation,
+														bool loop) {
 	AnimationState *_self = (AnimationState *) self;
 	return (spine_track_entry) &_self->setAnimation(trackIndex, (Animation *) animation, loop);
 }
@@ -47,7 +48,7 @@ spine_track_entry spine_animation_state_add_animation_1(spine_animation_state se
 	return (spine_track_entry) &_self->addAnimation(trackIndex, String(animationName), loop, delay);
 }
 
-spine_track_entry spine_animation_state_add_animation_2(spine_animation_state self, size_t trackIndex, spine_animation animation, bool loop,
+spine_track_entry spine_animation_state_add_animation_2(spine_animation_state self, size_t trackIndex, /*@null*/ spine_animation animation, bool loop,
 														float delay) {
 	AnimationState *_self = (AnimationState *) self;
 	return (spine_track_entry) &_self->addAnimation(trackIndex, (Animation *) animation, loop, delay);
@@ -68,7 +69,7 @@ void spine_animation_state_set_empty_animations(spine_animation_state self, floa
 	_self->setEmptyAnimations(mixDuration);
 }
 
-spine_track_entry spine_animation_state_get_current(spine_animation_state self, size_t trackIndex) {
+/*@null*/ spine_track_entry spine_animation_state_get_current(spine_animation_state self, size_t trackIndex) {
 	AnimationState *_self = (AnimationState *) self;
 	return (spine_track_entry) _self->getCurrent(trackIndex);
 }
@@ -78,7 +79,7 @@ spine_animation_state_data spine_animation_state_get_data(spine_animation_state
 	return (spine_animation_state_data) &_self->getData();
 }
 
-spine_array_track_entry spine_animation_state_get_tracks(spine_animation_state self) {
+/*@null*/ spine_array_track_entry spine_animation_state_get_tracks(spine_animation_state self) {
 	AnimationState *_self = (AnimationState *) self;
 	return (spine_array_track_entry) &_self->getTracks();
 }
@@ -113,12 +114,12 @@ bool spine_animation_state_get_manual_track_entry_disposal(spine_animation_state
 	return _self->getManualTrackEntryDisposal();
 }
 
-void spine_animation_state_dispose_track_entry(spine_animation_state self, spine_track_entry entry) {
+void spine_animation_state_dispose_track_entry(spine_animation_state self, /*@null*/ spine_track_entry entry) {
 	AnimationState *_self = (AnimationState *) self;
 	_self->disposeTrackEntry((TrackEntry *) entry);
 }
 
-void *spine_animation_state_get_renderer_object(spine_animation_state self) {
+/*@null*/ void *spine_animation_state_get_renderer_object(spine_animation_state self) {
 	HasRendererObject *_self = (HasRendererObject *) (AnimationState *) self;
 	return _self->getRendererObject();
 }

spine-c/src/generated/animation_state.h

@@ -9,7 +9,7 @@
 extern "C" {
 #endif
 
-SPINE_C_API spine_animation_state spine_animation_state_create(spine_animation_state_data data);
+SPINE_C_API spine_animation_state spine_animation_state_create(/*@null*/ spine_animation_state_data data);
 
 SPINE_C_API void spine_animation_state_dispose(spine_animation_state self);
 
@@ -19,27 +19,27 @@ SPINE_C_API void spine_animation_state_clear_tracks(spine_animation_state self);
 SPINE_C_API void spine_animation_state_clear_track(spine_animation_state self, size_t trackIndex);
 SPINE_C_API spine_track_entry spine_animation_state_set_animation_1(spine_animation_state self, size_t trackIndex, const char *animationName,
 																	bool loop);
-SPINE_C_API spine_track_entry spine_animation_state_set_animation_2(spine_animation_state self, size_t trackIndex, spine_animation animation,
-																	bool loop);
+SPINE_C_API spine_track_entry spine_animation_state_set_animation_2(spine_animation_state self, size_t trackIndex,
+																	/*@null*/ spine_animation animation, bool loop);
 SPINE_C_API spine_track_entry spine_animation_state_add_animation_1(spine_animation_state self, size_t trackIndex, const char *animationName,
 																	bool loop, float delay);
-SPINE_C_API spine_track_entry spine_animation_state_add_animation_2(spine_animation_state self, size_t trackIndex, spine_animation animation,
-																	bool loop, float delay);
+SPINE_C_API spine_track_entry spine_animation_state_add_animation_2(spine_animation_state self, size_t trackIndex,
+																	/*@null*/ spine_animation animation, bool loop, float delay);
 SPINE_C_API spine_track_entry spine_animation_state_set_empty_animation(spine_animation_state self, size_t trackIndex, float mixDuration);
 SPINE_C_API spine_track_entry spine_animation_state_add_empty_animation(spine_animation_state self, size_t trackIndex, float mixDuration,
 																		float delay);
 SPINE_C_API void spine_animation_state_set_empty_animations(spine_animation_state self, float mixDuration);
-SPINE_C_API spine_track_entry spine_animation_state_get_current(spine_animation_state self, size_t trackIndex);
+SPINE_C_API /*@null*/ spine_track_entry spine_animation_state_get_current(spine_animation_state self, size_t trackIndex);
 SPINE_C_API spine_animation_state_data spine_animation_state_get_data(spine_animation_state self);
-SPINE_C_API spine_array_track_entry spine_animation_state_get_tracks(spine_animation_state self);
+SPINE_C_API /*@null*/ spine_array_track_entry spine_animation_state_get_tracks(spine_animation_state self);
 SPINE_C_API float spine_animation_state_get_time_scale(spine_animation_state self);
 SPINE_C_API void spine_animation_state_set_time_scale(spine_animation_state self, float inValue);
 SPINE_C_API void spine_animation_state_disable_queue(spine_animation_state self);
 SPINE_C_API void spine_animation_state_enable_queue(spine_animation_state self);
 SPINE_C_API void spine_animation_state_set_manual_track_entry_disposal(spine_animation_state self, bool inValue);
 SPINE_C_API bool spine_animation_state_get_manual_track_entry_disposal(spine_animation_state self);
-SPINE_C_API void spine_animation_state_dispose_track_entry(spine_animation_state self, spine_track_entry entry);
-SPINE_C_API void *spine_animation_state_get_renderer_object(spine_animation_state self);
+SPINE_C_API void spine_animation_state_dispose_track_entry(spine_animation_state self, /*@null*/ spine_track_entry entry);
+SPINE_C_API /*@null*/ void *spine_animation_state_get_renderer_object(spine_animation_state self);
 
 #ifdef __cplusplus
 }

spine-c/src/generated/animation_state_data.cpp

@@ -3,7 +3,7 @@
 
 using namespace spine;
 
-spine_animation_state_data spine_animation_state_data_create(spine_skeleton_data skeletonData) {
+spine_animation_state_data spine_animation_state_data_create(/*@null*/ spine_skeleton_data skeletonData) {
 	return (spine_animation_state_data) new (__FILE__, __LINE__) AnimationStateData((SkeletonData *) skeletonData);
 }
 

spine-c/src/generated/animation_state_data.h

@@ -9,7 +9,7 @@
 extern "C" {
 #endif
 
-SPINE_C_API spine_animation_state_data spine_animation_state_data_create(spine_skeleton_data skeletonData);
+SPINE_C_API spine_animation_state_data spine_animation_state_data_create(/*@null*/ spine_skeleton_data skeletonData);
 
 SPINE_C_API void spine_animation_state_data_dispose(spine_animation_state_data self);
 

spine-c/src/generated/arrays.h

@@ -91,7 +91,7 @@ SPINE_C_API bool spine_array_float_contains(spine_array_float array, float inVal
 
 SPINE_C_API int spine_array_float_index_of(spine_array_float array, float inValue);
 
-SPINE_C_API float *spine_array_float_buffer(spine_array_float array);
+SPINE_C_API /*@null*/ float *spine_array_float_buffer(spine_array_float array);
 
 SPINE_C_API spine_array_int spine_array_int_create(void);
 
@@ -119,7 +119,7 @@ SPINE_C_API bool spine_array_int_contains(spine_array_int array, int inValue);
 
 SPINE_C_API int spine_array_int_index_of(spine_array_int array, int inValue);
 
-SPINE_C_API int *spine_array_int_buffer(spine_array_int array);
+SPINE_C_API /*@null*/ int *spine_array_int_buffer(spine_array_int array);
 
 SPINE_C_API spine_array_unsigned_short spine_array_unsigned_short_create(void);
 
@@ -148,7 +148,7 @@ SPINE_C_API bool spine_array_unsigned_short_contains(spine_array_unsigned_short
 
 SPINE_C_API int spine_array_unsigned_short_index_of(spine_array_unsigned_short array, unsigned short inValue);
 
-SPINE_C_API unsigned short *spine_array_unsigned_short_buffer(spine_array_unsigned_short array);
+SPINE_C_API /*@null*/ unsigned short *spine_array_unsigned_short_buffer(spine_array_unsigned_short array);
 
 SPINE_C_API spine_array_property_id spine_array_property_id_create(void);
 
@@ -176,7 +176,7 @@ SPINE_C_API bool spine_array_property_id_contains(spine_array_property_id array,
 
 SPINE_C_API int spine_array_property_id_index_of(spine_array_property_id array, int64_t inValue);
 
-SPINE_C_API int64_t *spine_array_property_id_buffer(spine_array_property_id array);
+SPINE_C_API /*@null*/ int64_t *spine_array_property_id_buffer(spine_array_property_id array);
 
 SPINE_C_API spine_array_animation spine_array_animation_create(void);
 
@@ -188,23 +188,24 @@ SPINE_C_API size_t spine_array_animation_get_capacity(spine_array_animation arra
 
 SPINE_C_API size_t spine_array_animation_size(spine_array_animation array);
 
-SPINE_C_API spine_array_animation spine_array_animation_set_size(spine_array_animation array, size_t newSize, spine_animation defaultValue);
+SPINE_C_API /*@null*/ spine_array_animation spine_array_animation_set_size(spine_array_animation array, size_t newSize,
+																		   /*@null*/ spine_animation defaultValue);
 
 SPINE_C_API void spine_array_animation_ensure_capacity(spine_array_animation array, size_t newCapacity);
 
-SPINE_C_API void spine_array_animation_add(spine_array_animation array, spine_animation inValue);
+SPINE_C_API void spine_array_animation_add(spine_array_animation array, /*@null*/ spine_animation inValue);
 
-SPINE_C_API void spine_array_animation_add_all(spine_array_animation array, spine_array_animation inValue);
+SPINE_C_API void spine_array_animation_add_all(spine_array_animation array, /*@null*/ spine_array_animation inValue);
 
-SPINE_C_API void spine_array_animation_clear_and_add_all(spine_array_animation array, spine_array_animation inValue);
+SPINE_C_API void spine_array_animation_clear_and_add_all(spine_array_animation array, /*@null*/ spine_array_animation inValue);
 
 SPINE_C_API void spine_array_animation_remove_at(spine_array_animation array, size_t inIndex);
 
-SPINE_C_API bool spine_array_animation_contains(spine_array_animation array, spine_animation inValue);
+SPINE_C_API bool spine_array_animation_contains(spine_array_animation array, /*@null*/ spine_animation inValue);
 
-SPINE_C_API int spine_array_animation_index_of(spine_array_animation array, spine_animation inValue);
+SPINE_C_API int spine_array_animation_index_of(spine_array_animation array, /*@null*/ spine_animation inValue);
 
-SPINE_C_API spine_animation *spine_array_animation_buffer(spine_array_animation array);
+SPINE_C_API /*@null*/ spine_animation *spine_array_animation_buffer(spine_array_animation array);
 
 SPINE_C_API spine_array_atlas_page spine_array_atlas_page_create(void);
 
@@ -216,23 +217,24 @@ SPINE_C_API size_t spine_array_atlas_page_get_capacity(spine_array_atlas_page ar
 
 SPINE_C_API size_t spine_array_atlas_page_size(spine_array_atlas_page array);
 
-SPINE_C_API spine_array_atlas_page spine_array_atlas_page_set_size(spine_array_atlas_page array, size_t newSize, spine_atlas_page defaultValue);
+SPINE_C_API /*@null*/ spine_array_atlas_page spine_array_atlas_page_set_size(spine_array_atlas_page array, size_t newSize,
+																			 /*@null*/ spine_atlas_page defaultValue);
 
 SPINE_C_API void spine_array_atlas_page_ensure_capacity(spine_array_atlas_page array, size_t newCapacity);
 
-SPINE_C_API void spine_array_atlas_page_add(spine_array_atlas_page array, spine_atlas_page inValue);
+SPINE_C_API void spine_array_atlas_page_add(spine_array_atlas_page array, /*@null*/ spine_atlas_page inValue);
 
-SPINE_C_API void spine_array_atlas_page_add_all(spine_array_atlas_page array, spine_array_atlas_page inValue);
+SPINE_C_API void spine_array_atlas_page_add_all(spine_array_atlas_page array, /*@null*/ spine_array_atlas_page inValue);
 
-SPINE_C_API void spine_array_atlas_page_clear_and_add_all(spine_array_atlas_page array, spine_array_atlas_page inValue);
+SPINE_C_API void spine_array_atlas_page_clear_and_add_all(spine_array_atlas_page array, /*@null*/ spine_array_atlas_page inValue);
 
 SPINE_C_API void spine_array_atlas_page_remove_at(spine_array_atlas_page array, size_t inIndex);
 
-SPINE_C_API bool spine_array_atlas_page_contains(spine_array_atlas_page array, spine_atlas_page inValue);
+SPINE_C_API bool spine_array_atlas_page_contains(spine_array_atlas_page array, /*@null*/ spine_atlas_page inValue);
 
-SPINE_C_API int spine_array_atlas_page_index_of(spine_array_atlas_page array, spine_atlas_page inValue);
+SPINE_C_API int spine_array_atlas_page_index_of(spine_array_atlas_page array, /*@null*/ spine_atlas_page inValue);
 
-SPINE_C_API spine_atlas_page *spine_array_atlas_page_buffer(spine_array_atlas_page array);
+SPINE_C_API /*@null*/ spine_atlas_page *spine_array_atlas_page_buffer(spine_array_atlas_page array);
 
 SPINE_C_API spine_array_atlas_region spine_array_atlas_region_create(void);
 
@@ -244,24 +246,24 @@ SPINE_C_API size_t spine_array_atlas_region_get_capacity(spine_array_atlas_regio
 
 SPINE_C_API size_t spine_array_atlas_region_size(spine_array_atlas_region array);
 
-SPINE_C_API spine_array_atlas_region spine_array_atlas_region_set_size(spine_array_atlas_region array, size_t newSize,
-																	   spine_atlas_region defaultValue);
+SPINE_C_API /*@null*/ spine_array_atlas_region spine_array_atlas_region_set_size(spine_array_atlas_region array, size_t newSize,
+																				 /*@null*/ spine_atlas_region defaultValue);
 
 SPINE_C_API void spine_array_atlas_region_ensure_capacity(spine_array_atlas_region array, size_t newCapacity);
 
-SPINE_C_API void spine_array_atlas_region_add(spine_array_atlas_region array, spine_atlas_region inValue);
+SPINE_C_API void spine_array_atlas_region_add(spine_array_atlas_region array, /*@null*/ spine_atlas_region inValue);
 
-SPINE_C_API void spine_array_atlas_region_add_all(spine_array_atlas_region array, spine_array_atlas_region inValue);
+SPINE_C_API void spine_array_atlas_region_add_all(spine_array_atlas_region array, /*@null*/ spine_array_atlas_region inValue);
 
-SPINE_C_API void spine_array_atlas_region_clear_and_add_all(spine_array_atlas_region array, spine_array_atlas_region inValue);
+SPINE_C_API void spine_array_atlas_region_clear_and_add_all(spine_array_atlas_region array, /*@null*/ spine_array_atlas_region inValue);
 
 SPINE_C_API void spine_array_atlas_region_remove_at(spine_array_atlas_region array, size_t inIndex);
 
-SPINE_C_API bool spine_array_atlas_region_contains(spine_array_atlas_region array, spine_atlas_region inValue);
+SPINE_C_API bool spine_array_atlas_region_contains(spine_array_atlas_region array, /*@null*/ spine_atlas_region inValue);
 
-SPINE_C_API int spine_array_atlas_region_index_of(spine_array_atlas_region array, spine_atlas_region inValue);
+SPINE_C_API int spine_array_atlas_region_index_of(spine_array_atlas_region array, /*@null*/ spine_atlas_region inValue);
 
-SPINE_C_API spine_atlas_region *spine_array_atlas_region_buffer(spine_array_atlas_region array);
+SPINE_C_API /*@null*/ spine_atlas_region *spine_array_atlas_region_buffer(spine_array_atlas_region array);
 
 SPINE_C_API spine_array_attachment spine_array_attachment_create(void);
 
@@ -273,23 +275,24 @@ SPINE_C_API size_t spine_array_attachment_get_capacity(spine_array_attachment ar
 
 SPINE_C_API size_t spine_array_attachment_size(spine_array_attachment array);
 
-SPINE_C_API spine_array_attachment spine_array_attachment_set_size(spine_array_attachment array, size_t newSize, spine_attachment defaultValue);
+SPINE_C_API /*@null*/ spine_array_attachment spine_array_attachment_set_size(spine_array_attachment array, size_t newSize,
+																			 /*@null*/ spine_attachment defaultValue);
 
 SPINE_C_API void spine_array_attachment_ensure_capacity(spine_array_attachment array, size_t newCapacity);
 
-SPINE_C_API void spine_array_attachment_add(spine_array_attachment array, spine_attachment inValue);
+SPINE_C_API void spine_array_attachment_add(spine_array_attachment array, /*@null*/ spine_attachment inValue);
 
-SPINE_C_API void spine_array_attachment_add_all(spine_array_attachment array, spine_array_attachment inValue);
+SPINE_C_API void spine_array_attachment_add_all(spine_array_attachment array, /*@null*/ spine_array_attachment inValue);
 
-SPINE_C_API void spine_array_attachment_clear_and_add_all(spine_array_attachment array, spine_array_attachment inValue);
+SPINE_C_API void spine_array_attachment_clear_and_add_all(spine_array_attachment array, /*@null*/ spine_array_attachment inValue);
 
 SPINE_C_API void spine_array_attachment_remove_at(spine_array_attachment array, size_t inIndex);
 
-SPINE_C_API bool spine_array_attachment_contains(spine_array_attachment array, spine_attachment inValue);
+SPINE_C_API bool spine_array_attachment_contains(spine_array_attachment array, /*@null*/ spine_attachment inValue);
 
-SPINE_C_API int spine_array_attachment_index_of(spine_array_attachment array, spine_attachment inValue);
+SPINE_C_API int spine_array_attachment_index_of(spine_array_attachment array, /*@null*/ spine_attachment inValue);
 
-SPINE_C_API spine_attachment *spine_array_attachment_buffer(spine_array_attachment array);
+SPINE_C_API /*@null*/ spine_attachment *spine_array_attachment_buffer(spine_array_attachment array);
 
 SPINE_C_API spine_array_bone spine_array_bone_create(void);
 
@@ -301,23 +304,23 @@ SPINE_C_API size_t spine_array_bone_get_capacity(spine_array_bone array);
 
 SPINE_C_API size_t spine_array_bone_size(spine_array_bone array);
 
-SPINE_C_API spine_array_bone spine_array_bone_set_size(spine_array_bone array, size_t newSize, spine_bone defaultValue);
+SPINE_C_API /*@null*/ spine_array_bone spine_array_bone_set_size(spine_array_bone array, size_t newSize, /*@null*/ spine_bone defaultValue);
 
 SPINE_C_API void spine_array_bone_ensure_capacity(spine_array_bone array, size_t newCapacity);
 
-SPINE_C_API void spine_array_bone_add(spine_array_bone array, spine_bone inValue);
+SPINE_C_API void spine_array_bone_add(spine_array_bone array, /*@null*/ spine_bone inValue);
 
-SPINE_C_API void spine_array_bone_add_all(spine_array_bone array, spine_array_bone inValue);
+SPINE_C_API void spine_array_bone_add_all(spine_array_bone array, /*@null*/ spine_array_bone inValue);
 
-SPINE_C_API void spine_array_bone_clear_and_add_all(spine_array_bone array, spine_array_bone inValue);
+SPINE_C_API void spine_array_bone_clear_and_add_all(spine_array_bone array, /*@null*/ spine_array_bone inValue);
 
 SPINE_C_API void spine_array_bone_remove_at(spine_array_bone array, size_t inIndex);
 
-SPINE_C_API bool spine_array_bone_contains(spine_array_bone array, spine_bone inValue);
+SPINE_C_API bool spine_array_bone_contains(spine_array_bone array, /*@null*/ spine_bone inValue);
 
-SPINE_C_API int spine_array_bone_index_of(spine_array_bone array, spine_bone inValue);
+SPINE_C_API int spine_array_bone_index_of(spine_array_bone array, /*@null*/ spine_bone inValue);
 
-SPINE_C_API spine_bone *spine_array_bone_buffer(spine_array_bone array);
+SPINE_C_API /*@null*/ spine_bone *spine_array_bone_buffer(spine_array_bone array);
 
 SPINE_C_API spine_array_bone_data spine_array_bone_data_create(void);
 
@@ -329,23 +332,24 @@ SPINE_C_API size_t spine_array_bone_data_get_capacity(spine_array_bone_data arra
 
 SPINE_C_API size_t spine_array_bone_data_size(spine_array_bone_data array);
 
-SPINE_C_API spine_array_bone_data spine_array_bone_data_set_size(spine_array_bone_data array, size_t newSize, spine_bone_data defaultValue);
+SPINE_C_API /*@null*/ spine_array_bone_data spine_array_bone_data_set_size(spine_array_bone_data array, size_t newSize,
+																		   /*@null*/ spine_bone_data defaultValue);
 
 SPINE_C_API void spine_array_bone_data_ensure_capacity(spine_array_bone_data array, size_t newCapacity);
 
-SPINE_C_API void spine_array_bone_data_add(spine_array_bone_data array, spine_bone_data inValue);
+SPINE_C_API void spine_array_bone_data_add(spine_array_bone_data array, /*@null*/ spine_bone_data inValue);
 
-SPINE_C_API void spine_array_bone_data_add_all(spine_array_bone_data array, spine_array_bone_data inValue);
+SPINE_C_API void spine_array_bone_data_add_all(spine_array_bone_data array, /*@null*/ spine_array_bone_data inValue);
 
-SPINE_C_API void spine_array_bone_data_clear_and_add_all(spine_array_bone_data array, spine_array_bone_data inValue);
+SPINE_C_API void spine_array_bone_data_clear_and_add_all(spine_array_bone_data array, /*@null*/ spine_array_bone_data inValue);
 
 SPINE_C_API void spine_array_bone_data_remove_at(spine_array_bone_data array, size_t inIndex);
 
-SPINE_C_API bool spine_array_bone_data_contains(spine_array_bone_data array, spine_bone_data inValue);
+SPINE_C_API bool spine_array_bone_data_contains(spine_array_bone_data array, /*@null*/ spine_bone_data inValue);
 
-SPINE_C_API int spine_array_bone_data_index_of(spine_array_bone_data array, spine_bone_data inValue);
+SPINE_C_API int spine_array_bone_data_index_of(spine_array_bone_data array, /*@null*/ spine_bone_data inValue);
 
-SPINE_C_API spine_bone_data *spine_array_bone_data_buffer(spine_array_bone_data array);
+SPINE_C_API /*@null*/ spine_bone_data *spine_array_bone_data_buffer(spine_array_bone_data array);
 
 SPINE_C_API spine_array_bone_pose spine_array_bone_pose_create(void);
 
@@ -357,23 +361,24 @@ SPINE_C_API size_t spine_array_bone_pose_get_capacity(spine_array_bone_pose arra
 
 SPINE_C_API size_t spine_array_bone_pose_size(spine_array_bone_pose array);
 
-SPINE_C_API spine_array_bone_pose spine_array_bone_pose_set_size(spine_array_bone_pose array, size_t newSize, spine_bone_pose defaultValue);
+SPINE_C_API /*@null*/ spine_array_bone_pose spine_array_bone_pose_set_size(spine_array_bone_pose array, size_t newSize,
+																		   /*@null*/ spine_bone_pose defaultValue);
 
 SPINE_C_API void spine_array_bone_pose_ensure_capacity(spine_array_bone_pose array, size_t newCapacity);
 
-SPINE_C_API void spine_array_bone_pose_add(spine_array_bone_pose array, spine_bone_pose inValue);
+SPINE_C_API void spine_array_bone_pose_add(spine_array_bone_pose array, /*@null*/ spine_bone_pose inValue);
 
-SPINE_C_API void spine_array_bone_pose_add_all(spine_array_bone_pose array, spine_array_bone_pose inValue);
+SPINE_C_API void spine_array_bone_pose_add_all(spine_array_bone_pose array, /*@null*/ spine_array_bone_pose inValue);
 
-SPINE_C_API void spine_array_bone_pose_clear_and_add_all(spine_array_bone_pose array, spine_array_bone_pose inValue);
+SPINE_C_API void spine_array_bone_pose_clear_and_add_all(spine_array_bone_pose array, /*@null*/ spine_array_bone_pose inValue);
 
 SPINE_C_API void spine_array_bone_pose_remove_at(spine_array_bone_pose array, size_t inIndex);
 
-SPINE_C_API bool spine_array_bone_pose_contains(spine_array_bone_pose array, spine_bone_pose inValue);
+SPINE_C_API bool spine_array_bone_pose_contains(spine_array_bone_pose array, /*@null*/ spine_bone_pose inValue);
 
-SPINE_C_API int spine_array_bone_pose_index_of(spine_array_bone_pose array, spine_bone_pose inValue);
+SPINE_C_API int spine_array_bone_pose_index_of(spine_array_bone_pose array, /*@null*/ spine_bone_pose inValue);
 
-SPINE_C_API spine_bone_pose *spine_array_bone_pose_buffer(spine_array_bone_pose array);
+SPINE_C_API /*@null*/ spine_bone_pose *spine_array_bone_pose_buffer(spine_array_bone_pose array);
 
 SPINE_C_API spine_array_bounding_box_attachment spine_array_bounding_box_attachment_create(void);
 
@@ -385,26 +390,28 @@ SPINE_C_API size_t spine_array_bounding_box_attachment_get_capacity(spine_array_
 
 SPINE_C_API size_t spine_array_bounding_box_attachment_size(spine_array_bounding_box_attachment array);
 
-SPINE_C_API spine_array_bounding_box_attachment spine_array_bounding_box_attachment_set_size(spine_array_bounding_box_attachment array,
-																							 size_t newSize,
-																							 spine_bounding_box_attachment defaultValue);
+SPINE_C_API /*@null*/ spine_array_bounding_box_attachment spine_array_bounding_box_attachment_set_size(
+	spine_array_bounding_box_attachment array, size_t newSize, /*@null*/ spine_bounding_box_attachment defaultValue);
 
 SPINE_C_API void spine_array_bounding_box_attachment_ensure_capacity(spine_array_bounding_box_attachment array, size_t newCapacity);
 
-SPINE_C_API void spine_array_bounding_box_attachment_add(spine_array_bounding_box_attachment array, spine_bounding_box_attachment inValue);
+SPINE_C_API void spine_array_bounding_box_attachment_add(spine_array_bounding_box_attachment array, /*@null*/ spine_bounding_box_attachment inValue);
 
-SPINE_C_API void spine_array_bounding_box_attachment_add_all(spine_array_bounding_box_attachment array, spine_array_bounding_box_attachment inValue);
+SPINE_C_API void spine_array_bounding_box_attachment_add_all(spine_array_bounding_box_attachment array,
+															 /*@null*/ spine_array_bounding_box_attachment inValue);
 
 SPINE_C_API void spine_array_bounding_box_attachment_clear_and_add_all(spine_array_bounding_box_attachment array,
-																	   spine_array_bounding_box_attachment inValue);
+																	   /*@null*/ spine_array_bounding_box_attachment inValue);
 
 SPINE_C_API void spine_array_bounding_box_attachment_remove_at(spine_array_bounding_box_attachment array, size_t inIndex);
 
-SPINE_C_API bool spine_array_bounding_box_attachment_contains(spine_array_bounding_box_attachment array, spine_bounding_box_attachment inValue);
+SPINE_C_API bool spine_array_bounding_box_attachment_contains(spine_array_bounding_box_attachment array,
+															  /*@null*/ spine_bounding_box_attachment inValue);
 
-SPINE_C_API int spine_array_bounding_box_attachment_index_of(spine_array_bounding_box_attachment array, spine_bounding_box_attachment inValue);
+SPINE_C_API int spine_array_bounding_box_attachment_index_of(spine_array_bounding_box_attachment array,
+															 /*@null*/ spine_bounding_box_attachment inValue);
 
-SPINE_C_API spine_bounding_box_attachment *spine_array_bounding_box_attachment_buffer(spine_array_bounding_box_attachment array);
+SPINE_C_API /*@null*/ spine_bounding_box_attachment *spine_array_bounding_box_attachment_buffer(spine_array_bounding_box_attachment array);
 
 SPINE_C_API spine_array_constraint spine_array_constraint_create(void);
 
@@ -416,23 +423,24 @@ SPINE_C_API size_t spine_array_constraint_get_capacity(spine_array_constraint ar
 
 SPINE_C_API size_t spine_array_constraint_size(spine_array_constraint array);
 
-SPINE_C_API spine_array_constraint spine_array_constraint_set_size(spine_array_constraint array, size_t newSize, spine_constraint defaultValue);
+SPINE_C_API /*@null*/ spine_array_constraint spine_array_constraint_set_size(spine_array_constraint array, size_t newSize,
+																			 /*@null*/ spine_constraint defaultValue);
 
 SPINE_C_API void spine_array_constraint_ensure_capacity(spine_array_constraint array, size_t newCapacity);
 
-SPINE_C_API void spine_array_constraint_add(spine_array_constraint array, spine_constraint inValue);
+SPINE_C_API void spine_array_constraint_add(spine_array_constraint array, /*@null*/ spine_constraint inValue);
 
-SPINE_C_API void spine_array_constraint_add_all(spine_array_constraint array, spine_array_constraint inValue);
+SPINE_C_API void spine_array_constraint_add_all(spine_array_constraint array, /*@null*/ spine_array_constraint inValue);
 
-SPINE_C_API void spine_array_constraint_clear_and_add_all(spine_array_constraint array, spine_array_constraint inValue);
+SPINE_C_API void spine_array_constraint_clear_and_add_all(spine_array_constraint array, /*@null*/ spine_array_constraint inValue);
 
 SPINE_C_API void spine_array_constraint_remove_at(spine_array_constraint array, size_t inIndex);
 
-SPINE_C_API bool spine_array_constraint_contains(spine_array_constraint array, spine_constraint inValue);
+SPINE_C_API bool spine_array_constraint_contains(spine_array_constraint array, /*@null*/ spine_constraint inValue);
 
-SPINE_C_API int spine_array_constraint_index_of(spine_array_constraint array, spine_constraint inValue);
+SPINE_C_API int spine_array_constraint_index_of(spine_array_constraint array, /*@null*/ spine_constraint inValue);
 
-SPINE_C_API spine_constraint *spine_array_constraint_buffer(spine_array_constraint array);
+SPINE_C_API /*@null*/ spine_constraint *spine_array_constraint_buffer(spine_array_constraint array);
 
 SPINE_C_API spine_array_constraint_data spine_array_constraint_data_create(void);
 
@@ -444,24 +452,24 @@ SPINE_C_API size_t spine_array_constraint_data_get_capacity(spine_array_constrai
 
 SPINE_C_API size_t spine_array_constraint_data_size(spine_array_constraint_data array);
 
-SPINE_C_API spine_array_constraint_data spine_array_constraint_data_set_size(spine_array_constraint_data array, size_t newSize,
-																			 spine_constraint_data defaultValue);
+SPINE_C_API /*@null*/ spine_array_constraint_data spine_array_constraint_data_set_size(spine_array_constraint_data array, size_t newSize,
+																					   /*@null*/ spine_constraint_data defaultValue);
 
 SPINE_C_API void spine_array_constraint_data_ensure_capacity(spine_array_constraint_data array, size_t newCapacity);
 
-SPINE_C_API void spine_array_constraint_data_add(spine_array_constraint_data array, spine_constraint_data inValue);
+SPINE_C_API void spine_array_constraint_data_add(spine_array_constraint_data array, /*@null*/ spine_constraint_data inValue);
 
-SPINE_C_API void spine_array_constraint_data_add_all(spine_array_constraint_data array, spine_array_constraint_data inValue);
+SPINE_C_API void spine_array_constraint_data_add_all(spine_array_constraint_data array, /*@null*/ spine_array_constraint_data inValue);
 
-SPINE_C_API void spine_array_constraint_data_clear_and_add_all(spine_array_constraint_data array, spine_array_constraint_data inValue);
+SPINE_C_API void spine_array_constraint_data_clear_and_add_all(spine_array_constraint_data array, /*@null*/ spine_array_constraint_data inValue);
 
 SPINE_C_API void spine_array_constraint_data_remove_at(spine_array_constraint_data array, size_t inIndex);
 
-SPINE_C_API bool spine_array_constraint_data_contains(spine_array_constraint_data array, spine_constraint_data inValue);
+SPINE_C_API bool spine_array_constraint_data_contains(spine_array_constraint_data array, /*@null*/ spine_constraint_data inValue);
 
-SPINE_C_API int spine_array_constraint_data_index_of(spine_array_constraint_data array, spine_constraint_data inValue);
+SPINE_C_API int spine_array_constraint_data_index_of(spine_array_constraint_data array, /*@null*/ spine_constraint_data inValue);
 
-SPINE_C_API spine_constraint_data *spine_array_constraint_data_buffer(spine_array_constraint_data array);
+SPINE_C_API /*@null*/ spine_constraint_data *spine_array_constraint_data_buffer(spine_array_constraint_data array);
 
 SPINE_C_API spine_array_event spine_array_event_create(void);
 
@@ -473,23 +481,23 @@ SPINE_C_API size_t spine_array_event_get_capacity(spine_array_event array);
 
 SPINE_C_API size_t spine_array_event_size(spine_array_event array);
 
-SPINE_C_API spine_array_event spine_array_event_set_size(spine_array_event array, size_t newSize, spine_event defaultValue);
+SPINE_C_API /*@null*/ spine_array_event spine_array_event_set_size(spine_array_event array, size_t newSize, /*@null*/ spine_event defaultValue);
 
 SPINE_C_API void spine_array_event_ensure_capacity(spine_array_event array, size_t newCapacity);
 
-SPINE_C_API void spine_array_event_add(spine_array_event array, spine_event inValue);
+SPINE_C_API void spine_array_event_add(spine_array_event array, /*@null*/ spine_event inValue);
 
-SPINE_C_API void spine_array_event_add_all(spine_array_event array, spine_array_event inValue);
+SPINE_C_API void spine_array_event_add_all(spine_array_event array, /*@null*/ spine_array_event inValue);
 
-SPINE_C_API void spine_array_event_clear_and_add_all(spine_array_event array, spine_array_event inValue);
+SPINE_C_API void spine_array_event_clear_and_add_all(spine_array_event array, /*@null*/ spine_array_event inValue);
 
 SPINE_C_API void spine_array_event_remove_at(spine_array_event array, size_t inIndex);
 
-SPINE_C_API bool spine_array_event_contains(spine_array_event array, spine_event inValue);
+SPINE_C_API bool spine_array_event_contains(spine_array_event array, /*@null*/ spine_event inValue);
 
-SPINE_C_API int spine_array_event_index_of(spine_array_event array, spine_event inValue);
+SPINE_C_API int spine_array_event_index_of(spine_array_event array, /*@null*/ spine_event inValue);
 
-SPINE_C_API spine_event *spine_array_event_buffer(spine_array_event array);
+SPINE_C_API /*@null*/ spine_event *spine_array_event_buffer(spine_array_event array);
 
 SPINE_C_API spine_array_event_data spine_array_event_data_create(void);
 
@@ -501,23 +509,24 @@ SPINE_C_API size_t spine_array_event_data_get_capacity(spine_array_event_data ar
 
 SPINE_C_API size_t spine_array_event_data_size(spine_array_event_data array);
 
-SPINE_C_API spine_array_event_data spine_array_event_data_set_size(spine_array_event_data array, size_t newSize, spine_event_data defaultValue);
+SPINE_C_API /*@null*/ spine_array_event_data spine_array_event_data_set_size(spine_array_event_data array, size_t newSize,
+																			 /*@null*/ spine_event_data defaultValue);
 
 SPINE_C_API void spine_array_event_data_ensure_capacity(spine_array_event_data array, size_t newCapacity);
 
-SPINE_C_API void spine_array_event_data_add(spine_array_event_data array, spine_event_data inValue);
+SPINE_C_API void spine_array_event_data_add(spine_array_event_data array, /*@null*/ spine_event_data inValue);
 
-SPINE_C_API void spine_array_event_data_add_all(spine_array_event_data array, spine_array_event_data inValue);
+SPINE_C_API void spine_array_event_data_add_all(spine_array_event_data array, /*@null*/ spine_array_event_data inValue);
 
-SPINE_C_API void spine_array_event_data_clear_and_add_all(spine_array_event_data array, spine_array_event_data inValue);
+SPINE_C_API void spine_array_event_data_clear_and_add_all(spine_array_event_data array, /*@null*/ spine_array_event_data inValue);
 
 SPINE_C_API void spine_array_event_data_remove_at(spine_array_event_data array, size_t inIndex);
 
-SPINE_C_API bool spine_array_event_data_contains(spine_array_event_data array, spine_event_data inValue);
+SPINE_C_API bool spine_array_event_data_contains(spine_array_event_data array, /*@null*/ spine_event_data inValue);
 
-SPINE_C_API int spine_array_event_data_index_of(spine_array_event_data array, spine_event_data inValue);
+SPINE_C_API int spine_array_event_data_index_of(spine_array_event_data array, /*@null*/ spine_event_data inValue);
 
-SPINE_C_API spine_event_data *spine_array_event_data_buffer(spine_array_event_data array);
+SPINE_C_API /*@null*/ spine_event_data *spine_array_event_data_buffer(spine_array_event_data array);
 
 SPINE_C_API spine_array_from_property spine_array_from_property_create(void);
 
@@ -529,24 +538,24 @@ SPINE_C_API size_t spine_array_from_property_get_capacity(spine_array_from_prope
 
 SPINE_C_API size_t spine_array_from_property_size(spine_array_from_property array);
 
-SPINE_C_API spine_array_from_property spine_array_from_property_set_size(spine_array_from_property array, size_t newSize,
-																		 spine_from_property defaultValue);
+SPINE_C_API /*@null*/ spine_array_from_property spine_array_from_property_set_size(spine_array_from_property array, size_t newSize,
+																				   /*@null*/ spine_from_property defaultValue);
 
 SPINE_C_API void spine_array_from_property_ensure_capacity(spine_array_from_property array, size_t newCapacity);
 
-SPINE_C_API void spine_array_from_property_add(spine_array_from_property array, spine_from_property inValue);
+SPINE_C_API void spine_array_from_property_add(spine_array_from_property array, /*@null*/ spine_from_property inValue);
 
-SPINE_C_API void spine_array_from_property_add_all(spine_array_from_property array, spine_array_from_property inValue);
+SPINE_C_API void spine_array_from_property_add_all(spine_array_from_property array, /*@null*/ spine_array_from_property inValue);
 
-SPINE_C_API void spine_array_from_property_clear_and_add_all(spine_array_from_property array, spine_array_from_property inValue);
+SPINE_C_API void spine_array_from_property_clear_and_add_all(spine_array_from_property array, /*@null*/ spine_array_from_property inValue);
 
 SPINE_C_API void spine_array_from_property_remove_at(spine_array_from_property array, size_t inIndex);
 
-SPINE_C_API bool spine_array_from_property_contains(spine_array_from_property array, spine_from_property inValue);
+SPINE_C_API bool spine_array_from_property_contains(spine_array_from_property array, /*@null*/ spine_from_property inValue);
 
-SPINE_C_API int spine_array_from_property_index_of(spine_array_from_property array, spine_from_property inValue);
+SPINE_C_API int spine_array_from_property_index_of(spine_array_from_property array, /*@null*/ spine_from_property inValue);
 
-SPINE_C_API spine_from_property *spine_array_from_property_buffer(spine_array_from_property array);
+SPINE_C_API /*@null*/ spine_from_property *spine_array_from_property_buffer(spine_array_from_property array);
 
 SPINE_C_API spine_array_physics_constraint spine_array_physics_constraint_create(void);
 
@@ -558,24 +567,25 @@ SPINE_C_API size_t spine_array_physics_constraint_get_capacity(spine_array_physi
 
 SPINE_C_API size_t spine_array_physics_constraint_size(spine_array_physics_constraint array);
 
-SPINE_C_API spine_array_physics_constraint spine_array_physics_constraint_set_size(spine_array_physics_constraint array, size_t newSize,
-																				   spine_physics_constraint defaultValue);
+SPINE_C_API /*@null*/ spine_array_physics_constraint spine_array_physics_constraint_set_size(spine_array_physics_constraint array, size_t newSize,
+																							 /*@null*/ spine_physics_constraint defaultValue);
 
 SPINE_C_API void spine_array_physics_constraint_ensure_capacity(spine_array_physics_constraint array, size_t newCapacity);
 
-SPINE_C_API void spine_array_physics_constraint_add(spine_array_physics_constraint array, spine_physics_constraint inValue);
+SPINE_C_API void spine_array_physics_constraint_add(spine_array_physics_constraint array, /*@null*/ spine_physics_constraint inValue);
 
-SPINE_C_API void spine_array_physics_constraint_add_all(spine_array_physics_constraint array, spine_array_physics_constraint inValue);
+SPINE_C_API void spine_array_physics_constraint_add_all(spine_array_physics_constraint array, /*@null*/ spine_array_physics_constraint inValue);
 
-SPINE_C_API void spine_array_physics_constraint_clear_and_add_all(spine_array_physics_constraint array, spine_array_physics_constraint inValue);
+SPINE_C_API void spine_array_physics_constraint_clear_and_add_all(spine_array_physics_constraint array,
+																  /*@null*/ spine_array_physics_constraint inValue);
 
 SPINE_C_API void spine_array_physics_constraint_remove_at(spine_array_physics_constraint array, size_t inIndex);
 
-SPINE_C_API bool spine_array_physics_constraint_contains(spine_array_physics_constraint array, spine_physics_constraint inValue);
+SPINE_C_API bool spine_array_physics_constraint_contains(spine_array_physics_constraint array, /*@null*/ spine_physics_constraint inValue);
 
-SPINE_C_API int spine_array_physics_constraint_index_of(spine_array_physics_constraint array, spine_physics_constraint inValue);
+SPINE_C_API int spine_array_physics_constraint_index_of(spine_array_physics_constraint array, /*@null*/ spine_physics_constraint inValue);
 
-SPINE_C_API spine_physics_constraint *spine_array_physics_constraint_buffer(spine_array_physics_constraint array);
+SPINE_C_API /*@null*/ spine_physics_constraint *spine_array_physics_constraint_buffer(spine_array_physics_constraint array);
 
 SPINE_C_API spine_array_polygon spine_array_polygon_create(void);
 
@@ -587,23 +597,24 @@ SPINE_C_API size_t spine_array_polygon_get_capacity(spine_array_polygon array);
 
 SPINE_C_API size_t spine_array_polygon_size(spine_array_polygon array);
 
-SPINE_C_API spine_array_polygon spine_array_polygon_set_size(spine_array_polygon array, size_t newSize, spine_polygon defaultValue);
+SPINE_C_API /*@null*/ spine_array_polygon spine_array_polygon_set_size(spine_array_polygon array, size_t newSize,
+																	   /*@null*/ spine_polygon defaultValue);
 
 SPINE_C_API void spine_array_polygon_ensure_capacity(spine_array_polygon array, size_t newCapacity);
 
-SPINE_C_API void spine_array_polygon_add(spine_array_polygon array, spine_polygon inValue);
+SPINE_C_API void spine_array_polygon_add(spine_array_polygon array, /*@null*/ spine_polygon inValue);
 
-SPINE_C_API void spine_array_polygon_add_all(spine_array_polygon array, spine_array_polygon inValue);
+SPINE_C_API void spine_array_polygon_add_all(spine_array_polygon array, /*@null*/ spine_array_polygon inValue);
 
-SPINE_C_API void spine_array_polygon_clear_and_add_all(spine_array_polygon array, spine_array_polygon inValue);
+SPINE_C_API void spine_array_polygon_clear_and_add_all(spine_array_polygon array, /*@null*/ spine_array_polygon inValue);
 
 SPINE_C_API void spine_array_polygon_remove_at(spine_array_polygon array, size_t inIndex);
 
-SPINE_C_API bool spine_array_polygon_contains(spine_array_polygon array, spine_polygon inValue);
+SPINE_C_API bool spine_array_polygon_contains(spine_array_polygon array, /*@null*/ spine_polygon inValue);
 
-SPINE_C_API int spine_array_polygon_index_of(spine_array_polygon array, spine_polygon inValue);
+SPINE_C_API int spine_array_polygon_index_of(spine_array_polygon array, /*@null*/ spine_polygon inValue);
 
-SPINE_C_API spine_polygon *spine_array_polygon_buffer(spine_array_polygon array);
+SPINE_C_API /*@null*/ spine_polygon *spine_array_polygon_buffer(spine_array_polygon array);
 
 SPINE_C_API spine_array_skin spine_array_skin_create(void);
 
@@ -615,23 +626,23 @@ SPINE_C_API size_t spine_array_skin_get_capacity(spine_array_skin array);
 
 SPINE_C_API size_t spine_array_skin_size(spine_array_skin array);
 
-SPINE_C_API spine_array_skin spine_array_skin_set_size(spine_array_skin array, size_t newSize, spine_skin defaultValue);
+SPINE_C_API /*@null*/ spine_array_skin spine_array_skin_set_size(spine_array_skin array, size_t newSize, /*@null*/ spine_skin defaultValue);
 
 SPINE_C_API void spine_array_skin_ensure_capacity(spine_array_skin array, size_t newCapacity);
 
-SPINE_C_API void spine_array_skin_add(spine_array_skin array, spine_skin inValue);
+SPINE_C_API void spine_array_skin_add(spine_array_skin array, /*@null*/ spine_skin inValue);
 
-SPINE_C_API void spine_array_skin_add_all(spine_array_skin array, spine_array_skin inValue);
+SPINE_C_API void spine_array_skin_add_all(spine_array_skin array, /*@null*/ spine_array_skin inValue);
 
-SPINE_C_API void spine_array_skin_clear_and_add_all(spine_array_skin array, spine_array_skin inValue);
+SPINE_C_API void spine_array_skin_clear_and_add_all(spine_array_skin array, /*@null*/ spine_array_skin inValue);
 
 SPINE_C_API void spine_array_skin_remove_at(spine_array_skin array, size_t inIndex);
 
-SPINE_C_API bool spine_array_skin_contains(spine_array_skin array, spine_skin inValue);
+SPINE_C_API bool spine_array_skin_contains(spine_array_skin array, /*@null*/ spine_skin inValue);
 
-SPINE_C_API int spine_array_skin_index_of(spine_array_skin array, spine_skin inValue);
+SPINE_C_API int spine_array_skin_index_of(spine_array_skin array, /*@null*/ spine_skin inValue);
 
-SPINE_C_API spine_skin *spine_array_skin_buffer(spine_array_skin array);
+SPINE_C_API /*@null*/ spine_skin *spine_array_skin_buffer(spine_array_skin array);
 
 SPINE_C_API spine_array_slot spine_array_slot_create(void);
 
@@ -643,23 +654,23 @@ SPINE_C_API size_t spine_array_slot_get_capacity(spine_array_slot array);
 
 SPINE_C_API size_t spine_array_slot_size(spine_array_slot array);
 
-SPINE_C_API spine_array_slot spine_array_slot_set_size(spine_array_slot array, size_t newSize, spine_slot defaultValue);
+SPINE_C_API /*@null*/ spine_array_slot spine_array_slot_set_size(spine_array_slot array, size_t newSize, /*@null*/ spine_slot defaultValue);
 
 SPINE_C_API void spine_array_slot_ensure_capacity(spine_array_slot array, size_t newCapacity);
 
-SPINE_C_API void spine_array_slot_add(spine_array_slot array, spine_slot inValue);
+SPINE_C_API void spine_array_slot_add(spine_array_slot array, /*@null*/ spine_slot inValue);
 
-SPINE_C_API void spine_array_slot_add_all(spine_array_slot array, spine_array_slot inValue);
+SPINE_C_API void spine_array_slot_add_all(spine_array_slot array, /*@null*/ spine_array_slot inValue);
 
-SPINE_C_API void spine_array_slot_clear_and_add_all(spine_array_slot array, spine_array_slot inValue);
+SPINE_C_API void spine_array_slot_clear_and_add_all(spine_array_slot array, /*@null*/ spine_array_slot inValue);
 
 SPINE_C_API void spine_array_slot_remove_at(spine_array_slot array, size_t inIndex);
 
-SPINE_C_API bool spine_array_slot_contains(spine_array_slot array, spine_slot inValue);
+SPINE_C_API bool spine_array_slot_contains(spine_array_slot array, /*@null*/ spine_slot inValue);
 
-SPINE_C_API int spine_array_slot_index_of(spine_array_slot array, spine_slot inValue);
+SPINE_C_API int spine_array_slot_index_of(spine_array_slot array, /*@null*/ spine_slot inValue);
 
-SPINE_C_API spine_slot *spine_array_slot_buffer(spine_array_slot array);
+SPINE_C_API /*@null*/ spine_slot *spine_array_slot_buffer(spine_array_slot array);
 
 SPINE_C_API spine_array_slot_data spine_array_slot_data_create(void);
 
@@ -671,23 +682,24 @@ SPINE_C_API size_t spine_array_slot_data_get_capacity(spine_array_slot_data arra
 
 SPINE_C_API size_t spine_array_slot_data_size(spine_array_slot_data array);
 
-SPINE_C_API spine_array_slot_data spine_array_slot_data_set_size(spine_array_slot_data array, size_t newSize, spine_slot_data defaultValue);
+SPINE_C_API /*@null*/ spine_array_slot_data spine_array_slot_data_set_size(spine_array_slot_data array, size_t newSize,
+																		   /*@null*/ spine_slot_data defaultValue);
 
 SPINE_C_API void spine_array_slot_data_ensure_capacity(spine_array_slot_data array, size_t newCapacity);
 
-SPINE_C_API void spine_array_slot_data_add(spine_array_slot_data array, spine_slot_data inValue);
+SPINE_C_API void spine_array_slot_data_add(spine_array_slot_data array, /*@null*/ spine_slot_data inValue);
 
-SPINE_C_API void spine_array_slot_data_add_all(spine_array_slot_data array, spine_array_slot_data inValue);
+SPINE_C_API void spine_array_slot_data_add_all(spine_array_slot_data array, /*@null*/ spine_array_slot_data inValue);
 
-SPINE_C_API void spine_array_slot_data_clear_and_add_all(spine_array_slot_data array, spine_array_slot_data inValue);
+SPINE_C_API void spine_array_slot_data_clear_and_add_all(spine_array_slot_data array, /*@null*/ spine_array_slot_data inValue);
 
 SPINE_C_API void spine_array_slot_data_remove_at(spine_array_slot_data array, size_t inIndex);
 
-SPINE_C_API bool spine_array_slot_data_contains(spine_array_slot_data array, spine_slot_data inValue);
+SPINE_C_API bool spine_array_slot_data_contains(spine_array_slot_data array, /*@null*/ spine_slot_data inValue);
 
-SPINE_C_API int spine_array_slot_data_index_of(spine_array_slot_data array, spine_slot_data inValue);
+SPINE_C_API int spine_array_slot_data_index_of(spine_array_slot_data array, /*@null*/ spine_slot_data inValue);
 
-SPINE_C_API spine_slot_data *spine_array_slot_data_buffer(spine_array_slot_data array);
+SPINE_C_API /*@null*/ spine_slot_data *spine_array_slot_data_buffer(spine_array_slot_data array);
 
 SPINE_C_API spine_array_texture_region spine_array_texture_region_create(void);
 
@@ -699,24 +711,24 @@ SPINE_C_API size_t spine_array_texture_region_get_capacity(spine_array_texture_r
 
 SPINE_C_API size_t spine_array_texture_region_size(spine_array_texture_region array);
 
-SPINE_C_API spine_array_texture_region spine_array_texture_region_set_size(spine_array_texture_region array, size_t newSize,
-																		   spine_texture_region defaultValue);
+SPINE_C_API /*@null*/ spine_array_texture_region spine_array_texture_region_set_size(spine_array_texture_region array, size_t newSize,
+																					 /*@null*/ spine_texture_region defaultValue);
 
 SPINE_C_API void spine_array_texture_region_ensure_capacity(spine_array_texture_region array, size_t newCapacity);
 
-SPINE_C_API void spine_array_texture_region_add(spine_array_texture_region array, spine_texture_region inValue);
+SPINE_C_API void spine_array_texture_region_add(spine_array_texture_region array, /*@null*/ spine_texture_region inValue);
 
-SPINE_C_API void spine_array_texture_region_add_all(spine_array_texture_region array, spine_array_texture_region inValue);
+SPINE_C_API void spine_array_texture_region_add_all(spine_array_texture_region array, /*@null*/ spine_array_texture_region inValue);
 
-SPINE_C_API void spine_array_texture_region_clear_and_add_all(spine_array_texture_region array, spine_array_texture_region inValue);
+SPINE_C_API void spine_array_texture_region_clear_and_add_all(spine_array_texture_region array, /*@null*/ spine_array_texture_region inValue);
 
 SPINE_C_API void spine_array_texture_region_remove_at(spine_array_texture_region array, size_t inIndex);
 
-SPINE_C_API bool spine_array_texture_region_contains(spine_array_texture_region array, spine_texture_region inValue);
+SPINE_C_API bool spine_array_texture_region_contains(spine_array_texture_region array, /*@null*/ spine_texture_region inValue);
 
-SPINE_C_API int spine_array_texture_region_index_of(spine_array_texture_region array, spine_texture_region inValue);
+SPINE_C_API int spine_array_texture_region_index_of(spine_array_texture_region array, /*@null*/ spine_texture_region inValue);
 
-SPINE_C_API spine_texture_region *spine_array_texture_region_buffer(spine_array_texture_region array);
+SPINE_C_API /*@null*/ spine_texture_region *spine_array_texture_region_buffer(spine_array_texture_region array);
 
 SPINE_C_API spine_array_timeline spine_array_timeline_create(void);
 
@@ -728,23 +740,24 @@ SPINE_C_API size_t spine_array_timeline_get_capacity(spine_array_timeline array)
 
 SPINE_C_API size_t spine_array_timeline_size(spine_array_timeline array);
 
-SPINE_C_API spine_array_timeline spine_array_timeline_set_size(spine_array_timeline array, size_t newSize, spine_timeline defaultValue);
+SPINE_C_API /*@null*/ spine_array_timeline spine_array_timeline_set_size(spine_array_timeline array, size_t newSize,
+																		 /*@null*/ spine_timeline defaultValue);
 
 SPINE_C_API void spine_array_timeline_ensure_capacity(spine_array_timeline array, size_t newCapacity);
 
-SPINE_C_API void spine_array_timeline_add(spine_array_timeline array, spine_timeline inValue);
+SPINE_C_API void spine_array_timeline_add(spine_array_timeline array, /*@null*/ spine_timeline inValue);
 
-SPINE_C_API void spine_array_timeline_add_all(spine_array_timeline array, spine_array_timeline inValue);
+SPINE_C_API void spine_array_timeline_add_all(spine_array_timeline array, /*@null*/ spine_array_timeline inValue);
 
-SPINE_C_API void spine_array_timeline_clear_and_add_all(spine_array_timeline array, spine_array_timeline inValue);
+SPINE_C_API void spine_array_timeline_clear_and_add_all(spine_array_timeline array, /*@null*/ spine_array_timeline inValue);
 
 SPINE_C_API void spine_array_timeline_remove_at(spine_array_timeline array, size_t inIndex);
 
-SPINE_C_API bool spine_array_timeline_contains(spine_array_timeline array, spine_timeline inValue);
+SPINE_C_API bool spine_array_timeline_contains(spine_array_timeline array, /*@null*/ spine_timeline inValue);
 
-SPINE_C_API int spine_array_timeline_index_of(spine_array_timeline array, spine_timeline inValue);
+SPINE_C_API int spine_array_timeline_index_of(spine_array_timeline array, /*@null*/ spine_timeline inValue);
 
-SPINE_C_API spine_timeline *spine_array_timeline_buffer(spine_array_timeline array);
+SPINE_C_API /*@null*/ spine_timeline *spine_array_timeline_buffer(spine_array_timeline array);
 
 SPINE_C_API spine_array_to_property spine_array_to_property_create(void);
 
@@ -756,23 +769,24 @@ SPINE_C_API size_t spine_array_to_property_get_capacity(spine_array_to_property
 
 SPINE_C_API size_t spine_array_to_property_size(spine_array_to_property array);
 
-SPINE_C_API spine_array_to_property spine_array_to_property_set_size(spine_array_to_property array, size_t newSize, spine_to_property defaultValue);
+SPINE_C_API /*@null*/ spine_array_to_property spine_array_to_property_set_size(spine_array_to_property array, size_t newSize,
+																			   /*@null*/ spine_to_property defaultValue);
 
 SPINE_C_API void spine_array_to_property_ensure_capacity(spine_array_to_property array, size_t newCapacity);
 
-SPINE_C_API void spine_array_to_property_add(spine_array_to_property array, spine_to_property inValue);
+SPINE_C_API void spine_array_to_property_add(spine_array_to_property array, /*@null*/ spine_to_property inValue);
 
-SPINE_C_API void spine_array_to_property_add_all(spine_array_to_property array, spine_array_to_property inValue);
+SPINE_C_API void spine_array_to_property_add_all(spine_array_to_property array, /*@null*/ spine_array_to_property inValue);
 
-SPINE_C_API void spine_array_to_property_clear_and_add_all(spine_array_to_property array, spine_array_to_property inValue);
+SPINE_C_API void spine_array_to_property_clear_and_add_all(spine_array_to_property array, /*@null*/ spine_array_to_property inValue);
 
 SPINE_C_API void spine_array_to_property_remove_at(spine_array_to_property array, size_t inIndex);
 
-SPINE_C_API bool spine_array_to_property_contains(spine_array_to_property array, spine_to_property inValue);
+SPINE_C_API bool spine_array_to_property_contains(spine_array_to_property array, /*@null*/ spine_to_property inValue);
 
-SPINE_C_API int spine_array_to_property_index_of(spine_array_to_property array, spine_to_property inValue);
+SPINE_C_API int spine_array_to_property_index_of(spine_array_to_property array, /*@null*/ spine_to_property inValue);
 
-SPINE_C_API spine_to_property *spine_array_to_property_buffer(spine_array_to_property array);
+SPINE_C_API /*@null*/ spine_to_property *spine_array_to_property_buffer(spine_array_to_property array);
 
 SPINE_C_API spine_array_track_entry spine_array_track_entry_create(void);
 
@@ -784,23 +798,24 @@ SPINE_C_API size_t spine_array_track_entry_get_capacity(spine_array_track_entry
 
 SPINE_C_API size_t spine_array_track_entry_size(spine_array_track_entry array);
 
-SPINE_C_API spine_array_track_entry spine_array_track_entry_set_size(spine_array_track_entry array, size_t newSize, spine_track_entry defaultValue);
+SPINE_C_API /*@null*/ spine_array_track_entry spine_array_track_entry_set_size(spine_array_track_entry array, size_t newSize,
+																			   /*@null*/ spine_track_entry defaultValue);
 
 SPINE_C_API void spine_array_track_entry_ensure_capacity(spine_array_track_entry array, size_t newCapacity);
 
-SPINE_C_API void spine_array_track_entry_add(spine_array_track_entry array, spine_track_entry inValue);
+SPINE_C_API void spine_array_track_entry_add(spine_array_track_entry array, /*@null*/ spine_track_entry inValue);
 
-SPINE_C_API void spine_array_track_entry_add_all(spine_array_track_entry array, spine_array_track_entry inValue);
+SPINE_C_API void spine_array_track_entry_add_all(spine_array_track_entry array, /*@null*/ spine_array_track_entry inValue);
 
-SPINE_C_API void spine_array_track_entry_clear_and_add_all(spine_array_track_entry array, spine_array_track_entry inValue);
+SPINE_C_API void spine_array_track_entry_clear_and_add_all(spine_array_track_entry array, /*@null*/ spine_array_track_entry inValue);
 
 SPINE_C_API void spine_array_track_entry_remove_at(spine_array_track_entry array, size_t inIndex);
 
-SPINE_C_API bool spine_array_track_entry_contains(spine_array_track_entry array, spine_track_entry inValue);
+SPINE_C_API bool spine_array_track_entry_contains(spine_array_track_entry array, /*@null*/ spine_track_entry inValue);
 
-SPINE_C_API int spine_array_track_entry_index_of(spine_array_track_entry array, spine_track_entry inValue);
+SPINE_C_API int spine_array_track_entry_index_of(spine_array_track_entry array, /*@null*/ spine_track_entry inValue);
 
-SPINE_C_API spine_track_entry *spine_array_track_entry_buffer(spine_array_track_entry array);
+SPINE_C_API /*@null*/ spine_track_entry *spine_array_track_entry_buffer(spine_array_track_entry array);
 
 SPINE_C_API spine_array_update spine_array_update_create(void);
 
@@ -812,23 +827,23 @@ SPINE_C_API size_t spine_array_update_get_capacity(spine_array_update array);
 
 SPINE_C_API size_t spine_array_update_size(spine_array_update array);
 
-SPINE_C_API spine_array_update spine_array_update_set_size(spine_array_update array, size_t newSize, spine_update defaultValue);
+SPINE_C_API /*@null*/ spine_array_update spine_array_update_set_size(spine_array_update array, size_t newSize, /*@null*/ spine_update defaultValue);
 
 SPINE_C_API void spine_array_update_ensure_capacity(spine_array_update array, size_t newCapacity);
 
-SPINE_C_API void spine_array_update_add(spine_array_update array, spine_update inValue);
+SPINE_C_API void spine_array_update_add(spine_array_update array, /*@null*/ spine_update inValue);
 
-SPINE_C_API void spine_array_update_add_all(spine_array_update array, spine_array_update inValue);
+SPINE_C_API void spine_array_update_add_all(spine_array_update array, /*@null*/ spine_array_update inValue);
 
-SPINE_C_API void spine_array_update_clear_and_add_all(spine_array_update array, spine_array_update inValue);
+SPINE_C_API void spine_array_update_clear_and_add_all(spine_array_update array, /*@null*/ spine_array_update inValue);
 
 SPINE_C_API void spine_array_update_remove_at(spine_array_update array, size_t inIndex);
 
-SPINE_C_API bool spine_array_update_contains(spine_array_update array, spine_update inValue);
+SPINE_C_API bool spine_array_update_contains(spine_array_update array, /*@null*/ spine_update inValue);
 
-SPINE_C_API int spine_array_update_index_of(spine_array_update array, spine_update inValue);
+SPINE_C_API int spine_array_update_index_of(spine_array_update array, /*@null*/ spine_update inValue);
 
-SPINE_C_API spine_update *spine_array_update_buffer(spine_array_update array);
+SPINE_C_API /*@null*/ spine_update *spine_array_update_buffer(spine_array_update array);
 
 #ifdef __cplusplus
 }

spine-c/src/generated/atlas.cpp

@@ -12,17 +12,17 @@ void spine_atlas_flip_v(spine_atlas self) {
 	_self->flipV();
 }
 
-spine_atlas_region spine_atlas_find_region(spine_atlas self, const char *name) {
+/*@null*/ spine_atlas_region spine_atlas_find_region(spine_atlas self, const char *name) {
 	Atlas *_self = (Atlas *) self;
 	return (spine_atlas_region) _self->findRegion(String(name));
 }
 
-spine_array_atlas_page spine_atlas_get_pages(spine_atlas self) {
+/*@null*/ spine_array_atlas_page spine_atlas_get_pages(spine_atlas self) {
 	Atlas *_self = (Atlas *) self;
 	return (spine_array_atlas_page) &_self->getPages();
 }
 
-spine_array_atlas_region spine_atlas_get_regions(spine_atlas self) {
+/*@null*/ spine_array_atlas_region spine_atlas_get_regions(spine_atlas self) {
 	Atlas *_self = (Atlas *) self;
 	return (spine_array_atlas_region) &_self->getRegions();
 }

spine-c/src/generated/atlas.h

@@ -12,9 +12,9 @@ extern "C" {
 SPINE_C_API void spine_atlas_dispose(spine_atlas self);
 
 SPINE_C_API void spine_atlas_flip_v(spine_atlas self);
-SPINE_C_API spine_atlas_region spine_atlas_find_region(spine_atlas self, const char *name);
-SPINE_C_API spine_array_atlas_page spine_atlas_get_pages(spine_atlas self);
-SPINE_C_API spine_array_atlas_region spine_atlas_get_regions(spine_atlas self);
+SPINE_C_API /*@null*/ spine_atlas_region spine_atlas_find_region(spine_atlas self, const char *name);
+SPINE_C_API /*@null*/ spine_array_atlas_page spine_atlas_get_pages(spine_atlas self);
+SPINE_C_API /*@null*/ spine_array_atlas_region spine_atlas_get_regions(spine_atlas self);
 
 #ifdef __cplusplus
 }

spine-c/src/generated/atlas_attachment_loader.cpp

@@ -3,7 +3,7 @@
 
 using namespace spine;
 
-spine_atlas_attachment_loader spine_atlas_attachment_loader_create(spine_atlas atlas) {
+spine_atlas_attachment_loader spine_atlas_attachment_loader_create(/*@null*/ spine_atlas atlas) {
 	return (spine_atlas_attachment_loader) new (__FILE__, __LINE__) AtlasAttachmentLoader((Atlas *) atlas);
 }
 
@@ -11,41 +11,45 @@ void spine_atlas_attachment_loader_dispose(spine_atlas_attachment_loader self) {
 	delete (AtlasAttachmentLoader *) self;
 }
 
-spine_region_attachment spine_atlas_attachment_loader_new_region_attachment(spine_atlas_attachment_loader self, spine_skin skin, const char *name,
-																			const char *path, spine_sequence sequence) {
+/*@null*/ spine_region_attachment spine_atlas_attachment_loader_new_region_attachment(spine_atlas_attachment_loader self, spine_skin skin,
+																					  const char *name, const char *path,
+																					  /*@null*/ spine_sequence sequence) {
 	AtlasAttachmentLoader *_self = (AtlasAttachmentLoader *) self;
 	return (spine_region_attachment) _self->newRegionAttachment(*((Skin *) skin), String(name), String(path), (Sequence *) sequence);
 }
 
-spine_mesh_attachment spine_atlas_attachment_loader_new_mesh_attachment(spine_atlas_attachment_loader self, spine_skin skin, const char *name,
-																		const char *path, spine_sequence sequence) {
+/*@null*/ spine_mesh_attachment spine_atlas_attachment_loader_new_mesh_attachment(spine_atlas_attachment_loader self, spine_skin skin,
+																				  const char *name, const char *path,
+																				  /*@null*/ spine_sequence sequence) {
 	AtlasAttachmentLoader *_self = (AtlasAttachmentLoader *) self;
 	return (spine_mesh_attachment) _self->newMeshAttachment(*((Skin *) skin), String(name), String(path), (Sequence *) sequence);
 }
 
-spine_bounding_box_attachment spine_atlas_attachment_loader_new_bounding_box_attachment(spine_atlas_attachment_loader self, spine_skin skin,
-																						const char *name) {
+/*@null*/ spine_bounding_box_attachment spine_atlas_attachment_loader_new_bounding_box_attachment(spine_atlas_attachment_loader self, spine_skin skin,
+																								  const char *name) {
 	AtlasAttachmentLoader *_self = (AtlasAttachmentLoader *) self;
 	return (spine_bounding_box_attachment) _self->newBoundingBoxAttachment(*((Skin *) skin), String(name));
 }
 
-spine_path_attachment spine_atlas_attachment_loader_new_path_attachment(spine_atlas_attachment_loader self, spine_skin skin, const char *name) {
+/*@null*/ spine_path_attachment spine_atlas_attachment_loader_new_path_attachment(spine_atlas_attachment_loader self, spine_skin skin,
+																				  const char *name) {
 	AtlasAttachmentLoader *_self = (AtlasAttachmentLoader *) self;
 	return (spine_path_attachment) _self->newPathAttachment(*((Skin *) skin), String(name));
 }
 
-spine_point_attachment spine_atlas_attachment_loader_new_point_attachment(spine_atlas_attachment_loader self, spine_skin skin, const char *name) {
+/*@null*/ spine_point_attachment spine_atlas_attachment_loader_new_point_attachment(spine_atlas_attachment_loader self, spine_skin skin,
+																					const char *name) {
 	AtlasAttachmentLoader *_self = (AtlasAttachmentLoader *) self;
 	return (spine_point_attachment) _self->newPointAttachment(*((Skin *) skin), String(name));
 }
 
-spine_clipping_attachment spine_atlas_attachment_loader_new_clipping_attachment(spine_atlas_attachment_loader self, spine_skin skin,
-																				const char *name) {
+/*@null*/ spine_clipping_attachment spine_atlas_attachment_loader_new_clipping_attachment(spine_atlas_attachment_loader self, spine_skin skin,
+																						  const char *name) {
 	AtlasAttachmentLoader *_self = (AtlasAttachmentLoader *) self;
 	return (spine_clipping_attachment) _self->newClippingAttachment(*((Skin *) skin), String(name));
 }
 
-spine_atlas_region spine_atlas_attachment_loader_find_region(spine_atlas_attachment_loader self, const char *name) {
+/*@null*/ spine_atlas_region spine_atlas_attachment_loader_find_region(spine_atlas_attachment_loader self, const char *name) {
 	AtlasAttachmentLoader *_self = (AtlasAttachmentLoader *) self;
 	return (spine_atlas_region) _self->findRegion(String(name));
 }

spine-c/src/generated/atlas_attachment_loader.h

@@ -9,23 +9,25 @@
 extern "C" {
 #endif
 
-SPINE_C_API spine_atlas_attachment_loader spine_atlas_attachment_loader_create(spine_atlas atlas);
+SPINE_C_API spine_atlas_attachment_loader spine_atlas_attachment_loader_create(/*@null*/ spine_atlas atlas);
 
 SPINE_C_API void spine_atlas_attachment_loader_dispose(spine_atlas_attachment_loader self);
 
-SPINE_C_API spine_region_attachment spine_atlas_attachment_loader_new_region_attachment(spine_atlas_attachment_loader self, spine_skin skin,
-																						const char *name, const char *path, spine_sequence sequence);
-SPINE_C_API spine_mesh_attachment spine_atlas_attachment_loader_new_mesh_attachment(spine_atlas_attachment_loader self, spine_skin skin,
-																					const char *name, const char *path, spine_sequence sequence);
-SPINE_C_API spine_bounding_box_attachment spine_atlas_attachment_loader_new_bounding_box_attachment(spine_atlas_attachment_loader self,
-																									spine_skin skin, const char *name);
-SPINE_C_API spine_path_attachment spine_atlas_attachment_loader_new_path_attachment(spine_atlas_attachment_loader self, spine_skin skin,
-																					const char *name);
-SPINE_C_API spine_point_attachment spine_atlas_attachment_loader_new_point_attachment(spine_atlas_attachment_loader self, spine_skin skin,
-																					  const char *name);
-SPINE_C_API spine_clipping_attachment spine_atlas_attachment_loader_new_clipping_attachment(spine_atlas_attachment_loader self, spine_skin skin,
-																							const char *name);
-SPINE_C_API spine_atlas_region spine_atlas_attachment_loader_find_region(spine_atlas_attachment_loader self, const char *name);
+SPINE_C_API /*@null*/ spine_region_attachment spine_atlas_attachment_loader_new_region_attachment(spine_atlas_attachment_loader self, spine_skin skin,
+																								  const char *name, const char *path,
+																								  /*@null*/ spine_sequence sequence);
+SPINE_C_API /*@null*/ spine_mesh_attachment spine_atlas_attachment_loader_new_mesh_attachment(spine_atlas_attachment_loader self, spine_skin skin,
+																							  const char *name, const char *path,
+																							  /*@null*/ spine_sequence sequence);
+SPINE_C_API /*@null*/ spine_bounding_box_attachment spine_atlas_attachment_loader_new_bounding_box_attachment(spine_atlas_attachment_loader self,
+																											  spine_skin skin, const char *name);
+SPINE_C_API /*@null*/ spine_path_attachment spine_atlas_attachment_loader_new_path_attachment(spine_atlas_attachment_loader self, spine_skin skin,
+																							  const char *name);
+SPINE_C_API /*@null*/ spine_point_attachment spine_atlas_attachment_loader_new_point_attachment(spine_atlas_attachment_loader self, spine_skin skin,
+																								const char *name);
+SPINE_C_API /*@null*/ spine_clipping_attachment spine_atlas_attachment_loader_new_clipping_attachment(spine_atlas_attachment_loader self,
+																									  spine_skin skin, const char *name);
+SPINE_C_API /*@null*/ spine_atlas_region spine_atlas_attachment_loader_find_region(spine_atlas_attachment_loader self, const char *name);
 
 #ifdef __cplusplus
 }

spine-c/src/generated/atlas_page.cpp

@@ -121,12 +121,12 @@ void spine_atlas_page_set_index(spine_atlas_page self, int value) {
 	_self->index = value;
 }
 
-void *spine_atlas_page_get_texture(spine_atlas_page self) {
+/*@null*/ void *spine_atlas_page_get_texture(spine_atlas_page self) {
 	AtlasPage *_self = (AtlasPage *) self;
 	return _self->texture;
 }
 
-void spine_atlas_page_set_texture(spine_atlas_page self, void *value) {
+void spine_atlas_page_set_texture(spine_atlas_page self, /*@null*/ void *value) {
 	AtlasPage *_self = (AtlasPage *) self;
 	_self->texture = (void *) value;
 }

spine-c/src/generated/atlas_page.h

@@ -35,8 +35,8 @@ SPINE_C_API bool spine_atlas_page_get_pma(spine_atlas_page self);
 SPINE_C_API void spine_atlas_page_set_pma(spine_atlas_page self, bool value);
 SPINE_C_API int spine_atlas_page_get_index(spine_atlas_page self);
 SPINE_C_API void spine_atlas_page_set_index(spine_atlas_page self, int value);
-SPINE_C_API void *spine_atlas_page_get_texture(spine_atlas_page self);
-SPINE_C_API void spine_atlas_page_set_texture(spine_atlas_page self, void *value);
+SPINE_C_API /*@null*/ void *spine_atlas_page_get_texture(spine_atlas_page self);
+SPINE_C_API void spine_atlas_page_set_texture(spine_atlas_page self, /*@null*/ void *value);
 
 #ifdef __cplusplus
 }

spine-c/src/generated/atlas_region.cpp

@@ -16,7 +16,7 @@ spine_rtti spine_atlas_region_get_rtti(spine_atlas_region self) {
 	return (spine_rtti) &_self->getRTTI();
 }
 
-spine_atlas_page spine_atlas_region_get_page(spine_atlas_region self) {
+/*@null*/ spine_atlas_page spine_atlas_region_get_page(spine_atlas_region self) {
 	AtlasRegion *_self = (AtlasRegion *) self;
 	return (spine_atlas_page) _self->getPage();
 }
@@ -96,7 +96,7 @@ spine_array_float spine_atlas_region_get_values(spine_atlas_region self) {
 	return (spine_array_float) &_self->getValues();
 }
 
-void spine_atlas_region_set_page(spine_atlas_region self, spine_atlas_page value) {
+void spine_atlas_region_set_page(spine_atlas_region self, /*@null*/ spine_atlas_page value) {
 	AtlasRegion *_self = (AtlasRegion *) self;
 	_self->setPage((AtlasPage *) value);
 }

spine-c/src/generated/atlas_region.h

@@ -14,7 +14,7 @@ SPINE_C_API spine_atlas_region spine_atlas_region_create(void);
 SPINE_C_API void spine_atlas_region_dispose(spine_atlas_region self);
 
 SPINE_C_API spine_rtti spine_atlas_region_get_rtti(spine_atlas_region self);
-SPINE_C_API spine_atlas_page spine_atlas_region_get_page(spine_atlas_region self);
+SPINE_C_API /*@null*/ spine_atlas_page spine_atlas_region_get_page(spine_atlas_region self);
 SPINE_C_API const char *spine_atlas_region_get_name(spine_atlas_region self);
 SPINE_C_API int spine_atlas_region_get_index(spine_atlas_region self);
 SPINE_C_API int spine_atlas_region_get_x(spine_atlas_region self);
@@ -30,7 +30,7 @@ SPINE_C_API int spine_atlas_region_get_degrees(spine_atlas_region self);
 SPINE_C_API spine_array_int spine_atlas_region_get_splits(spine_atlas_region self);
 SPINE_C_API spine_array_int spine_atlas_region_get_pads(spine_atlas_region self);
 SPINE_C_API spine_array_float spine_atlas_region_get_values(spine_atlas_region self);
-SPINE_C_API void spine_atlas_region_set_page(spine_atlas_region self, spine_atlas_page value);
+SPINE_C_API void spine_atlas_region_set_page(spine_atlas_region self, /*@null*/ spine_atlas_page value);
 SPINE_C_API void spine_atlas_region_set_name(spine_atlas_region self, const char *value);
 SPINE_C_API void spine_atlas_region_set_index(spine_atlas_region self, int value);
 SPINE_C_API void spine_atlas_region_set_x(spine_atlas_region self, int value);

spine-c/src/generated/attachment_loader.cpp

@@ -7,34 +7,35 @@ void spine_attachment_loader_dispose(spine_attachment_loader self) {
 	delete (AttachmentLoader *) self;
 }
 
-spine_region_attachment spine_attachment_loader_new_region_attachment(spine_attachment_loader self, spine_skin skin, const char *name,
-																	  const char *path, spine_sequence sequence) {
+/*@null*/ spine_region_attachment spine_attachment_loader_new_region_attachment(spine_attachment_loader self, spine_skin skin, const char *name,
+																				const char *path, /*@null*/ spine_sequence sequence) {
 	AttachmentLoader *_self = (AttachmentLoader *) self;
 	return (spine_region_attachment) _self->newRegionAttachment(*((Skin *) skin), String(name), String(path), (Sequence *) sequence);
 }
 
-spine_mesh_attachment spine_attachment_loader_new_mesh_attachment(spine_attachment_loader self, spine_skin skin, const char *name, const char *path,
-																  spine_sequence sequence) {
+/*@null*/ spine_mesh_attachment spine_attachment_loader_new_mesh_attachment(spine_attachment_loader self, spine_skin skin, const char *name,
+																			const char *path, /*@null*/ spine_sequence sequence) {
 	AttachmentLoader *_self = (AttachmentLoader *) self;
 	return (spine_mesh_attachment) _self->newMeshAttachment(*((Skin *) skin), String(name), String(path), (Sequence *) sequence);
 }
 
-spine_bounding_box_attachment spine_attachment_loader_new_bounding_box_attachment(spine_attachment_loader self, spine_skin skin, const char *name) {
+/*@null*/ spine_bounding_box_attachment spine_attachment_loader_new_bounding_box_attachment(spine_attachment_loader self, spine_skin skin,
+																							const char *name) {
 	AttachmentLoader *_self = (AttachmentLoader *) self;
 	return (spine_bounding_box_attachment) _self->newBoundingBoxAttachment(*((Skin *) skin), String(name));
 }
 
-spine_path_attachment spine_attachment_loader_new_path_attachment(spine_attachment_loader self, spine_skin skin, const char *name) {
+/*@null*/ spine_path_attachment spine_attachment_loader_new_path_attachment(spine_attachment_loader self, spine_skin skin, const char *name) {
 	AttachmentLoader *_self = (AttachmentLoader *) self;
 	return (spine_path_attachment) _self->newPathAttachment(*((Skin *) skin), String(name));
 }
 
-spine_point_attachment spine_attachment_loader_new_point_attachment(spine_attachment_loader self, spine_skin skin, const char *name) {
+/*@null*/ spine_point_attachment spine_attachment_loader_new_point_attachment(spine_attachment_loader self, spine_skin skin, const char *name) {
 	AttachmentLoader *_self = (AttachmentLoader *) self;
 	return (spine_point_attachment) _self->newPointAttachment(*((Skin *) skin), String(name));
 }
 
-spine_clipping_attachment spine_attachment_loader_new_clipping_attachment(spine_attachment_loader self, spine_skin skin, const char *name) {
+/*@null*/ spine_clipping_attachment spine_attachment_loader_new_clipping_attachment(spine_attachment_loader self, spine_skin skin, const char *name) {
 	AttachmentLoader *_self = (AttachmentLoader *) self;
 	return (spine_clipping_attachment) _self->newClippingAttachment(*((Skin *) skin), String(name));
 }

spine-c/src/generated/attachment_loader.h

@@ -11,16 +11,20 @@ extern "C" {
 
 SPINE_C_API void spine_attachment_loader_dispose(spine_attachment_loader self);
 
-SPINE_C_API spine_region_attachment spine_attachment_loader_new_region_attachment(spine_attachment_loader self, spine_skin skin, const char *name,
-																				  const char *path, spine_sequence sequence);
-SPINE_C_API spine_mesh_attachment spine_attachment_loader_new_mesh_attachment(spine_attachment_loader self, spine_skin skin, const char *name,
-																			  const char *path, spine_sequence sequence);
-SPINE_C_API spine_bounding_box_attachment spine_attachment_loader_new_bounding_box_attachment(spine_attachment_loader self, spine_skin skin,
-																							  const char *name);
-SPINE_C_API spine_path_attachment spine_attachment_loader_new_path_attachment(spine_attachment_loader self, spine_skin skin, const char *name);
-SPINE_C_API spine_point_attachment spine_attachment_loader_new_point_attachment(spine_attachment_loader self, spine_skin skin, const char *name);
-SPINE_C_API spine_clipping_attachment spine_attachment_loader_new_clipping_attachment(spine_attachment_loader self, spine_skin skin,
-																					  const char *name);
+SPINE_C_API /*@null*/ spine_region_attachment spine_attachment_loader_new_region_attachment(spine_attachment_loader self, spine_skin skin,
+																							const char *name, const char *path,
+																							/*@null*/ spine_sequence sequence);
+SPINE_C_API /*@null*/ spine_mesh_attachment spine_attachment_loader_new_mesh_attachment(spine_attachment_loader self, spine_skin skin,
+																						const char *name, const char *path,
+																						/*@null*/ spine_sequence sequence);
+SPINE_C_API /*@null*/ spine_bounding_box_attachment spine_attachment_loader_new_bounding_box_attachment(spine_attachment_loader self, spine_skin skin,
+																										const char *name);
+SPINE_C_API /*@null*/ spine_path_attachment spine_attachment_loader_new_path_attachment(spine_attachment_loader self, spine_skin skin,
+																						const char *name);
+SPINE_C_API /*@null*/ spine_point_attachment spine_attachment_loader_new_point_attachment(spine_attachment_loader self, spine_skin skin,
+																						  const char *name);
+SPINE_C_API /*@null*/ spine_clipping_attachment spine_attachment_loader_new_clipping_attachment(spine_attachment_loader self, spine_skin skin,
+																								const char *name);
 
 #ifdef __cplusplus
 }

spine-c/src/generated/attachment_timeline.cpp

@@ -16,8 +16,9 @@ spine_rtti spine_attachment_timeline_get_rtti(spine_attachment_timeline self) {
 	return (spine_rtti) &_self->getRTTI();
 }
 
-void spine_attachment_timeline_apply(spine_attachment_timeline self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents,
-									 float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
+void spine_attachment_timeline_apply(spine_attachment_timeline self, spine_skeleton skeleton, float lastTime, float time,
+									 /*@null*/ spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction,
+									 bool appliedPose) {
 	AttachmentTimeline *_self = (AttachmentTimeline *) self;
 	_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) pEvents, alpha, (MixBlend) blend, (MixDirection) direction,
 				 appliedPose);

spine-c/src/generated/attachment_timeline.h

@@ -15,8 +15,8 @@ SPINE_C_API void spine_attachment_timeline_dispose(spine_attachment_timeline sel
 
 SPINE_C_API spine_rtti spine_attachment_timeline_get_rtti(spine_attachment_timeline self);
 SPINE_C_API void spine_attachment_timeline_apply(spine_attachment_timeline self, spine_skeleton skeleton, float lastTime, float time,
-												 spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction,
-												 bool appliedPose);
+												 /*@null*/ spine_array_event pEvents, float alpha, spine_mix_blend blend,
+												 spine_mix_direction direction, bool appliedPose);
 SPINE_C_API void spine_attachment_timeline_set_frame(spine_attachment_timeline self, int frame, float time, const char *attachmentName);
 SPINE_C_API int spine_attachment_timeline_get_slot_index(spine_attachment_timeline self);
 SPINE_C_API void spine_attachment_timeline_set_slot_index(spine_attachment_timeline self, int inValue);

spine-c/src/generated/bone.cpp

@@ -3,11 +3,11 @@
 
 using namespace spine;
 
-spine_bone spine_bone_create(spine_bone_data data, spine_bone parent) {
+spine_bone spine_bone_create(spine_bone_data data, /*@null*/ spine_bone parent) {
 	return (spine_bone) new (__FILE__, __LINE__) Bone(*((BoneData *) data), (Bone *) parent);
 }
 
-spine_bone spine_bone_create2(spine_bone bone, spine_bone parent) {
+spine_bone spine_bone_create2(spine_bone bone, /*@null*/ spine_bone parent) {
 	return (spine_bone) new (__FILE__, __LINE__) Bone(*((Bone *) bone), (Bone *) parent);
 }
 
@@ -20,12 +20,12 @@ spine_rtti spine_bone_get_rtti(spine_bone self) {
 	return (spine_rtti) &_self->getRTTI();
 }
 
-spine_bone spine_bone_get_parent(spine_bone self) {
+/*@null*/ spine_bone spine_bone_get_parent(spine_bone self) {
 	Bone *_self = (Bone *) self;
 	return (spine_bone) _self->getParent();
 }
 
-spine_array_bone spine_bone_get_children(spine_bone self) {
+/*@null*/ spine_array_bone spine_bone_get_children(spine_bone self) {
 	Bone *_self = (Bone *) self;
 	return (spine_array_bone) &_self->getChildren();
 }

spine-c/src/generated/bone.h

@@ -9,14 +9,14 @@
 extern "C" {
 #endif
 
-SPINE_C_API spine_bone spine_bone_create(spine_bone_data data, spine_bone parent);
-SPINE_C_API spine_bone spine_bone_create2(spine_bone bone, spine_bone parent);
+SPINE_C_API spine_bone spine_bone_create(spine_bone_data data, /*@null*/ spine_bone parent);
+SPINE_C_API spine_bone spine_bone_create2(spine_bone bone, /*@null*/ spine_bone parent);
 
 SPINE_C_API void spine_bone_dispose(spine_bone self);
 
 SPINE_C_API spine_rtti spine_bone_get_rtti(spine_bone self);
-SPINE_C_API spine_bone spine_bone_get_parent(spine_bone self);
-SPINE_C_API spine_array_bone spine_bone_get_children(spine_bone self);
+SPINE_C_API /*@null*/ spine_bone spine_bone_get_parent(spine_bone self);
+SPINE_C_API /*@null*/ spine_array_bone spine_bone_get_children(spine_bone self);
 SPINE_C_API bool spine_bone_is_y_down(void);
 SPINE_C_API void spine_bone_set_y_down(bool value);
 SPINE_C_API void spine_bone_update(spine_bone self, spine_skeleton skeleton, spine_physics physics);

spine-c/src/generated/bone_data.cpp

@@ -3,7 +3,7 @@
 
 using namespace spine;
 
-spine_bone_data spine_bone_data_create(int index, const char *name, spine_bone_data parent) {
+spine_bone_data spine_bone_data_create(int index, const char *name, /*@null*/ spine_bone_data parent) {
 	return (spine_bone_data) new (__FILE__, __LINE__) BoneData(index, String(name), (BoneData *) parent);
 }
 
@@ -16,7 +16,7 @@ int spine_bone_data_get_index(spine_bone_data self) {
 	return _self->getIndex();
 }
 
-spine_bone_data spine_bone_data_get_parent(spine_bone_data self) {
+/*@null*/ spine_bone_data spine_bone_data_get_parent(spine_bone_data self) {
 	BoneData *_self = (BoneData *) self;
 	return (spine_bone_data) _self->getParent();
 }

spine-c/src/generated/bone_data.h

@@ -9,12 +9,12 @@
 extern "C" {
 #endif
 
-SPINE_C_API spine_bone_data spine_bone_data_create(int index, const char *name, spine_bone_data parent);
+SPINE_C_API spine_bone_data spine_bone_data_create(int index, const char *name, /*@null*/ spine_bone_data parent);
 
 SPINE_C_API void spine_bone_data_dispose(spine_bone_data self);
 
 SPINE_C_API int spine_bone_data_get_index(spine_bone_data self);
-SPINE_C_API spine_bone_data spine_bone_data_get_parent(spine_bone_data self);
+SPINE_C_API /*@null*/ spine_bone_data spine_bone_data_get_parent(spine_bone_data self);
 SPINE_C_API float spine_bone_data_get_length(spine_bone_data self);
 SPINE_C_API void spine_bone_data_set_length(spine_bone_data self, float inValue);
 SPINE_C_API spine_color spine_bone_data_get_color(spine_bone_data self);

spine-c/src/generated/bone_timeline1.cpp

@@ -12,7 +12,7 @@ spine_rtti spine_bone_timeline1_get_rtti(spine_bone_timeline1 self) {
 	return (spine_rtti) &_self->getRTTI();
 }
 
-void spine_bone_timeline1_apply(spine_bone_timeline1 self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents,
+void spine_bone_timeline1_apply(spine_bone_timeline1 self, spine_skeleton skeleton, float lastTime, float time, /*@null*/ spine_array_event pEvents,
 								float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
 	BoneTimeline1 *_self = (BoneTimeline1 *) self;
 	_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) pEvents, alpha, (MixBlend) blend, (MixDirection) direction,

spine-c/src/generated/bone_timeline1.h

@@ -12,8 +12,9 @@ extern "C" {
 SPINE_C_API void spine_bone_timeline1_dispose(spine_bone_timeline1 self);
 
 SPINE_C_API spine_rtti spine_bone_timeline1_get_rtti(spine_bone_timeline1 self);
-SPINE_C_API void spine_bone_timeline1_apply(spine_bone_timeline1 self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents,
-											float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose);
+SPINE_C_API void spine_bone_timeline1_apply(spine_bone_timeline1 self, spine_skeleton skeleton, float lastTime, float time,
+											/*@null*/ spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction,
+											bool appliedPose);
 SPINE_C_API int spine_bone_timeline1_get_bone_index(spine_bone_timeline1 self);
 SPINE_C_API void spine_bone_timeline1_set_bone_index(spine_bone_timeline1 self, int inValue);
 SPINE_C_API void spine_bone_timeline1_set_frame(spine_bone_timeline1 self, size_t frame, float time, float value);

spine-c/src/generated/bone_timeline2.cpp

@@ -12,7 +12,7 @@ spine_rtti spine_bone_timeline2_get_rtti(spine_bone_timeline2 self) {
 	return (spine_rtti) &_self->getRTTI();
 }
 
-void spine_bone_timeline2_apply(spine_bone_timeline2 self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents,
+void spine_bone_timeline2_apply(spine_bone_timeline2 self, spine_skeleton skeleton, float lastTime, float time, /*@null*/ spine_array_event pEvents,
 								float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
 	BoneTimeline2 *_self = (BoneTimeline2 *) self;
 	_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) pEvents, alpha, (MixBlend) blend, (MixDirection) direction,

spine-c/src/generated/bone_timeline2.h

@@ -12,8 +12,9 @@ extern "C" {
 SPINE_C_API void spine_bone_timeline2_dispose(spine_bone_timeline2 self);
 
 SPINE_C_API spine_rtti spine_bone_timeline2_get_rtti(spine_bone_timeline2 self);
-SPINE_C_API void spine_bone_timeline2_apply(spine_bone_timeline2 self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents,
-											float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose);
+SPINE_C_API void spine_bone_timeline2_apply(spine_bone_timeline2 self, spine_skeleton skeleton, float lastTime, float time,
+											/*@null*/ spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction,
+											bool appliedPose);
 SPINE_C_API int spine_bone_timeline2_get_bone_index(spine_bone_timeline2 self);
 SPINE_C_API void spine_bone_timeline2_set_bone_index(spine_bone_timeline2 self, int inValue);
 SPINE_C_API void spine_bone_timeline2_set_frame(spine_bone_timeline2 self, size_t frame, float time, float value1, float value2);

spine-c/src/generated/bounding_box_attachment.cpp

@@ -27,7 +27,8 @@ spine_attachment spine_bounding_box_attachment_copy(spine_bounding_box_attachmen
 }
 
 void spine_bounding_box_attachment_compute_world_vertices_1(spine_bounding_box_attachment self, spine_skeleton skeleton, spine_slot slot,
-															size_t start, size_t count, float *worldVertices, size_t offset, size_t stride) {
+															size_t start, size_t count, /*@null*/ float *worldVertices, size_t offset,
+															size_t stride) {
 	VertexAttachment *_self = (VertexAttachment *) (BoundingBoxAttachment *) self;
 	_self->computeWorldVertices(*((Skeleton *) skeleton), *((Slot *) slot), start, count, worldVertices, offset, stride);
 }
@@ -74,12 +75,12 @@ void spine_bounding_box_attachment_set_world_vertices_length(spine_bounding_box_
 	_self->setWorldVerticesLength(inValue);
 }
 
-spine_attachment spine_bounding_box_attachment_get_timeline_attachment(spine_bounding_box_attachment self) {
+/*@null*/ spine_attachment spine_bounding_box_attachment_get_timeline_attachment(spine_bounding_box_attachment self) {
 	VertexAttachment *_self = (VertexAttachment *) (BoundingBoxAttachment *) self;
 	return (spine_attachment) _self->getTimelineAttachment();
 }
 
-void spine_bounding_box_attachment_set_timeline_attachment(spine_bounding_box_attachment self, spine_attachment attachment) {
+void spine_bounding_box_attachment_set_timeline_attachment(spine_bounding_box_attachment self, /*@null*/ spine_attachment attachment) {
 	VertexAttachment *_self = (VertexAttachment *) (BoundingBoxAttachment *) self;
 	_self->setTimelineAttachment((Attachment *) attachment);
 }

spine-c/src/generated/bounding_box_attachment.h

@@ -17,7 +17,7 @@ SPINE_C_API spine_rtti spine_bounding_box_attachment_get_rtti(spine_bounding_box
 SPINE_C_API spine_color spine_bounding_box_attachment_get_color(spine_bounding_box_attachment self);
 SPINE_C_API spine_attachment spine_bounding_box_attachment_copy(spine_bounding_box_attachment self);
 SPINE_C_API void spine_bounding_box_attachment_compute_world_vertices_1(spine_bounding_box_attachment self, spine_skeleton skeleton, spine_slot slot,
-																		size_t start, size_t count, float *worldVertices, size_t offset,
+																		size_t start, size_t count, /*@null*/ float *worldVertices, size_t offset,
 																		size_t stride);
 SPINE_C_API void spine_bounding_box_attachment_compute_world_vertices_2(spine_bounding_box_attachment self, spine_skeleton skeleton, spine_slot slot,
 																		size_t start, size_t count, spine_array_float worldVertices, size_t offset,
@@ -29,8 +29,8 @@ SPINE_C_API spine_array_float spine_bounding_box_attachment_get_vertices(spine_b
 SPINE_C_API void spine_bounding_box_attachment_set_vertices(spine_bounding_box_attachment self, spine_array_float vertices);
 SPINE_C_API size_t spine_bounding_box_attachment_get_world_vertices_length(spine_bounding_box_attachment self);
 SPINE_C_API void spine_bounding_box_attachment_set_world_vertices_length(spine_bounding_box_attachment self, size_t inValue);
-SPINE_C_API spine_attachment spine_bounding_box_attachment_get_timeline_attachment(spine_bounding_box_attachment self);
-SPINE_C_API void spine_bounding_box_attachment_set_timeline_attachment(spine_bounding_box_attachment self, spine_attachment attachment);
+SPINE_C_API /*@null*/ spine_attachment spine_bounding_box_attachment_get_timeline_attachment(spine_bounding_box_attachment self);
+SPINE_C_API void spine_bounding_box_attachment_set_timeline_attachment(spine_bounding_box_attachment self, /*@null*/ spine_attachment attachment);
 SPINE_C_API void spine_bounding_box_attachment_copy_to(spine_bounding_box_attachment self, spine_vertex_attachment other);
 SPINE_C_API const char *spine_bounding_box_attachment_get_name(spine_bounding_box_attachment self);
 SPINE_C_API int spine_bounding_box_attachment_get_ref_count(spine_bounding_box_attachment self);

spine-c/src/generated/clipping_attachment.cpp

@@ -16,12 +16,12 @@ spine_rtti spine_clipping_attachment_get_rtti(spine_clipping_attachment self) {
 	return (spine_rtti) &_self->getRTTI();
 }
 
-spine_slot_data spine_clipping_attachment_get_end_slot(spine_clipping_attachment self) {
+/*@null*/ spine_slot_data spine_clipping_attachment_get_end_slot(spine_clipping_attachment self) {
 	ClippingAttachment *_self = (ClippingAttachment *) self;
 	return (spine_slot_data) _self->getEndSlot();
 }
 
-void spine_clipping_attachment_set_end_slot(spine_clipping_attachment self, spine_slot_data inValue) {
+void spine_clipping_attachment_set_end_slot(spine_clipping_attachment self, /*@null*/ spine_slot_data inValue) {
 	ClippingAttachment *_self = (ClippingAttachment *) self;
 	_self->setEndSlot((SlotData *) inValue);
 }
@@ -37,7 +37,7 @@ spine_attachment spine_clipping_attachment_copy(spine_clipping_attachment self)
 }
 
 void spine_clipping_attachment_compute_world_vertices_1(spine_clipping_attachment self, spine_skeleton skeleton, spine_slot slot, size_t start,
-														size_t count, float *worldVertices, size_t offset, size_t stride) {
+														size_t count, /*@null*/ float *worldVertices, size_t offset, size_t stride) {
 	VertexAttachment *_self = (VertexAttachment *) (ClippingAttachment *) self;
 	_self->computeWorldVertices(*((Skeleton *) skeleton), *((Slot *) slot), start, count, worldVertices, offset, stride);
 }
@@ -83,12 +83,12 @@ void spine_clipping_attachment_set_world_vertices_length(spine_clipping_attachme
 	_self->setWorldVerticesLength(inValue);
 }
 
-spine_attachment spine_clipping_attachment_get_timeline_attachment(spine_clipping_attachment self) {
+/*@null*/ spine_attachment spine_clipping_attachment_get_timeline_attachment(spine_clipping_attachment self) {
 	VertexAttachment *_self = (VertexAttachment *) (ClippingAttachment *) self;
 	return (spine_attachment) _self->getTimelineAttachment();
 }
 
-void spine_clipping_attachment_set_timeline_attachment(spine_clipping_attachment self, spine_attachment attachment) {
+void spine_clipping_attachment_set_timeline_attachment(spine_clipping_attachment self, /*@null*/ spine_attachment attachment) {
 	VertexAttachment *_self = (VertexAttachment *) (ClippingAttachment *) self;
 	_self->setTimelineAttachment((Attachment *) attachment);
 }

spine-c/src/generated/clipping_attachment.h

@@ -14,12 +14,13 @@ SPINE_C_API spine_clipping_attachment spine_clipping_attachment_create(const cha
 SPINE_C_API void spine_clipping_attachment_dispose(spine_clipping_attachment self);
 
 SPINE_C_API spine_rtti spine_clipping_attachment_get_rtti(spine_clipping_attachment self);
-SPINE_C_API spine_slot_data spine_clipping_attachment_get_end_slot(spine_clipping_attachment self);
-SPINE_C_API void spine_clipping_attachment_set_end_slot(spine_clipping_attachment self, spine_slot_data inValue);
+SPINE_C_API /*@null*/ spine_slot_data spine_clipping_attachment_get_end_slot(spine_clipping_attachment self);
+SPINE_C_API void spine_clipping_attachment_set_end_slot(spine_clipping_attachment self, /*@null*/ spine_slot_data inValue);
 SPINE_C_API spine_color spine_clipping_attachment_get_color(spine_clipping_attachment self);
 SPINE_C_API spine_attachment spine_clipping_attachment_copy(spine_clipping_attachment self);
 SPINE_C_API void spine_clipping_attachment_compute_world_vertices_1(spine_clipping_attachment self, spine_skeleton skeleton, spine_slot slot,
-																	size_t start, size_t count, float *worldVertices, size_t offset, size_t stride);
+																	size_t start, size_t count, /*@null*/ float *worldVertices, size_t offset,
+																	size_t stride);
 SPINE_C_API void spine_clipping_attachment_compute_world_vertices_2(spine_clipping_attachment self, spine_skeleton skeleton, spine_slot slot,
 																	size_t start, size_t count, spine_array_float worldVertices, size_t offset,
 																	size_t stride);
@@ -30,8 +31,8 @@ SPINE_C_API spine_array_float spine_clipping_attachment_get_vertices(spine_clipp
 SPINE_C_API void spine_clipping_attachment_set_vertices(spine_clipping_attachment self, spine_array_float vertices);
 SPINE_C_API size_t spine_clipping_attachment_get_world_vertices_length(spine_clipping_attachment self);
 SPINE_C_API void spine_clipping_attachment_set_world_vertices_length(spine_clipping_attachment self, size_t inValue);
-SPINE_C_API spine_attachment spine_clipping_attachment_get_timeline_attachment(spine_clipping_attachment self);
-SPINE_C_API void spine_clipping_attachment_set_timeline_attachment(spine_clipping_attachment self, spine_attachment attachment);
+SPINE_C_API /*@null*/ spine_attachment spine_clipping_attachment_get_timeline_attachment(spine_clipping_attachment self);
+SPINE_C_API void spine_clipping_attachment_set_timeline_attachment(spine_clipping_attachment self, /*@null*/ spine_attachment attachment);
 SPINE_C_API void spine_clipping_attachment_copy_to(spine_clipping_attachment self, spine_vertex_attachment other);
 SPINE_C_API const char *spine_clipping_attachment_get_name(spine_clipping_attachment self);
 SPINE_C_API int spine_clipping_attachment_get_ref_count(spine_clipping_attachment self);

spine-c/src/generated/color.cpp

@@ -50,7 +50,7 @@ spine_color spine_color_clamp(spine_color self) {
 	return (spine_color) &_self->clamp();
 }
 
-float spine_color_parse_hex(const char *value, size_t index) {
+float spine_color_parse_hex(/*@null*/ const char *value, size_t index) {
 	return Color::parseHex(value, index);
 }
 

spine-c/src/generated/color.h

@@ -21,7 +21,7 @@ SPINE_C_API spine_color spine_color_add_1(spine_color self, float _r, float _g,
 SPINE_C_API spine_color spine_color_add_2(spine_color self, float _r, float _g, float _b);
 SPINE_C_API spine_color spine_color_add_3(spine_color self, spine_color other);
 SPINE_C_API spine_color spine_color_clamp(spine_color self);
-SPINE_C_API float spine_color_parse_hex(const char *value, size_t index);
+SPINE_C_API float spine_color_parse_hex(/*@null*/ const char *value, size_t index);
 SPINE_C_API void spine_color_rgba8888_to_color(spine_color color, int value);
 SPINE_C_API void spine_color_rgb888_to_color(spine_color color, int value);
 SPINE_C_API float spine_color_get_r(spine_color self);

spine-c/src/generated/constraint_timeline1.cpp

@@ -82,8 +82,9 @@ spine_array_float spine_constraint_timeline1_get_curves(spine_constraint_timelin
 	return (spine_array_float) &_self->getCurves();
 }
 
-void spine_constraint_timeline1_apply(spine_constraint_timeline1 self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents,
-									  float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
+void spine_constraint_timeline1_apply(spine_constraint_timeline1 self, spine_skeleton skeleton, float lastTime, float time,
+									  /*@null*/ spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction,
+									  bool appliedPose) {
 	CurveTimeline1 *_self = (CurveTimeline1 *) (ConstraintTimeline1 *) self;
 	_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) pEvents, alpha, (MixBlend) blend, (MixDirection) direction,
 				 appliedPose);

spine-c/src/generated/constraint_timeline1.h

@@ -32,8 +32,8 @@ SPINE_C_API float spine_constraint_timeline1_get_bezier_value(spine_constraint_t
 															  size_t i);
 SPINE_C_API spine_array_float spine_constraint_timeline1_get_curves(spine_constraint_timeline1 self);
 SPINE_C_API void spine_constraint_timeline1_apply(spine_constraint_timeline1 self, spine_skeleton skeleton, float lastTime, float time,
-												  spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction,
-												  bool appliedPose);
+												  /*@null*/ spine_array_event pEvents, float alpha, spine_mix_blend blend,
+												  spine_mix_direction direction, bool appliedPose);
 SPINE_C_API size_t spine_constraint_timeline1_get_frame_entries(spine_constraint_timeline1 self);
 SPINE_C_API size_t spine_constraint_timeline1_get_frame_count(spine_constraint_timeline1 self);
 SPINE_C_API spine_array_float spine_constraint_timeline1_get_frames(spine_constraint_timeline1 self);

spine-c/src/generated/curve_timeline.cpp

@@ -38,7 +38,7 @@ spine_array_float spine_curve_timeline_get_curves(spine_curve_timeline self) {
 	return (spine_array_float) &_self->getCurves();
 }
 
-void spine_curve_timeline_apply(spine_curve_timeline self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents,
+void spine_curve_timeline_apply(spine_curve_timeline self, spine_skeleton skeleton, float lastTime, float time, /*@null*/ spine_array_event pEvents,
 								float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
 	Timeline *_self = (Timeline *) (CurveTimeline *) self;
 	_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) pEvents, alpha, (MixBlend) blend, (MixDirection) direction,

spine-c/src/generated/curve_timeline.h

@@ -18,8 +18,9 @@ SPINE_C_API void spine_curve_timeline_set_bezier(spine_curve_timeline self, size
 												 float cx1, float cy1, float cx2, float cy2, float time2, float value2);
 SPINE_C_API float spine_curve_timeline_get_bezier_value(spine_curve_timeline self, float time, size_t frame, size_t valueOffset, size_t i);
 SPINE_C_API spine_array_float spine_curve_timeline_get_curves(spine_curve_timeline self);
-SPINE_C_API void spine_curve_timeline_apply(spine_curve_timeline self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents,
-											float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose);
+SPINE_C_API void spine_curve_timeline_apply(spine_curve_timeline self, spine_skeleton skeleton, float lastTime, float time,
+											/*@null*/ spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction,
+											bool appliedPose);
 SPINE_C_API size_t spine_curve_timeline_get_frame_entries(spine_curve_timeline self);
 SPINE_C_API size_t spine_curve_timeline_get_frame_count(spine_curve_timeline self);
 SPINE_C_API spine_array_float spine_curve_timeline_get_frames(spine_curve_timeline self);

spine-c/src/generated/curve_timeline1.cpp

@@ -72,7 +72,7 @@ spine_array_float spine_curve_timeline1_get_curves(spine_curve_timeline1 self) {
 	return (spine_array_float) &_self->getCurves();
 }
 
-void spine_curve_timeline1_apply(spine_curve_timeline1 self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents,
+void spine_curve_timeline1_apply(spine_curve_timeline1 self, spine_skeleton skeleton, float lastTime, float time, /*@null*/ spine_array_event pEvents,
 								 float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
 	CurveTimeline *_self = (CurveTimeline *) (CurveTimeline1 *) self;
 	_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) pEvents, alpha, (MixBlend) blend, (MixDirection) direction,

spine-c/src/generated/curve_timeline1.h

@@ -29,7 +29,7 @@ SPINE_C_API void spine_curve_timeline1_set_bezier(spine_curve_timeline1 self, si
 SPINE_C_API float spine_curve_timeline1_get_bezier_value(spine_curve_timeline1 self, float time, size_t frame, size_t valueOffset, size_t i);
 SPINE_C_API spine_array_float spine_curve_timeline1_get_curves(spine_curve_timeline1 self);
 SPINE_C_API void spine_curve_timeline1_apply(spine_curve_timeline1 self, spine_skeleton skeleton, float lastTime, float time,
-											 spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction,
+											 /*@null*/ spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction,
 											 bool appliedPose);
 SPINE_C_API size_t spine_curve_timeline1_get_frame_entries(spine_curve_timeline1 self);
 SPINE_C_API size_t spine_curve_timeline1_get_frame_count(spine_curve_timeline1 self);

spine-c/src/generated/deform_timeline.cpp

@@ -3,7 +3,8 @@
 
 using namespace spine;
 
-spine_deform_timeline spine_deform_timeline_create(size_t frameCount, size_t bezierCount, int slotIndex, spine_vertex_attachment attachment) {
+spine_deform_timeline spine_deform_timeline_create(size_t frameCount, size_t bezierCount, int slotIndex,
+												   /*@null*/ spine_vertex_attachment attachment) {
 	return (spine_deform_timeline) new (__FILE__, __LINE__) DeformTimeline(frameCount, bezierCount, slotIndex, (VertexAttachment *) attachment);
 }
 
@@ -47,7 +48,7 @@ size_t spine_deform_timeline_get_frame_count(spine_deform_timeline self) {
 	return _self->getFrameCount();
 }
 
-void spine_deform_timeline_apply(spine_deform_timeline self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents,
+void spine_deform_timeline_apply(spine_deform_timeline self, spine_skeleton skeleton, float lastTime, float time, /*@null*/ spine_array_event pEvents,
 								 float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
 	SlotCurveTimeline *_self = (SlotCurveTimeline *) (DeformTimeline *) self;
 	_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) pEvents, alpha, (MixBlend) blend, (MixDirection) direction,

spine-c/src/generated/deform_timeline.h

@@ -10,7 +10,7 @@ extern "C" {
 #endif
 
 SPINE_C_API spine_deform_timeline spine_deform_timeline_create(size_t frameCount, size_t bezierCount, int slotIndex,
-															   spine_vertex_attachment attachment);
+															   /*@null*/ spine_vertex_attachment attachment);
 
 SPINE_C_API void spine_deform_timeline_dispose(spine_deform_timeline self);
 
@@ -23,7 +23,7 @@ SPINE_C_API void spine_deform_timeline_set_bezier(spine_deform_timeline self, si
 SPINE_C_API float spine_deform_timeline_get_curve_percent(spine_deform_timeline self, float time, int frame);
 SPINE_C_API size_t spine_deform_timeline_get_frame_count(spine_deform_timeline self);
 SPINE_C_API void spine_deform_timeline_apply(spine_deform_timeline self, spine_skeleton skeleton, float lastTime, float time,
-											 spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction,
+											 /*@null*/ spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction,
 											 bool appliedPose);
 SPINE_C_API int spine_deform_timeline_get_slot_index(spine_deform_timeline self);
 SPINE_C_API void spine_deform_timeline_set_slot_index(spine_deform_timeline self, int inValue);

spine-c/src/generated/draw_order_timeline.cpp

@@ -16,8 +16,9 @@ spine_rtti spine_draw_order_timeline_get_rtti(spine_draw_order_timeline self) {
 	return (spine_rtti) &_self->getRTTI();
 }
 
-void spine_draw_order_timeline_apply(spine_draw_order_timeline self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents,
-									 float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
+void spine_draw_order_timeline_apply(spine_draw_order_timeline self, spine_skeleton skeleton, float lastTime, float time,
+									 /*@null*/ spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction,
+									 bool appliedPose) {
 	DrawOrderTimeline *_self = (DrawOrderTimeline *) self;
 	_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) pEvents, alpha, (MixBlend) blend, (MixDirection) direction,
 				 appliedPose);
@@ -28,7 +29,7 @@ size_t spine_draw_order_timeline_get_frame_count(spine_draw_order_timeline self)
 	return _self->getFrameCount();
 }
 
-void spine_draw_order_timeline_set_frame(spine_draw_order_timeline self, size_t frame, float time, spine_array_int drawOrder) {
+void spine_draw_order_timeline_set_frame(spine_draw_order_timeline self, size_t frame, float time, /*@null*/ spine_array_int drawOrder) {
 	DrawOrderTimeline *_self = (DrawOrderTimeline *) self;
 	_self->setFrame(frame, time, (Array<int> *) drawOrder);
 }

spine-c/src/generated/draw_order_timeline.h

@@ -15,10 +15,10 @@ SPINE_C_API void spine_draw_order_timeline_dispose(spine_draw_order_timeline sel
 
 SPINE_C_API spine_rtti spine_draw_order_timeline_get_rtti(spine_draw_order_timeline self);
 SPINE_C_API void spine_draw_order_timeline_apply(spine_draw_order_timeline self, spine_skeleton skeleton, float lastTime, float time,
-												 spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction,
-												 bool appliedPose);
+												 /*@null*/ spine_array_event pEvents, float alpha, spine_mix_blend blend,
+												 spine_mix_direction direction, bool appliedPose);
 SPINE_C_API size_t spine_draw_order_timeline_get_frame_count(spine_draw_order_timeline self);
-SPINE_C_API void spine_draw_order_timeline_set_frame(spine_draw_order_timeline self, size_t frame, float time, spine_array_int drawOrder);
+SPINE_C_API void spine_draw_order_timeline_set_frame(spine_draw_order_timeline self, size_t frame, float time, /*@null*/ spine_array_int drawOrder);
 SPINE_C_API size_t spine_draw_order_timeline_get_frame_entries(spine_draw_order_timeline self);
 SPINE_C_API spine_array_float spine_draw_order_timeline_get_frames(spine_draw_order_timeline self);
 SPINE_C_API float spine_draw_order_timeline_get_duration(spine_draw_order_timeline self);

spine-c/src/generated/event_queue_entry.cpp

@@ -3,7 +3,8 @@
 
 using namespace spine;
 
-spine_event_queue_entry spine_event_queue_entry_create(spine_event_type eventType, spine_track_entry trackEntry, spine_event event) {
+spine_event_queue_entry spine_event_queue_entry_create(spine_event_type eventType, /*@null*/ spine_track_entry trackEntry,
+													   /*@null*/ spine_event event) {
 	return (spine_event_queue_entry) new (__FILE__, __LINE__) EventQueueEntry((EventType) eventType, (TrackEntry *) trackEntry, (Event *) event);
 }
 
@@ -21,22 +22,22 @@ void spine_event_queue_entry_set__type(spine_event_queue_entry self, spine_event
 	_self->_type = (EventType) value;
 }
 
-spine_track_entry spine_event_queue_entry_get__entry(spine_event_queue_entry self) {
+/*@null*/ spine_track_entry spine_event_queue_entry_get__entry(spine_event_queue_entry self) {
 	EventQueueEntry *_self = (EventQueueEntry *) self;
 	return (spine_track_entry) _self->_entry;
 }
 
-void spine_event_queue_entry_set__entry(spine_event_queue_entry self, spine_track_entry value) {
+void spine_event_queue_entry_set__entry(spine_event_queue_entry self, /*@null*/ spine_track_entry value) {
 	EventQueueEntry *_self = (EventQueueEntry *) self;
 	_self->_entry = (TrackEntry *) value;
 }
 
-spine_event spine_event_queue_entry_get__event(spine_event_queue_entry self) {
+/*@null*/ spine_event spine_event_queue_entry_get__event(spine_event_queue_entry self) {
 	EventQueueEntry *_self = (EventQueueEntry *) self;
 	return (spine_event) _self->_event;
 }
 
-void spine_event_queue_entry_set__event(spine_event_queue_entry self, spine_event value) {
+void spine_event_queue_entry_set__event(spine_event_queue_entry self, /*@null*/ spine_event value) {
 	EventQueueEntry *_self = (EventQueueEntry *) self;
 	_self->_event = (Event *) value;
 }

spine-c/src/generated/event_queue_entry.h

@@ -9,16 +9,17 @@
 extern "C" {
 #endif
 
-SPINE_C_API spine_event_queue_entry spine_event_queue_entry_create(spine_event_type eventType, spine_track_entry trackEntry, spine_event event);
+SPINE_C_API spine_event_queue_entry spine_event_queue_entry_create(spine_event_type eventType, /*@null*/ spine_track_entry trackEntry,
+																   /*@null*/ spine_event event);
 
 SPINE_C_API void spine_event_queue_entry_dispose(spine_event_queue_entry self);
 
 SPINE_C_API spine_event_type spine_event_queue_entry_get__type(spine_event_queue_entry self);
 SPINE_C_API void spine_event_queue_entry_set__type(spine_event_queue_entry self, spine_event_type value);
-SPINE_C_API spine_track_entry spine_event_queue_entry_get__entry(spine_event_queue_entry self);
-SPINE_C_API void spine_event_queue_entry_set__entry(spine_event_queue_entry self, spine_track_entry value);
-SPINE_C_API spine_event spine_event_queue_entry_get__event(spine_event_queue_entry self);
-SPINE_C_API void spine_event_queue_entry_set__event(spine_event_queue_entry self, spine_event value);
+SPINE_C_API /*@null*/ spine_track_entry spine_event_queue_entry_get__entry(spine_event_queue_entry self);
+SPINE_C_API void spine_event_queue_entry_set__entry(spine_event_queue_entry self, /*@null*/ spine_track_entry value);
+SPINE_C_API /*@null*/ spine_event spine_event_queue_entry_get__event(spine_event_queue_entry self);
+SPINE_C_API void spine_event_queue_entry_set__event(spine_event_queue_entry self, /*@null*/ spine_event value);
 
 #ifdef __cplusplus
 }

spine-c/src/generated/event_timeline.cpp

@@ -16,7 +16,7 @@ spine_rtti spine_event_timeline_get_rtti(spine_event_timeline self) {
 	return (spine_rtti) &_self->getRTTI();
 }
 
-void spine_event_timeline_apply(spine_event_timeline self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents,
+void spine_event_timeline_apply(spine_event_timeline self, spine_skeleton skeleton, float lastTime, float time, /*@null*/ spine_array_event pEvents,
 								float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
 	EventTimeline *_self = (EventTimeline *) self;
 	_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) pEvents, alpha, (MixBlend) blend, (MixDirection) direction,
@@ -28,7 +28,7 @@ size_t spine_event_timeline_get_frame_count(spine_event_timeline self) {
 	return _self->getFrameCount();
 }
 
-spine_array_event spine_event_timeline_get_events(spine_event_timeline self) {
+/*@null*/ spine_array_event spine_event_timeline_get_events(spine_event_timeline self) {
 	EventTimeline *_self = (EventTimeline *) self;
 	return (spine_array_event) &_self->getEvents();
 }

spine-c/src/generated/event_timeline.h

@@ -14,10 +14,11 @@ SPINE_C_API spine_event_timeline spine_event_timeline_create(size_t frameCount);
 SPINE_C_API void spine_event_timeline_dispose(spine_event_timeline self);
 
 SPINE_C_API spine_rtti spine_event_timeline_get_rtti(spine_event_timeline self);
-SPINE_C_API void spine_event_timeline_apply(spine_event_timeline self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents,
-											float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose);
+SPINE_C_API void spine_event_timeline_apply(spine_event_timeline self, spine_skeleton skeleton, float lastTime, float time,
+											/*@null*/ spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction,
+											bool appliedPose);
 SPINE_C_API size_t spine_event_timeline_get_frame_count(spine_event_timeline self);
-SPINE_C_API spine_array_event spine_event_timeline_get_events(spine_event_timeline self);
+SPINE_C_API /*@null*/ spine_array_event spine_event_timeline_get_events(spine_event_timeline self);
 SPINE_C_API void spine_event_timeline_set_frame(spine_event_timeline self, size_t frame, spine_event event);
 SPINE_C_API size_t spine_event_timeline_get_frame_entries(spine_event_timeline self);
 SPINE_C_API spine_array_float spine_event_timeline_get_frames(spine_event_timeline self);

spine-c/src/generated/from_property.cpp

@@ -12,7 +12,7 @@ spine_rtti spine_from_property_get_rtti(spine_from_property self) {
 	return (spine_rtti) &_self->getRTTI();
 }
 
-float spine_from_property_value(spine_from_property self, spine_skeleton skeleton, spine_bone_pose source, bool local, float *offsets) {
+float spine_from_property_value(spine_from_property self, spine_skeleton skeleton, spine_bone_pose source, bool local, /*@null*/ float *offsets) {
 	FromProperty *_self = (FromProperty *) self;
 	return _self->value(*((Skeleton *) skeleton), *((BonePose *) source), local, offsets);
 }
@@ -31,12 +31,12 @@ void spine_from_property_set__offset(spine_from_property self, float value) {
 	_self->_offset = value;
 }
 
-spine_array_to_property spine_from_property_get__to(spine_from_property self) {
+/*@null*/ spine_array_to_property spine_from_property_get__to(spine_from_property self) {
 	FromProperty *_self = (FromProperty *) self;
 	return (spine_array_to_property) &_self->_to;
 }
 
-void spine_from_property_set__to(spine_from_property self, spine_array_to_property value) {
+void spine_from_property_set__to(spine_from_property self, /*@null*/ spine_array_to_property value) {
 	FromProperty *_self = (FromProperty *) self;
 	_self->_to = *((Array<ToProperty *> *) value);
 }

spine-c/src/generated/from_property.h

@@ -12,12 +12,13 @@ extern "C" {
 SPINE_C_API void spine_from_property_dispose(spine_from_property self);
 
 SPINE_C_API spine_rtti spine_from_property_get_rtti(spine_from_property self);
-SPINE_C_API float spine_from_property_value(spine_from_property self, spine_skeleton skeleton, spine_bone_pose source, bool local, float *offsets);
+SPINE_C_API float spine_from_property_value(spine_from_property self, spine_skeleton skeleton, spine_bone_pose source, bool local,
+											/*@null*/ float *offsets);
 SPINE_C_API spine_rtti spine_from_property_rtti(void);
 SPINE_C_API float spine_from_property_get__offset(spine_from_property self);
 SPINE_C_API void spine_from_property_set__offset(spine_from_property self, float value);
-SPINE_C_API spine_array_to_property spine_from_property_get__to(spine_from_property self);
-SPINE_C_API void spine_from_property_set__to(spine_from_property self, spine_array_to_property value);
+SPINE_C_API /*@null*/ spine_array_to_property spine_from_property_get__to(spine_from_property self);
+SPINE_C_API void spine_from_property_set__to(spine_from_property self, /*@null*/ spine_array_to_property value);
 
 #ifdef __cplusplus
 }

spine-c/src/generated/from_rotate.cpp

@@ -16,7 +16,7 @@ spine_rtti spine_from_rotate_get_rtti(spine_from_rotate self) {
 	return (spine_rtti) &_self->getRTTI();
 }
 
-float spine_from_rotate_value(spine_from_rotate self, spine_skeleton skeleton, spine_bone_pose source, bool local, float *offsets) {
+float spine_from_rotate_value(spine_from_rotate self, spine_skeleton skeleton, spine_bone_pose source, bool local, /*@null*/ float *offsets) {
 	FromRotate *_self = (FromRotate *) self;
 	return _self->value(*((Skeleton *) skeleton), *((BonePose *) source), local, offsets);
 }

spine-c/src/generated/from_rotate.h

@@ -14,7 +14,8 @@ SPINE_C_API spine_from_rotate spine_from_rotate_create(void);
 SPINE_C_API void spine_from_rotate_dispose(spine_from_rotate self);
 
 SPINE_C_API spine_rtti spine_from_rotate_get_rtti(spine_from_rotate self);
-SPINE_C_API float spine_from_rotate_value(spine_from_rotate self, spine_skeleton skeleton, spine_bone_pose source, bool local, float *offsets);
+SPINE_C_API float spine_from_rotate_value(spine_from_rotate self, spine_skeleton skeleton, spine_bone_pose source, bool local,
+										  /*@null*/ float *offsets);
 SPINE_C_API spine_rtti spine_from_rotate_rtti(void);
 
 #ifdef __cplusplus

spine-c/src/generated/from_scale_x.cpp

@@ -16,7 +16,7 @@ spine_rtti spine_from_scale_x_get_rtti(spine_from_scale_x self) {
 	return (spine_rtti) &_self->getRTTI();
 }
 
-float spine_from_scale_x_value(spine_from_scale_x self, spine_skeleton skeleton, spine_bone_pose source, bool local, float *offsets) {
+float spine_from_scale_x_value(spine_from_scale_x self, spine_skeleton skeleton, spine_bone_pose source, bool local, /*@null*/ float *offsets) {
 	FromScaleX *_self = (FromScaleX *) self;
 	return _self->value(*((Skeleton *) skeleton), *((BonePose *) source), local, offsets);
 }

spine-c/src/generated/from_scale_x.h

@@ -14,7 +14,8 @@ SPINE_C_API spine_from_scale_x spine_from_scale_x_create(void);
 SPINE_C_API void spine_from_scale_x_dispose(spine_from_scale_x self);
 
 SPINE_C_API spine_rtti spine_from_scale_x_get_rtti(spine_from_scale_x self);
-SPINE_C_API float spine_from_scale_x_value(spine_from_scale_x self, spine_skeleton skeleton, spine_bone_pose source, bool local, float *offsets);
+SPINE_C_API float spine_from_scale_x_value(spine_from_scale_x self, spine_skeleton skeleton, spine_bone_pose source, bool local,
+										   /*@null*/ float *offsets);
 SPINE_C_API spine_rtti spine_from_scale_x_rtti(void);
 
 #ifdef __cplusplus

spine-c/src/generated/from_scale_y.cpp

@@ -16,7 +16,7 @@ spine_rtti spine_from_scale_y_get_rtti(spine_from_scale_y self) {
 	return (spine_rtti) &_self->getRTTI();
 }
 
-float spine_from_scale_y_value(spine_from_scale_y self, spine_skeleton skeleton, spine_bone_pose source, bool local, float *offsets) {
+float spine_from_scale_y_value(spine_from_scale_y self, spine_skeleton skeleton, spine_bone_pose source, bool local, /*@null*/ float *offsets) {
 	FromScaleY *_self = (FromScaleY *) self;
 	return _self->value(*((Skeleton *) skeleton), *((BonePose *) source), local, offsets);
 }

spine-c/src/generated/from_scale_y.h

@@ -14,7 +14,8 @@ SPINE_C_API spine_from_scale_y spine_from_scale_y_create(void);
 SPINE_C_API void spine_from_scale_y_dispose(spine_from_scale_y self);
 
 SPINE_C_API spine_rtti spine_from_scale_y_get_rtti(spine_from_scale_y self);
-SPINE_C_API float spine_from_scale_y_value(spine_from_scale_y self, spine_skeleton skeleton, spine_bone_pose source, bool local, float *offsets);
+SPINE_C_API float spine_from_scale_y_value(spine_from_scale_y self, spine_skeleton skeleton, spine_bone_pose source, bool local,
+										   /*@null*/ float *offsets);
 SPINE_C_API spine_rtti spine_from_scale_y_rtti(void);
 
 #ifdef __cplusplus

spine-c/src/generated/from_shear_y.cpp

@@ -16,7 +16,7 @@ spine_rtti spine_from_shear_y_get_rtti(spine_from_shear_y self) {
 	return (spine_rtti) &_self->getRTTI();
 }
 
-float spine_from_shear_y_value(spine_from_shear_y self, spine_skeleton skeleton, spine_bone_pose source, bool local, float *offsets) {
+float spine_from_shear_y_value(spine_from_shear_y self, spine_skeleton skeleton, spine_bone_pose source, bool local, /*@null*/ float *offsets) {
 	FromShearY *_self = (FromShearY *) self;
 	return _self->value(*((Skeleton *) skeleton), *((BonePose *) source), local, offsets);
 }

spine-c/src/generated/from_shear_y.h

@@ -14,7 +14,8 @@ SPINE_C_API spine_from_shear_y spine_from_shear_y_create(void);
 SPINE_C_API void spine_from_shear_y_dispose(spine_from_shear_y self);
 
 SPINE_C_API spine_rtti spine_from_shear_y_get_rtti(spine_from_shear_y self);
-SPINE_C_API float spine_from_shear_y_value(spine_from_shear_y self, spine_skeleton skeleton, spine_bone_pose source, bool local, float *offsets);
+SPINE_C_API float spine_from_shear_y_value(spine_from_shear_y self, spine_skeleton skeleton, spine_bone_pose source, bool local,
+										   /*@null*/ float *offsets);
 SPINE_C_API spine_rtti spine_from_shear_y_rtti(void);
 
 #ifdef __cplusplus

spine-c/src/generated/from_x.cpp

@@ -16,7 +16,7 @@ spine_rtti spine_from_x_get_rtti(spine_from_x self) {
 	return (spine_rtti) &_self->getRTTI();
 }
 
-float spine_from_x_value(spine_from_x self, spine_skeleton skeleton, spine_bone_pose source, bool local, float *offsets) {
+float spine_from_x_value(spine_from_x self, spine_skeleton skeleton, spine_bone_pose source, bool local, /*@null*/ float *offsets) {
 	FromX *_self = (FromX *) self;
 	return _self->value(*((Skeleton *) skeleton), *((BonePose *) source), local, offsets);
 }

spine-c/src/generated/from_x.h

@@ -14,7 +14,7 @@ SPINE_C_API spine_from_x spine_from_x_create(void);
 SPINE_C_API void spine_from_x_dispose(spine_from_x self);
 
 SPINE_C_API spine_rtti spine_from_x_get_rtti(spine_from_x self);
-SPINE_C_API float spine_from_x_value(spine_from_x self, spine_skeleton skeleton, spine_bone_pose source, bool local, float *offsets);
+SPINE_C_API float spine_from_x_value(spine_from_x self, spine_skeleton skeleton, spine_bone_pose source, bool local, /*@null*/ float *offsets);
 SPINE_C_API spine_rtti spine_from_x_rtti(void);
 
 #ifdef __cplusplus

spine-c/src/generated/from_y.cpp

@@ -16,7 +16,7 @@ spine_rtti spine_from_y_get_rtti(spine_from_y self) {
 	return (spine_rtti) &_self->getRTTI();
 }
 
-float spine_from_y_value(spine_from_y self, spine_skeleton skeleton, spine_bone_pose source, bool local, float *offsets) {
+float spine_from_y_value(spine_from_y self, spine_skeleton skeleton, spine_bone_pose source, bool local, /*@null*/ float *offsets) {
 	FromY *_self = (FromY *) self;
 	return _self->value(*((Skeleton *) skeleton), *((BonePose *) source), local, offsets);
 }

spine-c/src/generated/from_y.h

@@ -14,7 +14,7 @@ SPINE_C_API spine_from_y spine_from_y_create(void);
 SPINE_C_API void spine_from_y_dispose(spine_from_y self);
 
 SPINE_C_API spine_rtti spine_from_y_get_rtti(spine_from_y self);
-SPINE_C_API float spine_from_y_value(spine_from_y self, spine_skeleton skeleton, spine_bone_pose source, bool local, float *offsets);
+SPINE_C_API float spine_from_y_value(spine_from_y self, spine_skeleton skeleton, spine_bone_pose source, bool local, /*@null*/ float *offsets);
 SPINE_C_API spine_rtti spine_from_y_rtti(void);
 
 #ifdef __cplusplus

spine-c/src/generated/ik_constraint.cpp

@@ -41,7 +41,7 @@ spine_ik_constraint_data spine_ik_constraint_get_data(spine_ik_constraint self)
 	return (spine_ik_constraint_data) &_self->getData();
 }
 
-spine_array_bone_pose spine_ik_constraint_get_bones(spine_ik_constraint self) {
+/*@null*/ spine_array_bone_pose spine_ik_constraint_get_bones(spine_ik_constraint self) {
 	IkConstraint *_self = (IkConstraint *) self;
 	return (spine_array_bone_pose) &_self->getBones();
 }

spine-c/src/generated/ik_constraint.h

@@ -19,7 +19,7 @@ SPINE_C_API void spine_ik_constraint_update(spine_ik_constraint self, spine_skel
 SPINE_C_API void spine_ik_constraint_sort(spine_ik_constraint self, spine_skeleton skeleton);
 SPINE_C_API bool spine_ik_constraint_is_source_active(spine_ik_constraint self);
 SPINE_C_API spine_ik_constraint_data spine_ik_constraint_get_data(spine_ik_constraint self);
-SPINE_C_API spine_array_bone_pose spine_ik_constraint_get_bones(spine_ik_constraint self);
+SPINE_C_API /*@null*/ spine_array_bone_pose spine_ik_constraint_get_bones(spine_ik_constraint self);
 SPINE_C_API spine_bone spine_ik_constraint_get_target(spine_ik_constraint self);
 SPINE_C_API void spine_ik_constraint_set_target(spine_ik_constraint self, spine_bone inValue);
 SPINE_C_API void spine_ik_constraint_apply_1(spine_skeleton skeleton, spine_bone_pose bone, float targetX, float targetY, bool compress, bool stretch,

spine-c/src/generated/ik_constraint_data.cpp

@@ -21,7 +21,7 @@ spine_constraint spine_ik_constraint_data_create_method(spine_ik_constraint_data
 	return (spine_constraint) &_self->create(*((Skeleton *) skeleton));
 }
 
-spine_array_bone_data spine_ik_constraint_data_get_bones(spine_ik_constraint_data self) {
+/*@null*/ spine_array_bone_data spine_ik_constraint_data_get_bones(spine_ik_constraint_data self) {
 	IkConstraintData *_self = (IkConstraintData *) self;
 	return (spine_array_bone_data) &_self->getBones();
 }

spine-c/src/generated/ik_constraint_data.h

@@ -15,7 +15,7 @@ SPINE_C_API void spine_ik_constraint_data_dispose(spine_ik_constraint_data self)
 
 SPINE_C_API spine_rtti spine_ik_constraint_data_get_rtti(spine_ik_constraint_data self);
 SPINE_C_API spine_constraint spine_ik_constraint_data_create_method(spine_ik_constraint_data self, spine_skeleton skeleton);
-SPINE_C_API spine_array_bone_data spine_ik_constraint_data_get_bones(spine_ik_constraint_data self);
+SPINE_C_API /*@null*/ spine_array_bone_data spine_ik_constraint_data_get_bones(spine_ik_constraint_data self);
 SPINE_C_API spine_bone_data spine_ik_constraint_data_get_target(spine_ik_constraint_data self);
 SPINE_C_API void spine_ik_constraint_data_set_target(spine_ik_constraint_data self, spine_bone_data inValue);
 SPINE_C_API bool spine_ik_constraint_data_get_uniform(spine_ik_constraint_data self);

spine-c/src/generated/ik_constraint_timeline.cpp

@@ -17,7 +17,7 @@ spine_rtti spine_ik_constraint_timeline_get_rtti(spine_ik_constraint_timeline se
 }
 
 void spine_ik_constraint_timeline_apply(spine_ik_constraint_timeline self, spine_skeleton skeleton, float lastTime, float time,
-										spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction,
+										/*@null*/ spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction,
 										bool appliedPose) {
 	IkConstraintTimeline *_self = (IkConstraintTimeline *) self;
 	_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) pEvents, alpha, (MixBlend) blend, (MixDirection) direction,

spine-c/src/generated/ik_constraint_timeline.h

@@ -15,8 +15,8 @@ SPINE_C_API void spine_ik_constraint_timeline_dispose(spine_ik_constraint_timeli
 
 SPINE_C_API spine_rtti spine_ik_constraint_timeline_get_rtti(spine_ik_constraint_timeline self);
 SPINE_C_API void spine_ik_constraint_timeline_apply(spine_ik_constraint_timeline self, spine_skeleton skeleton, float lastTime, float time,
-													spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction,
-													bool appliedPose);
+													/*@null*/ spine_array_event pEvents, float alpha, spine_mix_blend blend,
+													spine_mix_direction direction, bool appliedPose);
 SPINE_C_API void spine_ik_constraint_timeline_set_frame(spine_ik_constraint_timeline self, int frame, float time, float mix, float softness,
 														int bendDirection, bool compress, bool stretch);
 SPINE_C_API int spine_ik_constraint_timeline_get_constraint_index(spine_ik_constraint_timeline self);

spine-c/src/generated/inherit_timeline.cpp

@@ -21,8 +21,9 @@ void spine_inherit_timeline_set_frame(spine_inherit_timeline self, int frame, fl
 	_self->setFrame(frame, time, (Inherit) inherit);
 }
 
-void spine_inherit_timeline_apply(spine_inherit_timeline self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents,
-								  float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
+void spine_inherit_timeline_apply(spine_inherit_timeline self, spine_skeleton skeleton, float lastTime, float time,
+								  /*@null*/ spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction,
+								  bool appliedPose) {
 	InheritTimeline *_self = (InheritTimeline *) self;
 	_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) pEvents, alpha, (MixBlend) blend, (MixDirection) direction,
 				 appliedPose);

spine-c/src/generated/inherit_timeline.h

@@ -16,7 +16,7 @@ SPINE_C_API void spine_inherit_timeline_dispose(spine_inherit_timeline self);
 SPINE_C_API spine_rtti spine_inherit_timeline_get_rtti(spine_inherit_timeline self);
 SPINE_C_API void spine_inherit_timeline_set_frame(spine_inherit_timeline self, int frame, float time, spine_inherit inherit);
 SPINE_C_API void spine_inherit_timeline_apply(spine_inherit_timeline self, spine_skeleton skeleton, float lastTime, float time,
-											  spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction,
+											  /*@null*/ spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction,
 											  bool appliedPose);
 SPINE_C_API int spine_inherit_timeline_get_bone_index(spine_inherit_timeline self);
 SPINE_C_API void spine_inherit_timeline_set_bone_index(spine_inherit_timeline self, int inValue);

spine-c/src/generated/linked_mesh.cpp

@@ -3,12 +3,12 @@
 
 using namespace spine;
 
-spine_linked_mesh spine_linked_mesh_create(spine_mesh_attachment mesh, const int skinIndex, size_t slotIndex, const char *parent,
+spine_linked_mesh spine_linked_mesh_create(/*@null*/ spine_mesh_attachment mesh, const int skinIndex, size_t slotIndex, const char *parent,
 										   bool inheritTimelines) {
 	return (spine_linked_mesh) new (__FILE__, __LINE__) LinkedMesh((MeshAttachment *) mesh, skinIndex, slotIndex, String(parent), inheritTimelines);
 }
 
-spine_linked_mesh spine_linked_mesh_create2(spine_mesh_attachment mesh, const char *skin, size_t slotIndex, const char *parent,
+spine_linked_mesh spine_linked_mesh_create2(/*@null*/ spine_mesh_attachment mesh, const char *skin, size_t slotIndex, const char *parent,
 											bool inheritTimelines) {
 	return (spine_linked_mesh) new (__FILE__, __LINE__)
 		LinkedMesh((MeshAttachment *) mesh, String(skin), slotIndex, String(parent), inheritTimelines);

spine-c/src/generated/linked_mesh.h

@@ -9,9 +9,9 @@
 extern "C" {
 #endif
 
-SPINE_C_API spine_linked_mesh spine_linked_mesh_create(spine_mesh_attachment mesh, const int skinIndex, size_t slotIndex, const char *parent,
-													   bool inheritTimelines);
-SPINE_C_API spine_linked_mesh spine_linked_mesh_create2(spine_mesh_attachment mesh, const char *skin, size_t slotIndex, const char *parent,
+SPINE_C_API spine_linked_mesh spine_linked_mesh_create(/*@null*/ spine_mesh_attachment mesh, const int skinIndex, size_t slotIndex,
+													   const char *parent, bool inheritTimelines);
+SPINE_C_API spine_linked_mesh spine_linked_mesh_create2(/*@null*/ spine_mesh_attachment mesh, const char *skin, size_t slotIndex, const char *parent,
 														bool inheritTimelines);
 
 SPINE_C_API void spine_linked_mesh_dispose(spine_linked_mesh self);

spine-c/src/generated/mesh_attachment.cpp

@@ -17,7 +17,7 @@ spine_rtti spine_mesh_attachment_get_rtti(spine_mesh_attachment self) {
 }
 
 void spine_mesh_attachment_compute_world_vertices_1(spine_mesh_attachment self, spine_skeleton skeleton, spine_slot slot, size_t start, size_t count,
-													float *worldVertices, size_t offset, size_t stride) {
+													/*@null*/ float *worldVertices, size_t offset, size_t stride) {
 	MeshAttachment *_self = (MeshAttachment *) self;
 	_self->computeWorldVertices(*((Skeleton *) skeleton), *((Slot *) slot), start, count, worldVertices, offset, stride);
 }
@@ -83,7 +83,7 @@ void spine_mesh_attachment_set_path(spine_mesh_attachment self, const char *inVa
 	_self->setPath(String(inValue));
 }
 
-spine_texture_region spine_mesh_attachment_get_region(spine_mesh_attachment self) {
+/*@null*/ spine_texture_region spine_mesh_attachment_get_region(spine_mesh_attachment self) {
 	MeshAttachment *_self = (MeshAttachment *) self;
 	return (spine_texture_region) _self->getRegion();
 }
@@ -93,22 +93,22 @@ void spine_mesh_attachment_set_region(spine_mesh_attachment self, spine_texture_
 	_self->setRegion(*((TextureRegion *) region));
 }
 
-spine_sequence spine_mesh_attachment_get_sequence(spine_mesh_attachment self) {
+/*@null*/ spine_sequence spine_mesh_attachment_get_sequence(spine_mesh_attachment self) {
 	MeshAttachment *_self = (MeshAttachment *) self;
 	return (spine_sequence) _self->getSequence();
 }
 
-void spine_mesh_attachment_set_sequence(spine_mesh_attachment self, spine_sequence sequence) {
+void spine_mesh_attachment_set_sequence(spine_mesh_attachment self, /*@null*/ spine_sequence sequence) {
 	MeshAttachment *_self = (MeshAttachment *) self;
 	_self->setSequence((Sequence *) sequence);
 }
 
-spine_mesh_attachment spine_mesh_attachment_get_parent_mesh(spine_mesh_attachment self) {
+/*@null*/ spine_mesh_attachment spine_mesh_attachment_get_parent_mesh(spine_mesh_attachment self) {
 	MeshAttachment *_self = (MeshAttachment *) self;
 	return (spine_mesh_attachment) _self->getParentMesh();
 }
 
-void spine_mesh_attachment_set_parent_mesh(spine_mesh_attachment self, spine_mesh_attachment inValue) {
+void spine_mesh_attachment_set_parent_mesh(spine_mesh_attachment self, /*@null*/ spine_mesh_attachment inValue) {
 	MeshAttachment *_self = (MeshAttachment *) self;
 	_self->setParentMesh((MeshAttachment *) inValue);
 }
@@ -188,12 +188,12 @@ void spine_mesh_attachment_set_world_vertices_length(spine_mesh_attachment self,
 	_self->setWorldVerticesLength(inValue);
 }
 
-spine_attachment spine_mesh_attachment_get_timeline_attachment(spine_mesh_attachment self) {
+/*@null*/ spine_attachment spine_mesh_attachment_get_timeline_attachment(spine_mesh_attachment self) {
 	VertexAttachment *_self = (VertexAttachment *) (MeshAttachment *) self;
 	return (spine_attachment) _self->getTimelineAttachment();
 }
 
-void spine_mesh_attachment_set_timeline_attachment(spine_mesh_attachment self, spine_attachment attachment) {
+void spine_mesh_attachment_set_timeline_attachment(spine_mesh_attachment self, /*@null*/ spine_attachment attachment) {
 	VertexAttachment *_self = (VertexAttachment *) (MeshAttachment *) self;
 	_self->setTimelineAttachment((Attachment *) attachment);
 }

spine-c/src/generated/mesh_attachment.h

@@ -15,7 +15,7 @@ SPINE_C_API void spine_mesh_attachment_dispose(spine_mesh_attachment self);
 
 SPINE_C_API spine_rtti spine_mesh_attachment_get_rtti(spine_mesh_attachment self);
 SPINE_C_API void spine_mesh_attachment_compute_world_vertices_1(spine_mesh_attachment self, spine_skeleton skeleton, spine_slot slot, size_t start,
-																size_t count, float *worldVertices, size_t offset, size_t stride);
+																size_t count, /*@null*/ float *worldVertices, size_t offset, size_t stride);
 SPINE_C_API void spine_mesh_attachment_compute_world_vertices_2(spine_mesh_attachment self, spine_skeleton skeleton, spine_slot slot, size_t start,
 																size_t count, spine_array_float worldVertices, size_t offset, size_t stride);
 SPINE_C_API void spine_mesh_attachment_update_region(spine_mesh_attachment self);
@@ -29,12 +29,12 @@ SPINE_C_API void spine_mesh_attachment_set_triangles(spine_mesh_attachment self,
 SPINE_C_API spine_color spine_mesh_attachment_get_color(spine_mesh_attachment self);
 SPINE_C_API const char *spine_mesh_attachment_get_path(spine_mesh_attachment self);
 SPINE_C_API void spine_mesh_attachment_set_path(spine_mesh_attachment self, const char *inValue);
-SPINE_C_API spine_texture_region spine_mesh_attachment_get_region(spine_mesh_attachment self);
+SPINE_C_API /*@null*/ spine_texture_region spine_mesh_attachment_get_region(spine_mesh_attachment self);
 SPINE_C_API void spine_mesh_attachment_set_region(spine_mesh_attachment self, spine_texture_region region);
-SPINE_C_API spine_sequence spine_mesh_attachment_get_sequence(spine_mesh_attachment self);
-SPINE_C_API void spine_mesh_attachment_set_sequence(spine_mesh_attachment self, spine_sequence sequence);
-SPINE_C_API spine_mesh_attachment spine_mesh_attachment_get_parent_mesh(spine_mesh_attachment self);
-SPINE_C_API void spine_mesh_attachment_set_parent_mesh(spine_mesh_attachment self, spine_mesh_attachment inValue);
+SPINE_C_API /*@null*/ spine_sequence spine_mesh_attachment_get_sequence(spine_mesh_attachment self);
+SPINE_C_API void spine_mesh_attachment_set_sequence(spine_mesh_attachment self, /*@null*/ spine_sequence sequence);
+SPINE_C_API /*@null*/ spine_mesh_attachment spine_mesh_attachment_get_parent_mesh(spine_mesh_attachment self);
+SPINE_C_API void spine_mesh_attachment_set_parent_mesh(spine_mesh_attachment self, /*@null*/ spine_mesh_attachment inValue);
 SPINE_C_API spine_array_unsigned_short spine_mesh_attachment_get_edges(spine_mesh_attachment self);
 SPINE_C_API void spine_mesh_attachment_set_edges(spine_mesh_attachment self, spine_array_unsigned_short inValue);
 SPINE_C_API float spine_mesh_attachment_get_width(spine_mesh_attachment self);
@@ -50,8 +50,8 @@ SPINE_C_API spine_array_float spine_mesh_attachment_get_vertices(spine_mesh_atta
 SPINE_C_API void spine_mesh_attachment_set_vertices(spine_mesh_attachment self, spine_array_float vertices);
 SPINE_C_API size_t spine_mesh_attachment_get_world_vertices_length(spine_mesh_attachment self);
 SPINE_C_API void spine_mesh_attachment_set_world_vertices_length(spine_mesh_attachment self, size_t inValue);
-SPINE_C_API spine_attachment spine_mesh_attachment_get_timeline_attachment(spine_mesh_attachment self);
-SPINE_C_API void spine_mesh_attachment_set_timeline_attachment(spine_mesh_attachment self, spine_attachment attachment);
+SPINE_C_API /*@null*/ spine_attachment spine_mesh_attachment_get_timeline_attachment(spine_mesh_attachment self);
+SPINE_C_API void spine_mesh_attachment_set_timeline_attachment(spine_mesh_attachment self, /*@null*/ spine_attachment attachment);
 SPINE_C_API void spine_mesh_attachment_copy_to(spine_mesh_attachment self, spine_vertex_attachment other);
 SPINE_C_API const char *spine_mesh_attachment_get_name(spine_mesh_attachment self);
 SPINE_C_API int spine_mesh_attachment_get_ref_count(spine_mesh_attachment self);

spine-c/src/generated/path_attachment.cpp

@@ -57,7 +57,7 @@ spine_attachment spine_path_attachment_copy(spine_path_attachment self) {
 }
 
 void spine_path_attachment_compute_world_vertices_1(spine_path_attachment self, spine_skeleton skeleton, spine_slot slot, size_t start, size_t count,
-													float *worldVertices, size_t offset, size_t stride) {
+													/*@null*/ float *worldVertices, size_t offset, size_t stride) {
 	VertexAttachment *_self = (VertexAttachment *) (PathAttachment *) self;
 	_self->computeWorldVertices(*((Skeleton *) skeleton), *((Slot *) slot), start, count, worldVertices, offset, stride);
 }
@@ -103,12 +103,12 @@ void spine_path_attachment_set_world_vertices_length(spine_path_attachment self,
 	_self->setWorldVerticesLength(inValue);
 }
 
-spine_attachment spine_path_attachment_get_timeline_attachment(spine_path_attachment self) {
+/*@null*/ spine_attachment spine_path_attachment_get_timeline_attachment(spine_path_attachment self) {
 	VertexAttachment *_self = (VertexAttachment *) (PathAttachment *) self;
 	return (spine_attachment) _self->getTimelineAttachment();
 }
 
-void spine_path_attachment_set_timeline_attachment(spine_path_attachment self, spine_attachment attachment) {
+void spine_path_attachment_set_timeline_attachment(spine_path_attachment self, /*@null*/ spine_attachment attachment) {
 	VertexAttachment *_self = (VertexAttachment *) (PathAttachment *) self;
 	_self->setTimelineAttachment((Attachment *) attachment);
 }

spine-c/src/generated/path_attachment.h

@@ -23,7 +23,7 @@ SPINE_C_API void spine_path_attachment_set_constant_speed(spine_path_attachment
 SPINE_C_API spine_color spine_path_attachment_get_color(spine_path_attachment self);
 SPINE_C_API spine_attachment spine_path_attachment_copy(spine_path_attachment self);
 SPINE_C_API void spine_path_attachment_compute_world_vertices_1(spine_path_attachment self, spine_skeleton skeleton, spine_slot slot, size_t start,
-																size_t count, float *worldVertices, size_t offset, size_t stride);
+																size_t count, /*@null*/ float *worldVertices, size_t offset, size_t stride);
 SPINE_C_API void spine_path_attachment_compute_world_vertices_2(spine_path_attachment self, spine_skeleton skeleton, spine_slot slot, size_t start,
 																size_t count, spine_array_float worldVertices, size_t offset, size_t stride);
 SPINE_C_API int spine_path_attachment_get_id(spine_path_attachment self);
@@ -33,8 +33,8 @@ SPINE_C_API spine_array_float spine_path_attachment_get_vertices(spine_path_atta
 SPINE_C_API void spine_path_attachment_set_vertices(spine_path_attachment self, spine_array_float vertices);
 SPINE_C_API size_t spine_path_attachment_get_world_vertices_length(spine_path_attachment self);
 SPINE_C_API void spine_path_attachment_set_world_vertices_length(spine_path_attachment self, size_t inValue);
-SPINE_C_API spine_attachment spine_path_attachment_get_timeline_attachment(spine_path_attachment self);
-SPINE_C_API void spine_path_attachment_set_timeline_attachment(spine_path_attachment self, spine_attachment attachment);
+SPINE_C_API /*@null*/ spine_attachment spine_path_attachment_get_timeline_attachment(spine_path_attachment self);
+SPINE_C_API void spine_path_attachment_set_timeline_attachment(spine_path_attachment self, /*@null*/ spine_attachment attachment);
 SPINE_C_API void spine_path_attachment_copy_to(spine_path_attachment self, spine_vertex_attachment other);
 SPINE_C_API const char *spine_path_attachment_get_name(spine_path_attachment self);
 SPINE_C_API int spine_path_attachment_get_ref_count(spine_path_attachment self);

spine-c/src/generated/path_constraint.cpp

@@ -36,7 +36,7 @@ bool spine_path_constraint_is_source_active(spine_path_constraint self) {
 	return _self->isSourceActive();
 }
 
-spine_array_bone_pose spine_path_constraint_get_bones(spine_path_constraint self) {
+/*@null*/ spine_array_bone_pose spine_path_constraint_get_bones(spine_path_constraint self) {
 	PathConstraint *_self = (PathConstraint *) self;
 	return (spine_array_bone_pose) &_self->getBones();
 }

spine-c/src/generated/path_constraint.h

@@ -18,7 +18,7 @@ SPINE_C_API spine_path_constraint spine_path_constraint_copy(spine_path_constrai
 SPINE_C_API void spine_path_constraint_update(spine_path_constraint self, spine_skeleton skeleton, spine_physics physics);
 SPINE_C_API void spine_path_constraint_sort(spine_path_constraint self, spine_skeleton skeleton);
 SPINE_C_API bool spine_path_constraint_is_source_active(spine_path_constraint self);
-SPINE_C_API spine_array_bone_pose spine_path_constraint_get_bones(spine_path_constraint self);
+SPINE_C_API /*@null*/ spine_array_bone_pose spine_path_constraint_get_bones(spine_path_constraint self);
 SPINE_C_API spine_slot spine_path_constraint_get_slot(spine_path_constraint self);
 SPINE_C_API void spine_path_constraint_set_slot(spine_path_constraint self, spine_slot slot);
 SPINE_C_API spine_path_constraint_data spine_path_constraint_get_data(spine_path_constraint self);

spine-c/src/generated/path_constraint_data.cpp

@@ -21,7 +21,7 @@ spine_constraint spine_path_constraint_data_create_method(spine_path_constraint_
 	return (spine_constraint) &_self->create(*((Skeleton *) skeleton));
 }
 
-spine_array_bone_data spine_path_constraint_data_get_bones(spine_path_constraint_data self) {
+/*@null*/ spine_array_bone_data spine_path_constraint_data_get_bones(spine_path_constraint_data self) {
 	PathConstraintData *_self = (PathConstraintData *) self;
 	return (spine_array_bone_data) &_self->getBones();
 }

spine-c/src/generated/path_constraint_data.h

@@ -15,7 +15,7 @@ SPINE_C_API void spine_path_constraint_data_dispose(spine_path_constraint_data s
 
 SPINE_C_API spine_rtti spine_path_constraint_data_get_rtti(spine_path_constraint_data self);
 SPINE_C_API spine_constraint spine_path_constraint_data_create_method(spine_path_constraint_data self, spine_skeleton skeleton);
-SPINE_C_API spine_array_bone_data spine_path_constraint_data_get_bones(spine_path_constraint_data self);
+SPINE_C_API /*@null*/ spine_array_bone_data spine_path_constraint_data_get_bones(spine_path_constraint_data self);
 SPINE_C_API spine_slot_data spine_path_constraint_data_get_slot(spine_path_constraint_data self);
 SPINE_C_API void spine_path_constraint_data_set_slot(spine_path_constraint_data self, spine_slot_data slot);
 SPINE_C_API spine_position_mode spine_path_constraint_data_get_position_mode(spine_path_constraint_data self);

spine-c/src/generated/path_constraint_mix_timeline.cpp

@@ -17,7 +17,7 @@ spine_rtti spine_path_constraint_mix_timeline_get_rtti(spine_path_constraint_mix
 }
 
 void spine_path_constraint_mix_timeline_apply(spine_path_constraint_mix_timeline self, spine_skeleton skeleton, float lastTime, float time,
-											  spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction,
+											  /*@null*/ spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction,
 											  bool appliedPose) {
 	PathConstraintMixTimeline *_self = (PathConstraintMixTimeline *) self;
 	_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) pEvents, alpha, (MixBlend) blend, (MixDirection) direction,

spine-c/src/generated/path_constraint_mix_timeline.h

@@ -15,7 +15,7 @@ SPINE_C_API void spine_path_constraint_mix_timeline_dispose(spine_path_constrain
 
 SPINE_C_API spine_rtti spine_path_constraint_mix_timeline_get_rtti(spine_path_constraint_mix_timeline self);
 SPINE_C_API void spine_path_constraint_mix_timeline_apply(spine_path_constraint_mix_timeline self, spine_skeleton skeleton, float lastTime,
-														  float time, spine_array_event pEvents, float alpha, spine_mix_blend blend,
+														  float time, /*@null*/ spine_array_event pEvents, float alpha, spine_mix_blend blend,
 														  spine_mix_direction direction, bool appliedPose);
 SPINE_C_API void spine_path_constraint_mix_timeline_set_frame(spine_path_constraint_mix_timeline self, int frame, float time, float mixRotate,
 															  float mixX, float mixY);

spine-c/src/generated/path_constraint_position_timeline.cpp

@@ -18,8 +18,8 @@ spine_rtti spine_path_constraint_position_timeline_get_rtti(spine_path_constrain
 }
 
 void spine_path_constraint_position_timeline_apply(spine_path_constraint_position_timeline self, spine_skeleton skeleton, float lastTime, float time,
-												   spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction,
-												   bool appliedPose) {
+												   /*@null*/ spine_array_event pEvents, float alpha, spine_mix_blend blend,
+												   spine_mix_direction direction, bool appliedPose) {
 	PathConstraintPositionTimeline *_self = (PathConstraintPositionTimeline *) self;
 	_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) pEvents, alpha, (MixBlend) blend, (MixDirection) direction,
 				 appliedPose);

spine-c/src/generated/path_constraint_position_timeline.h

@@ -16,7 +16,7 @@ SPINE_C_API void spine_path_constraint_position_timeline_dispose(spine_path_cons
 
 SPINE_C_API spine_rtti spine_path_constraint_position_timeline_get_rtti(spine_path_constraint_position_timeline self);
 SPINE_C_API void spine_path_constraint_position_timeline_apply(spine_path_constraint_position_timeline self, spine_skeleton skeleton, float lastTime,
-															   float time, spine_array_event pEvents, float alpha, spine_mix_blend blend,
+															   float time, /*@null*/ spine_array_event pEvents, float alpha, spine_mix_blend blend,
 															   spine_mix_direction direction, bool appliedPose);
 SPINE_C_API int spine_path_constraint_position_timeline_get_constraint_index(spine_path_constraint_position_timeline self);
 SPINE_C_API void spine_path_constraint_position_timeline_set_constraint_index(spine_path_constraint_position_timeline self, int inValue);

spine-c/src/generated/path_constraint_spacing_timeline.cpp

@@ -17,8 +17,8 @@ spine_rtti spine_path_constraint_spacing_timeline_get_rtti(spine_path_constraint
 }
 
 void spine_path_constraint_spacing_timeline_apply(spine_path_constraint_spacing_timeline self, spine_skeleton skeleton, float lastTime, float time,
-												  spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction,
-												  bool appliedPose) {
+												  /*@null*/ spine_array_event pEvents, float alpha, spine_mix_blend blend,
+												  spine_mix_direction direction, bool appliedPose) {
 	PathConstraintSpacingTimeline *_self = (PathConstraintSpacingTimeline *) self;
 	_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) pEvents, alpha, (MixBlend) blend, (MixDirection) direction,
 				 appliedPose);

spine-c/src/generated/path_constraint_spacing_timeline.h

@@ -16,7 +16,7 @@ SPINE_C_API void spine_path_constraint_spacing_timeline_dispose(spine_path_const
 
 SPINE_C_API spine_rtti spine_path_constraint_spacing_timeline_get_rtti(spine_path_constraint_spacing_timeline self);
 SPINE_C_API void spine_path_constraint_spacing_timeline_apply(spine_path_constraint_spacing_timeline self, spine_skeleton skeleton, float lastTime,
-															  float time, spine_array_event pEvents, float alpha, spine_mix_blend blend,
+															  float time, /*@null*/ spine_array_event pEvents, float alpha, spine_mix_blend blend,
 															  spine_mix_direction direction, bool appliedPose);
 SPINE_C_API int spine_path_constraint_spacing_timeline_get_constraint_index(spine_path_constraint_spacing_timeline self);
 SPINE_C_API void spine_path_constraint_spacing_timeline_set_constraint_index(spine_path_constraint_spacing_timeline self, int inValue);

spine-c/src/generated/physics_constraint_damping_timeline.cpp

@@ -19,7 +19,7 @@ spine_rtti spine_physics_constraint_damping_timeline_get_rtti(spine_physics_cons
 }
 
 void spine_physics_constraint_damping_timeline_apply(spine_physics_constraint_damping_timeline self, spine_skeleton skeleton, float lastTime,
-													 float time, spine_array_event pEvents, float alpha, spine_mix_blend blend,
+													 float time, /*@null*/ spine_array_event pEvents, float alpha, spine_mix_blend blend,
 													 spine_mix_direction direction, bool appliedPose) {
 	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintDampingTimeline *) self;
 	_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) pEvents, alpha, (MixBlend) blend, (MixDirection) direction,

spine-c/src/generated/physics_constraint_damping_timeline.h

@@ -16,7 +16,7 @@ SPINE_C_API void spine_physics_constraint_damping_timeline_dispose(spine_physics
 
 SPINE_C_API spine_rtti spine_physics_constraint_damping_timeline_get_rtti(spine_physics_constraint_damping_timeline self);
 SPINE_C_API void spine_physics_constraint_damping_timeline_apply(spine_physics_constraint_damping_timeline self, spine_skeleton skeleton,
-																 float lastTime, float time, spine_array_event pEvents, float alpha,
+																 float lastTime, float time, /*@null*/ spine_array_event pEvents, float alpha,
 																 spine_mix_blend blend, spine_mix_direction direction, bool appliedPose);
 SPINE_C_API int spine_physics_constraint_damping_timeline_get_constraint_index(spine_physics_constraint_damping_timeline self);
 SPINE_C_API void spine_physics_constraint_damping_timeline_set_constraint_index(spine_physics_constraint_damping_timeline self, int inValue);

spine-c/src/generated/physics_constraint_gravity_timeline.cpp

@@ -19,7 +19,7 @@ spine_rtti spine_physics_constraint_gravity_timeline_get_rtti(spine_physics_cons
 }
 
 void spine_physics_constraint_gravity_timeline_apply(spine_physics_constraint_gravity_timeline self, spine_skeleton skeleton, float lastTime,
-													 float time, spine_array_event pEvents, float alpha, spine_mix_blend blend,
+													 float time, /*@null*/ spine_array_event pEvents, float alpha, spine_mix_blend blend,
 													 spine_mix_direction direction, bool appliedPose) {
 	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintGravityTimeline *) self;
 	_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) pEvents, alpha, (MixBlend) blend, (MixDirection) direction,

spine-c/src/generated/physics_constraint_gravity_timeline.h

@@ -16,7 +16,7 @@ SPINE_C_API void spine_physics_constraint_gravity_timeline_dispose(spine_physics
 
 SPINE_C_API spine_rtti spine_physics_constraint_gravity_timeline_get_rtti(spine_physics_constraint_gravity_timeline self);
 SPINE_C_API void spine_physics_constraint_gravity_timeline_apply(spine_physics_constraint_gravity_timeline self, spine_skeleton skeleton,
-																 float lastTime, float time, spine_array_event pEvents, float alpha,
+																 float lastTime, float time, /*@null*/ spine_array_event pEvents, float alpha,
 																 spine_mix_blend blend, spine_mix_direction direction, bool appliedPose);
 SPINE_C_API int spine_physics_constraint_gravity_timeline_get_constraint_index(spine_physics_constraint_gravity_timeline self);
 SPINE_C_API void spine_physics_constraint_gravity_timeline_set_constraint_index(spine_physics_constraint_gravity_timeline self, int inValue);

spine-c/src/generated/physics_constraint_inertia_timeline.cpp

@@ -19,7 +19,7 @@ spine_rtti spine_physics_constraint_inertia_timeline_get_rtti(spine_physics_cons
 }
 
 void spine_physics_constraint_inertia_timeline_apply(spine_physics_constraint_inertia_timeline self, spine_skeleton skeleton, float lastTime,
-													 float time, spine_array_event pEvents, float alpha, spine_mix_blend blend,
+													 float time, /*@null*/ spine_array_event pEvents, float alpha, spine_mix_blend blend,
 													 spine_mix_direction direction, bool appliedPose) {
 	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintInertiaTimeline *) self;
 	_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) pEvents, alpha, (MixBlend) blend, (MixDirection) direction,

spine-c/src/generated/physics_constraint_inertia_timeline.h

@@ -16,7 +16,7 @@ SPINE_C_API void spine_physics_constraint_inertia_timeline_dispose(spine_physics
 
 SPINE_C_API spine_rtti spine_physics_constraint_inertia_timeline_get_rtti(spine_physics_constraint_inertia_timeline self);
 SPINE_C_API void spine_physics_constraint_inertia_timeline_apply(spine_physics_constraint_inertia_timeline self, spine_skeleton skeleton,
-																 float lastTime, float time, spine_array_event pEvents, float alpha,
+																 float lastTime, float time, /*@null*/ spine_array_event pEvents, float alpha,
 																 spine_mix_blend blend, spine_mix_direction direction, bool appliedPose);
 SPINE_C_API int spine_physics_constraint_inertia_timeline_get_constraint_index(spine_physics_constraint_inertia_timeline self);
 SPINE_C_API void spine_physics_constraint_inertia_timeline_set_constraint_index(spine_physics_constraint_inertia_timeline self, int inValue);

spine-c/src/generated/physics_constraint_mass_timeline.cpp

@@ -19,8 +19,8 @@ spine_rtti spine_physics_constraint_mass_timeline_get_rtti(spine_physics_constra
 }
 
 void spine_physics_constraint_mass_timeline_apply(spine_physics_constraint_mass_timeline self, spine_skeleton skeleton, float lastTime, float time,
-												  spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction,
-												  bool appliedPose) {
+												  /*@null*/ spine_array_event pEvents, float alpha, spine_mix_blend blend,
+												  spine_mix_direction direction, bool appliedPose) {
 	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintMassTimeline *) self;
 	_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) pEvents, alpha, (MixBlend) blend, (MixDirection) direction,
 				 appliedPose);

spine-c/src/generated/physics_constraint_mass_timeline.h

@@ -16,7 +16,7 @@ SPINE_C_API void spine_physics_constraint_mass_timeline_dispose(spine_physics_co
 
 SPINE_C_API spine_rtti spine_physics_constraint_mass_timeline_get_rtti(spine_physics_constraint_mass_timeline self);
 SPINE_C_API void spine_physics_constraint_mass_timeline_apply(spine_physics_constraint_mass_timeline self, spine_skeleton skeleton, float lastTime,
-															  float time, spine_array_event pEvents, float alpha, spine_mix_blend blend,
+															  float time, /*@null*/ spine_array_event pEvents, float alpha, spine_mix_blend blend,
 															  spine_mix_direction direction, bool appliedPose);
 SPINE_C_API int spine_physics_constraint_mass_timeline_get_constraint_index(spine_physics_constraint_mass_timeline self);
 SPINE_C_API void spine_physics_constraint_mass_timeline_set_constraint_index(spine_physics_constraint_mass_timeline self, int inValue);