style: Preserve indentation inside preprocessor blocks and re-run

Author: bobtista

Core/GameEngineDevice/Source/W3DDevice/GameClient/W3DTerrainVisual.cpp

@@ -439,10 +439,10 @@ void W3DTerrainVisual::handleSeismicSimulations()
 
 }
 
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+  ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+  ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+  ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+  ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 void W3DTerrainVisual::updateSeismicSimulations()
 {
 

Core/Libraries/Source/WWVegas/WWLib/FastAllocator.h

@@ -529,11 +529,11 @@ WWINLINE void* FastAllocatorGeneral::Realloc(void* pAlloc, unsigned int n){
 //
 
 #ifdef _MSC_VER
-//VC++ continues to be the one compiler that lacks the ability to compile
-//standard C++. So we define a version of the STL allocator specifically
-//for VC++, and let other compilers use a standard allocator template.
-template <class T>
-struct FastSTLAllocator{
+   //VC++ continues to be the one compiler that lacks the ability to compile
+   //standard C++. So we define a version of the STL allocator specifically
+   //for VC++, and let other compilers use a standard allocator template.
+   template <class T>
+   struct FastSTLAllocator{
 	typedef size_t    size_type;        //basically, "unsigned int"
 	typedef ptrdiff_t difference_type;  //basically, "int"
 	typedef T*        pointer;
@@ -558,14 +558,14 @@ struct FastSTLAllocator{
 	//the above delallocate() function. So your version of deallocate
 	//should *not* assume that it will only be given T objects to delete.
 	char* _Charalloc(size_t n){ return (char*)FastAllocatorGeneral::Get_Allocator()->Alloc(n*sizeof(char)); }
-};
+   };
 #else
-//This is a C++ language standard allocator. Most C++ compilers after 1999
-//other than Microsoft C++ compile this fine. Otherwise. you might be able
-//to use the same allocator as VC++ uses above.
-template <class T>
-class FastSTLAllocator{
-public:
+   //This is a C++ language standard allocator. Most C++ compilers after 1999
+   //other than Microsoft C++ compile this fine. Otherwise. you might be able
+   //to use the same allocator as VC++ uses above.
+   template <class T>
+   class FastSTLAllocator{
+   public:
 	typedef size_t     size_type;
 	typedef ptrdiff_t  difference_type;
 	typedef T*         pointer;
@@ -591,7 +591,7 @@ class FastSTLAllocator{
 	size_type max_size() const                   { return size_t(-1) / sizeof(T); }
 	void construct(pointer p, const T& val)      { new(p) T(val); }
 	void destroy(pointer p)                      { p->~T(); }
-};
+   };
 #endif
 
 template<class T>

Core/Libraries/Source/WWVegas/WWLib/lzo_conf.h

@@ -110,9 +110,9 @@
 
 /* ptrdiff_t */
 #if (UINT_MAX >= 0xffffffffL)
-typedef ptrdiff_t        lzo_ptrdiff_t;
+   typedef ptrdiff_t        lzo_ptrdiff_t;
 #else
-typedef long             lzo_ptrdiff_t;
+   typedef long             lzo_ptrdiff_t;
 #endif
 
 

Core/Libraries/Source/WWVegas/WWLib/lzoconf.h

@@ -94,12 +94,12 @@
 
 /* Unsigned type with 32 bits or more */
 #if (UINT_MAX >= 0xffffffffL)
-typedef unsigned int     lzo_uint;
-typedef int              lzo_int;
+   typedef unsigned int     lzo_uint;
+   typedef int              lzo_int;
 #  define LZO_UINT_MAX      UINT_MAX
 #elif (ULONG_MAX >= 0xffffffffL)
-typedef unsigned long    lzo_uint;
-typedef long             lzo_int;
+   typedef unsigned long    lzo_uint;
+   typedef long             lzo_int;
 #  define LZO_UINT_MAX      ULONG_MAX
 #else
 #  error lzo_uint

Core/Tools/W3DView/W3DViewView.h

@@ -63,7 +63,7 @@ class CW3DViewView : public CView
 
 #ifndef RTS_DEBUG  // debug version in W3DViewView.cpp
 inline CW3DViewDoc* CW3DViewView::GetDocument()
-{ return (CW3DViewDoc*)m_pDocument; }
+   { return (CW3DViewDoc*)m_pDocument; }
 #endif
 
 /////////////////////////////////////////////////////////////////////////////

Core/Tools/mangler/wlib/threadfac.h

@@ -45,14 +45,14 @@
 
 
 #ifdef THREADFAC_CODE
-// This is the fake thread entry point for functions
+  // This is the fake thread entry point for functions
   #ifdef _WIN32
     static unsigned __stdcall threadFuncLauncher(void *temp);
   #else  // UNIX
     static void *threadFuncLauncher(void *temp);
   #endif
 
-// Fake entry point for classes
+  // Fake entry point for classes
   #ifdef _WIN32
     static unsigned __stdcall threadClassLauncher(void *temp);
   #else  // UNIX

Core/Tools/matchbot/wlib/threadfac.h

@@ -45,14 +45,14 @@
 
 
 #ifdef THREADFAC_CODE
-// This is the fake thread entry point for functions
+  // This is the fake thread entry point for functions
   #ifdef _WIN32
     static unsigned __stdcall threadFuncLauncher(void *temp);
   #else  // UNIX
     static void *threadFuncLauncher(void *temp);
   #endif
 
-// Fake entry point for classes
+  // Fake entry point for classes
   #ifdef _WIN32
     static unsigned __stdcall threadClassLauncher(void *temp);
   #else  // UNIX

Dependencies/Utility/Utility/stdint_adapter.h

@@ -21,11 +21,11 @@
 #if defined(USING_STLPORT) || (defined(_MSC_VER) && _MSC_VER < 1300)
 /* 7.18.1.4  Integer types capable of holding object pointers */
 #ifdef _WIN64
-typedef __int64 intptr_t;
-typedef unsigned __int64 uintptr_t;
+  typedef __int64 intptr_t;
+  typedef unsigned __int64 uintptr_t;
 #else
-typedef int intptr_t;
-typedef unsigned int uintptr_t;
+  typedef int intptr_t;
+  typedef unsigned int uintptr_t;
 #endif
 
 /* 7.18.1.1  Exact-width integer types */

scripts/cpp/convert_leading_spaces_to_tabs.py

@@ -184,6 +184,7 @@ def process_file(filepath, dry_run=False, verbose=False):
     in_asm_block = False
     asm_brace_depth = 0
     asm_pending = False
+    pp_depth = 0
 
     for line_idx, line in enumerate(lines):
         # Track block comments manually for reliability
@@ -235,6 +236,13 @@ def process_file(filepath, dry_run=False, verbose=False):
 
         # Preprocessor directives - always column 0
         if stripped.startswith('#'):
+            # Track preprocessor nesting depth
+            directive = stripped.lstrip('#').lstrip()
+            if directive.startswith(('if ', 'if\t', 'ifdef ', 'ifdef\t',
+                                     'ifndef ', 'ifndef\t')):
+                pp_depth += 1
+            elif directive.startswith('endif'):
+                pp_depth = max(0, pp_depth - 1)
             new_lines.append(line)
             in_macro_continuation = line_continues_macro
             continue
@@ -373,9 +381,16 @@ def process_file(filepath, dry_run=False, verbose=False):
         # Sanity check: if the line had significant indentation but we
         # computed depth 0, something is likely wrong (parse errors nearby,
         # inline assembly corrupting the AST, etc). Skip to be safe.
-        # Threshold of 4 spaces catches most misparses while allowing
-        # legitimate depth-0 code with minor (1-3 space) indentation errors.
+        # Also skip depth-0 lines inside preprocessor blocks — the codebase
+        # convention is to indent C++ code inside #if/#ifdef blocks, but
+        # tree-sitter doesn't model preprocessor nesting.
         space_count = len(leading_ws)
+        if depth == 0 and space_count > 0 and pp_depth > 0:
+            new_lines.append(line)
+            skipped += 1
+            if verbose:
+                print(f"  SKIP pp-indent L{line_idx+1}: depth=0 but pp_depth={pp_depth}: {line.rstrip()[:80]}")
+            continue
         if depth == 0 and space_count >= 4:
             new_lines.append(line)
             skipped += 1