Spell "indices" correctly

Change-Id: I63b1de195bf2f3f8bfd185181f48b1520cdd849f

59 files changed, 685 insertions, 685 deletions

diff --git a/bridges/source/cpp_uno/gcc3_aix_powerpc/cpp2uno.cxx b/bridges/source/cpp_uno/gcc3_aix_powerpc/cpp2uno.cxx
index f60afae62102..20d534c1529b 100644
--- a/bridges/source/cpp_uno/gcc3_aix_powerpc/cpp2uno.cxx
+++ b/bridges/source/cpp_uno/gcc3_aix_powerpc/cpp2uno.cxx
@@ -88,13 +88,13 @@ static typelib_TypeClass cpp2uno_call(
         void ** pUnoArgs = (void **)__builtin_alloca( 4 * sizeof(void *) * nParams );
         void ** pCppArgs = pUnoArgs + nParams;
 
-        // indizes of values this have to be converted (interface conversion cpp<=>uno)
-        sal_Int32 * pTempIndizes = (sal_Int32 *)(pUnoArgs + (2 * nParams));
+        // indices of values this have to be converted (interface conversion cpp<=>uno)
+        sal_Int32 * pTempIndices = (sal_Int32 *)(pUnoArgs + (2 * nParams));
 
         // type descriptions for reconversions
         typelib_TypeDescription ** ppTempParamTypeDescr = (typelib_TypeDescription **)(pUnoArgs + (3 * nParams));
 
-        sal_Int32 nTempIndizes   = 0;
+        sal_Int32 nTempIndices   = 0;
 
         for ( sal_Int32 nPos = 0; nPos < nParams; ++nPos )
         {
@@ -206,9 +206,9 @@ static typelib_TypeClass cpp2uno_call(
                         {
                                 // uno out is unconstructed mem!
                                 pUnoArgs[nPos] = __builtin_alloca( pParamTypeDescr->nSize );
-                                pTempIndizes[nTempIndizes] = nPos;
+                                pTempIndices[nTempIndices] = nPos;
                                 // will be released at reconversion
-                                ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+                                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
                         }
                         // is in/inout
                         else if (bridges::cpp_uno::shared::relatesToInterfaceType( pParamTypeDescr ))
@@ -216,9 +216,9 @@ static typelib_TypeClass cpp2uno_call(
                                 uno_copyAndConvertData( pUnoArgs[nPos] = __builtin_alloca( pParamTypeDescr->nSize ),
                                                                                 pCppStack, pParamTypeDescr,
                                                                                 pThis->getBridge()->getCpp2Uno() );
-                                pTempIndizes[nTempIndizes] = nPos; // has to be reconverted
+                                pTempIndices[nTempIndices] = nPos; // has to be reconverted
                                 // will be released at reconversion
-                                ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+                                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
                         }
                         else // direct way
                         {
@@ -241,13 +241,13 @@ static typelib_TypeClass cpp2uno_call(
         if (pUnoExc)
         {
                 // destruct temporary in/inout params
-                for ( ; nTempIndizes--; )
+                for ( ; nTempIndices--; )
                 {
-                        sal_Int32 nIndex = pTempIndizes[nTempIndizes];
+                        sal_Int32 nIndex = pTempIndices[nTempIndices];
 
                         if (pParams[nIndex].bIn) // is in/inout => was constructed
-                                uno_destructData( pUnoArgs[nIndex], ppTempParamTypeDescr[nTempIndizes], 0 );
-                        TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndizes] );
+                                uno_destructData( pUnoArgs[nIndex], ppTempParamTypeDescr[nTempIndices], 0 );
+                        TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndices] );
                 }
                 if (pReturnTypeDescr)
                         TYPELIB_DANGER_RELEASE( pReturnTypeDescr );
@@ -261,10 +261,10 @@ static typelib_TypeClass cpp2uno_call(
         else // else no exception occurred...
         {
                 // temporary params
-                for ( ; nTempIndizes--; )
+                for ( ; nTempIndices--; )
                 {
-                        sal_Int32 nIndex = pTempIndizes[nTempIndizes];
-                        typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndizes];
+                        sal_Int32 nIndex = pTempIndices[nTempIndices];
+                        typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndices];
 
                         if (pParams[nIndex].bOut) // inout/out
                         {
diff --git a/bridges/source/cpp_uno/gcc3_aix_powerpc/uno2cpp.cxx b/bridges/source/cpp_uno/gcc3_aix_powerpc/uno2cpp.cxx
index aa7a279582f5..f59cd968fa78 100644
--- a/bridges/source/cpp_uno/gcc3_aix_powerpc/uno2cpp.cxx
+++ b/bridges/source/cpp_uno/gcc3_aix_powerpc/uno2cpp.cxx
@@ -207,12 +207,12 @@ static void cpp_call(
         OSL_ENSURE( sizeof(void *) == sizeof(sal_Int32), "### unexpected size!" );
         // args
         void ** pCppArgs  = (void **)__builtin_alloca( 3 * sizeof(void *) * nParams );
-        // indizes of values this have to be converted (interface conversion cpp<=>uno)
-        sal_Int32 * pTempIndizes = (sal_Int32 *)(pCppArgs + nParams);
+        // indices of values this have to be converted (interface conversion cpp<=>uno)
+        sal_Int32 * pTempIndices = (sal_Int32 *)(pCppArgs + nParams);
         // type descriptions for reconversions
         typelib_TypeDescription ** ppTempParamTypeDescr = (typelib_TypeDescription **)(pCppArgs + (2 * nParams));
 
-        sal_Int32 nTempIndizes   = 0;
+        sal_Int32 nTempIndices   = 0;
 
         for ( sal_Int32 nPos = 0; nPos < nParams; ++nPos )
         {
@@ -267,9 +267,9 @@ static void cpp_call(
                                 uno_constructData(
                                         pCppArgs[nPos] = __builtin_alloca( pParamTypeDescr->nSize ),
                                         pParamTypeDescr );
-                                pTempIndizes[nTempIndizes] = nPos; // default constructed for cpp call
+                                pTempIndices[nTempIndices] = nPos; // default constructed for cpp call
                                 // will be released at reconversion
-                                ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+                                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
                         }
                         // is in/inout
                         else if (bridges::cpp_uno::shared::relatesToInterfaceType( pParamTypeDescr ))
@@ -278,9 +278,9 @@ static void cpp_call(
                                         pCppArgs[nPos] = __builtin_alloca( pParamTypeDescr->nSize ),
                                         pUnoArgs[nPos], pParamTypeDescr, pThis->getBridge()->getUno2Cpp() );
 
-                                pTempIndizes[nTempIndizes] = nPos; // has to be reconverted
+                                pTempIndices[nTempIndices] = nPos; // has to be reconverted
                                 // will be released at reconversion
-                                ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+                                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
                         }
                         else // direct way
                         {
@@ -303,10 +303,10 @@ static void cpp_call(
                 *ppUnoExc = 0;
 
                 // reconvert temporary params
-                for ( ; nTempIndizes--; )
+                for ( ; nTempIndices--; )
                 {
-                        sal_Int32 nIndex = pTempIndizes[nTempIndizes];
-                        typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndizes];
+                        sal_Int32 nIndex = pTempIndices[nTempIndices];
+                        typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndices];
 
                         if (pParams[nIndex].bIn)
                         {
@@ -341,12 +341,12 @@ static void cpp_call(
                 fillUnoException( CPPU_CURRENT_NAMESPACE::__cxa_get_globals()->caughtExceptions, *ppUnoExc, pThis->getBridge()->getCpp2Uno() );
 
                 // temporary params
-                for ( ; nTempIndizes--; )
+                for ( ; nTempIndices--; )
                 {
-                        sal_Int32 nIndex = pTempIndizes[nTempIndizes];
+                        sal_Int32 nIndex = pTempIndices[nTempIndices];
                         // destroy temp cpp param => cpp: every param was constructed
-                        uno_destructData( pCppArgs[nIndex], ppTempParamTypeDescr[nTempIndizes], cpp_release );
-                        TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndizes] );
+                        uno_destructData( pCppArgs[nIndex], ppTempParamTypeDescr[nTempIndices], cpp_release );
+                        TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndices] );
                 }
                 // return type
                 if (pReturnTypeDescr)
diff --git a/bridges/source/cpp_uno/gcc3_ios_arm/cpp2uno-arm.cxx b/bridges/source/cpp_uno/gcc3_ios_arm/cpp2uno-arm.cxx
index 78a0d3e83aea..301efd164736 100644
--- a/bridges/source/cpp_uno/gcc3_ios_arm/cpp2uno-arm.cxx
+++ b/bridges/source/cpp_uno/gcc3_ios_arm/cpp2uno-arm.cxx
@@ -99,14 +99,14 @@ namespace
         // parameters
         void ** pUnoArgs = (void **)alloca( 4 * sizeof(void *) * nParams );
         void ** pCppArgs = pUnoArgs + nParams;
-        // indizes of values this have to be converted (interface conversion
+        // indices of values this have to be converted (interface conversion
         // cpp<=>uno)
-        sal_Int32 * pTempIndizes = (sal_Int32 *)(pUnoArgs + (2 * nParams));
+        sal_Int32 * pTempIndices = (sal_Int32 *)(pUnoArgs + (2 * nParams));
         // type descriptions for reconversions
         typelib_TypeDescription ** ppTempParamTypeDescr =
             (typelib_TypeDescription **)(pUnoArgs + (3 * nParams));
 
-        sal_Int32 nTempIndizes   = 0;
+        sal_Int32 nTempIndices   = 0;
 
         for ( sal_Int32 nPos = 0; nPos < nParams; ++nPos )
         {
@@ -176,9 +176,9 @@ namespace
                 {
                     // uno out is unconstructed mem!
                     pUnoArgs[nPos] = alloca( pParamTypeDescr->nSize );
-                    pTempIndizes[nTempIndizes] = nPos;
+                    pTempIndices[nTempIndices] = nPos;
                     // will be released at reconversion
-                    ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+                    ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
                 }
                 // is in/inout
                 else if (bridges::cpp_uno::shared::relatesToInterfaceType(
@@ -188,9 +188,9 @@ namespace
                         alloca( pParamTypeDescr->nSize ),
                         *(void **)pCppStack, pParamTypeDescr,
                         pThis->getBridge()->getCpp2Uno() );
-                    pTempIndizes[nTempIndizes] = nPos; // has to be reconverted
+                    pTempIndices[nTempIndices] = nPos; // has to be reconverted
                     // will be released at reconversion
-                    ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+                    ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
                 }
                 else // direct way
                 {
@@ -221,14 +221,14 @@ namespace
         if (pUnoExc)
         {
             // destruct temporary in/inout params
-            for ( ; nTempIndizes--; )
+            for ( ; nTempIndices--; )
             {
-                sal_Int32 nIndex = pTempIndizes[nTempIndizes];
+                sal_Int32 nIndex = pTempIndices[nTempIndices];
 
                 if (pParams[nIndex].bIn) // is in/inout => was constructed
                     uno_destructData( pUnoArgs[nIndex],
-                        ppTempParamTypeDescr[nTempIndizes], 0 );
-                TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndizes] );
+                        ppTempParamTypeDescr[nTempIndices], 0 );
+                TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndices] );
             }
             if (pReturnTypeDescr)
                 TYPELIB_DANGER_RELEASE( pReturnTypeDescr );
@@ -241,11 +241,11 @@ namespace
         else // else no exception occurred...
         {
             // temporary params
-            for ( ; nTempIndizes--; )
+            for ( ; nTempIndices--; )
             {
-                sal_Int32 nIndex = pTempIndizes[nTempIndizes];
+                sal_Int32 nIndex = pTempIndices[nTempIndices];
                 typelib_TypeDescription * pParamTypeDescr =
-                    ppTempParamTypeDescr[nTempIndizes];
+                    ppTempParamTypeDescr[nTempIndices];
 
                 if (pParams[nIndex].bOut) // inout/out
                 {
diff --git a/bridges/source/cpp_uno/gcc3_ios_arm/cpp2uno-i386.cxx b/bridges/source/cpp_uno/gcc3_ios_arm/cpp2uno-i386.cxx
index 1c9bfab206dd..8ff236bb9893 100644
--- a/bridges/source/cpp_uno/gcc3_ios_arm/cpp2uno-i386.cxx
+++ b/bridges/source/cpp_uno/gcc3_ios_arm/cpp2uno-i386.cxx
@@ -96,12 +96,12 @@ void cpp2uno_call(
     // parameters
     void ** pUnoArgs = (void **)alloca( 4 * sizeof(void *) * nParams );
     void ** pCppArgs = pUnoArgs + nParams;
-    // indizes of values this have to be converted (interface conversion cpp<=>uno)
-    sal_Int32 * pTempIndizes = (sal_Int32 *)(pUnoArgs + (2 * nParams));
+    // indices of values this have to be converted (interface conversion cpp<=>uno)
+    sal_Int32 * pTempIndices = (sal_Int32 *)(pUnoArgs + (2 * nParams));
     // type descriptions for reconversions
     typelib_TypeDescription ** ppTempParamTypeDescr = (typelib_TypeDescription **)(pUnoArgs + (3 * nParams));
 
-    sal_Int32 nTempIndizes   = 0;
+    sal_Int32 nTempIndices   = 0;
 
     for ( sal_Int32 nPos = 0; nPos < nParams; ++nPos )
     {
@@ -135,9 +135,9 @@ void cpp2uno_call(
             {
                 // uno out is unconstructed mem!
                 pUnoArgs[nPos] = alloca( pParamTypeDescr->nSize );
-                pTempIndizes[nTempIndizes] = nPos;
+                pTempIndices[nTempIndices] = nPos;
                 // will be released at reconversion
-                ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
             }
             // is in/inout
             else if (bridges::cpp_uno::shared::relatesToInterfaceType(
@@ -146,9 +146,9 @@ void cpp2uno_call(
                 uno_copyAndConvertData( pUnoArgs[nPos] = alloca( pParamTypeDescr->nSize ),
                                         *(void **)pCppStack, pParamTypeDescr,
                                         pThis->getBridge()->getCpp2Uno() );
-                pTempIndizes[nTempIndizes] = nPos; // has to be reconverted
+                pTempIndices[nTempIndices] = nPos; // has to be reconverted
                 // will be released at reconversion
-                ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
             }
             else // direct way
             {
@@ -172,13 +172,13 @@ void cpp2uno_call(
     if (pUnoExc)
     {
         // destruct temporary in/inout params
-        for ( ; nTempIndizes--; )
+        for ( ; nTempIndices--; )
         {
-            sal_Int32 nIndex = pTempIndizes[nTempIndizes];
+            sal_Int32 nIndex = pTempIndices[nTempIndices];
 
             if (pParams[nIndex].bIn) // is in/inout => was constructed
-                uno_destructData( pUnoArgs[nIndex], ppTempParamTypeDescr[nTempIndizes], 0 );
-            TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndizes] );
+                uno_destructData( pUnoArgs[nIndex], ppTempParamTypeDescr[nTempIndices], 0 );
+            TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndices] );
         }
         if (pReturnTypeDescr)
             TYPELIB_DANGER_RELEASE( pReturnTypeDescr );
@@ -190,10 +190,10 @@ void cpp2uno_call(
     else // else no exception occurred...
     {
         // temporary params
-        for ( ; nTempIndizes--; )
+        for ( ; nTempIndices--; )
         {
-            sal_Int32 nIndex = pTempIndizes[nTempIndizes];
-            typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndizes];
+            sal_Int32 nIndex = pTempIndices[nTempIndices];
+            typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndices];
 
             if (pParams[nIndex].bOut) // inout/out
             {
diff --git a/bridges/source/cpp_uno/gcc3_ios_arm/uno2cpp-arm.cxx b/bridges/source/cpp_uno/gcc3_ios_arm/uno2cpp-arm.cxx
index cef2ecf740a3..c9d917a62daf 100644
--- a/bridges/source/cpp_uno/gcc3_ios_arm/uno2cpp-arm.cxx
+++ b/bridges/source/cpp_uno/gcc3_ios_arm/uno2cpp-arm.cxx
@@ -393,12 +393,12 @@ static void cpp_call(
     OSL_ENSURE( sizeof(void *) == sizeof(sal_Int32), "### unexpected size!" );
     // args
     void ** pCppArgs  = (void **)alloca( 3 * sizeof(void *) * nParams );
-    // indizes of values this have to be converted (interface conversion cpp<=>uno)
-    sal_Int32 * pTempIndizes = (sal_Int32 *)(pCppArgs + nParams);
+    // indices of values this have to be converted (interface conversion cpp<=>uno)
+    sal_Int32 * pTempIndices = (sal_Int32 *)(pCppArgs + nParams);
     // type descriptions for reconversions
     typelib_TypeDescription ** ppTempParamTypeDescr = (typelib_TypeDescription **)(pCppArgs + (2 * nParams));
 
-    sal_Int32 nTempIndizes   = 0;
+    sal_Int32 nTempIndices   = 0;
 
     for ( sal_Int32 nPos = 0; nPos < nParams; ++nPos )
     {
@@ -458,9 +458,9 @@ static void cpp_call(
                 uno_constructData(
                     pCppArgs[nPos] = alloca( pParamTypeDescr->nSize ),
                     pParamTypeDescr );
-                pTempIndizes[nTempIndizes] = nPos; // default constructed for cpp call
+                pTempIndices[nTempIndices] = nPos; // default constructed for cpp call
                 // will be released at reconversion
-                ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
             }
             // is in/inout
             else if (bridges::cpp_uno::shared::relatesToInterfaceType( pParamTypeDescr ))
@@ -469,9 +469,9 @@ static void cpp_call(
                     pCppArgs[nPos] = alloca( pParamTypeDescr->nSize ),
                     pUnoArgs[nPos], pParamTypeDescr, pThis->getBridge()->getUno2Cpp() );
 
-                pTempIndizes[nTempIndizes] = nPos; // has to be reconverted
+                pTempIndices[nTempIndices] = nPos; // has to be reconverted
                 // will be released at reconversion
-                ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
             }
             else // direct way
             {
@@ -497,10 +497,10 @@ static void cpp_call(
         *ppUnoExc = 0;
 
         // reconvert temporary params
-        for ( ; nTempIndizes--; )
+        for ( ; nTempIndices--; )
         {
-            sal_Int32 nIndex = pTempIndizes[nTempIndizes];
-            typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndizes];
+            sal_Int32 nIndex = pTempIndices[nTempIndices];
+            typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndices];
 
             if (pParams[nIndex].bIn)
             {
@@ -537,12 +537,12 @@ static void cpp_call(
         CPPU_CURRENT_NAMESPACE::fillUnoException( abi::__cxa_get_globals()->caughtExceptions, *ppUnoExc, pThis->getBridge()->getCpp2Uno() );
 
         // temporary params
-        for ( ; nTempIndizes--; )
+        for ( ; nTempIndices--; )
         {
-            sal_Int32 nIndex = pTempIndizes[nTempIndizes];
+            sal_Int32 nIndex = pTempIndices[nTempIndices];
             // destroy temp cpp param => cpp: every param was constructed
-            uno_destructData( pCppArgs[nIndex], ppTempParamTypeDescr[nTempIndizes], cpp_release );
-            TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndizes] );
+            uno_destructData( pCppArgs[nIndex], ppTempParamTypeDescr[nTempIndices], cpp_release );
+            TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndices] );
         }
 
         // return type
diff --git a/bridges/source/cpp_uno/gcc3_ios_arm/uno2cpp-i386.cxx b/bridges/source/cpp_uno/gcc3_ios_arm/uno2cpp-i386.cxx
index 5846f5d1fe20..65f32e7e6a62 100644
--- a/bridges/source/cpp_uno/gcc3_ios_arm/uno2cpp-i386.cxx
+++ b/bridges/source/cpp_uno/gcc3_ios_arm/uno2cpp-i386.cxx
@@ -194,12 +194,12 @@ static void cpp_call(
     OSL_ENSURE( sizeof(void *) == sizeof(sal_Int32), "### unexpected size!" );
     // args
     void ** pCppArgs  = (void **)alloca( 3 * sizeof(void *) * nParams );
-    // indizes of values this have to be converted (interface conversion cpp<=>uno)
-    sal_Int32 * pTempIndizes = (sal_Int32 *)(pCppArgs + nParams);
+    // indices of values this have to be converted (interface conversion cpp<=>uno)
+    sal_Int32 * pTempIndices = (sal_Int32 *)(pCppArgs + nParams);
     // type descriptions for reconversions
     typelib_TypeDescription ** ppTempParamTypeDescr = (typelib_TypeDescription **)(pCppArgs + (2 * nParams));
 
-    sal_Int32 nTempIndizes   = 0;
+    sal_Int32 nTempIndices   = 0;
 
     for ( sal_Int32 nPos = 0; nPos < nParams; ++nPos )
     {
@@ -233,9 +233,9 @@ static void cpp_call(
                 uno_constructData(
                     *(void **)pCppStack = pCppArgs[nPos] = alloca( pParamTypeDescr->nSize ),
                     pParamTypeDescr );
-                pTempIndizes[nTempIndizes] = nPos; // default constructed for cpp call
+                pTempIndices[nTempIndices] = nPos; // default constructed for cpp call
                 // will be released at reconversion
-                ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
             }
             // is in/inout
             else if (bridges::cpp_uno::shared::relatesToInterfaceType(
@@ -246,9 +246,9 @@ static void cpp_call(
                     pUnoArgs[nPos], pParamTypeDescr,
                     pThis->getBridge()->getUno2Cpp() );
 
-                pTempIndizes[nTempIndizes] = nPos; // has to be reconverted
+                pTempIndices[nTempIndices] = nPos; // has to be reconverted
                 // will be released at reconversion
-                ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
             }
             else // direct way
             {
@@ -271,10 +271,10 @@ static void cpp_call(
         *ppUnoExc = 0;
 
         // reconvert temporary params
-        for ( ; nTempIndizes--; )
+        for ( ; nTempIndices--; )
         {
-            sal_Int32 nIndex = pTempIndizes[nTempIndizes];
-            typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndizes];
+            sal_Int32 nIndex = pTempIndices[nTempIndices];
+            typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndices];
 
             if (pParams[nIndex].bIn)
             {
@@ -312,12 +312,12 @@ static void cpp_call(
         CPPU_CURRENT_NAMESPACE::fillUnoException( abi::__cxa_get_globals()->caughtExceptions, *ppUnoExc, pThis->getBridge()->getCpp2Uno() );
 
         // temporary params
-        for ( ; nTempIndizes--; )
+        for ( ; nTempIndices--; )
         {
-            sal_Int32 nIndex = pTempIndizes[nTempIndizes];
+            sal_Int32 nIndex = pTempIndices[nTempIndices];
             // destroy temp cpp param => cpp: every param was constructed
-            uno_destructData( pCppArgs[nIndex], ppTempParamTypeDescr[nTempIndizes], cpp_release );
-            TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndizes] );
+            uno_destructData( pCppArgs[nIndex], ppTempParamTypeDescr[nTempIndices], cpp_release );
+            TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndices] );
         }
         // return type
         if (pReturnTypeDescr)
diff --git a/bridges/source/cpp_uno/gcc3_linux_alpha/cpp2uno.cxx b/bridges/source/cpp_uno/gcc3_linux_alpha/cpp2uno.cxx
index ca05bb0ae1b4..0705789a2e50 100644
--- a/bridges/source/cpp_uno/gcc3_linux_alpha/cpp2uno.cxx
+++ b/bridges/source/cpp_uno/gcc3_linux_alpha/cpp2uno.cxx
@@ -92,12 +92,12 @@ static typelib_TypeClass cpp2uno_call(
     // parameters
     void ** pUnoArgs = (void **)alloca( 4 * sizeof(void *) * nParams );
     void ** pCppArgs = pUnoArgs + nParams;
-    // indizes of values this have to be converted (interface conversion cpp<=>uno)
-    sal_Int32 * pTempIndizes = (sal_Int32 *)(pUnoArgs + (2 * nParams));
+    // indices of values this have to be converted (interface conversion cpp<=>uno)
+    sal_Int32 * pTempIndices = (sal_Int32 *)(pUnoArgs + (2 * nParams));
     // type descriptions for reconversions
     typelib_TypeDescription ** ppTempParamTypeDescr = (typelib_TypeDescription **)(pUnoArgs + (3 * nParams));
 
-    sal_Int32 nTempIndizes   = 0;
+    sal_Int32 nTempIndices   = 0;
     for ( sal_Int32 nPos = 0; nPos < nParams; ++nPos )
     {
         const typelib_MethodParameter & rParam = pParams[nPos];
@@ -228,9 +228,9 @@ static typelib_TypeClass cpp2uno_call(
             {
                 // uno out is unconstructed mem!
                 pUnoArgs[nPos] = alloca( pParamTypeDescr->nSize );
-                pTempIndizes[nTempIndizes] = nPos;
+                pTempIndices[nTempIndices] = nPos;
                 // will be released at reconversion
-                ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
             }
             // is in/inout
             else if (bridges::cpp_uno::shared::relatesToInterfaceType( pParamTypeDescr ))
@@ -238,9 +238,9 @@ static typelib_TypeClass cpp2uno_call(
                 uno_copyAndConvertData( pUnoArgs[nPos] = alloca( pParamTypeDescr->nSize ),
                                         pCppStack, pParamTypeDescr,
                                         pThis->getBridge()->getCpp2Uno() );
-                pTempIndizes[nTempIndizes] = nPos; // has to be reconverted
+                pTempIndices[nTempIndices] = nPos; // has to be reconverted
                 // will be released at reconversion
-                ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
             }
             else // direct way
             {
@@ -266,13 +266,13 @@ static typelib_TypeClass cpp2uno_call(
     if (pUnoExc)
     {
         // destruct temporary in/inout params
-        for ( ; nTempIndizes--; )
+        for ( ; nTempIndices--; )
         {
-            sal_Int32 nIndex = pTempIndizes[nTempIndizes];
+            sal_Int32 nIndex = pTempIndices[nTempIndices];
 
             if (pParams[nIndex].bIn) // is in/inout => was constructed
-                uno_destructData( pUnoArgs[nIndex], ppTempParamTypeDescr[nTempIndizes], 0 );
-            TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndizes] );
+                uno_destructData( pUnoArgs[nIndex], ppTempParamTypeDescr[nTempIndices], 0 );
+            TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndices] );
         }
         if (pReturnTypeDescr)
             TYPELIB_DANGER_RELEASE( pReturnTypeDescr );
@@ -284,10 +284,10 @@ static typelib_TypeClass cpp2uno_call(
     else // else no exception occurred...
     {
         // temporary params
-        for ( ; nTempIndizes--; )
+        for ( ; nTempIndices--; )
         {
-            sal_Int32 nIndex = pTempIndizes[nTempIndizes];
-            typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndizes];
+            sal_Int32 nIndex = pTempIndices[nTempIndices];
+            typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndices];
 
             if (pParams[nIndex].bOut) // inout/out
             {
diff --git a/bridges/source/cpp_uno/gcc3_linux_alpha/uno2cpp.cxx b/bridges/source/cpp_uno/gcc3_linux_alpha/uno2cpp.cxx
index 522f4c50373f..4ac41e574309 100644
--- a/bridges/source/cpp_uno/gcc3_linux_alpha/uno2cpp.cxx
+++ b/bridges/source/cpp_uno/gcc3_linux_alpha/uno2cpp.cxx
@@ -239,12 +239,12 @@ static void cpp_call(
     OSL_ENSURE( sizeof(void *) == sizeof(sal_Int64), "### unexpected size!" );
     // args
     void ** pCppArgs  = (void **)alloca( 3 * sizeof(void *) * nParams );
-    // indizes of values this have to be converted (interface conversion cpp<=>uno)
-    sal_Int32 * pTempIndizes = (sal_Int32 *)(pCppArgs + nParams);
+    // indices of values this have to be converted (interface conversion cpp<=>uno)
+    sal_Int32 * pTempIndices = (sal_Int32 *)(pCppArgs + nParams);
     // type descriptions for reconversions
     typelib_TypeDescription ** ppTempParamTypeDescr = (typelib_TypeDescription **)(pCppArgs + (2 * nParams));
 
-    sal_Int32 nTempIndizes   = 0;
+    sal_Int32 nTempIndices   = 0;
 
     for ( sal_Int32 nPos = 0; nPos < nParams; ++nPos )
     {
@@ -298,9 +298,9 @@ static void cpp_call(
                 uno_constructData(
                     pCppArgs[nPos] = alloca( pParamTypeDescr->nSize ),
                     pParamTypeDescr );
-                pTempIndizes[nTempIndizes] = nPos; // default constructed for cpp call
+                pTempIndices[nTempIndices] = nPos; // default constructed for cpp call
                 // will be released at reconversion
-                ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
             }
             // is in/inout
             else if (bridges::cpp_uno::shared::relatesToInterfaceType( pParamTypeDescr ))
@@ -309,9 +309,9 @@ static void cpp_call(
                     pCppArgs[nPos] = alloca( pParamTypeDescr->nSize ),
                     pUnoArgs[nPos], pParamTypeDescr, pThis->getBridge()->getUno2Cpp() );
 
-                pTempIndizes[nTempIndizes] = nPos; // has to be reconverted
+                pTempIndices[nTempIndices] = nPos; // has to be reconverted
                 // will be released at reconversion
-                ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
             }
             else // direct way
             {
@@ -335,10 +335,10 @@ static void cpp_call(
         *ppUnoExc = 0;
 
         // reconvert temporary params
-        for ( ; nTempIndizes--; )
+        for ( ; nTempIndices--; )
         {
-            sal_Int32 nIndex = pTempIndizes[nTempIndizes];
-            typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndizes];
+            sal_Int32 nIndex = pTempIndices[nTempIndices];
+            typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndices];
 
             if (pParams[nIndex].bIn)
             {
@@ -375,12 +375,12 @@ static void cpp_call(
 
 
         // temporary params
-        for ( ; nTempIndizes--; )
+        for ( ; nTempIndices--; )
         {
-            sal_Int32 nIndex = pTempIndizes[nTempIndizes];
+            sal_Int32 nIndex = pTempIndices[nTempIndices];
             // destroy temp cpp param => cpp: every param was constructed
-            uno_destructData( pCppArgs[nIndex], ppTempParamTypeDescr[nTempIndizes], cpp_release );
-            TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndizes] );
+            uno_destructData( pCppArgs[nIndex], ppTempParamTypeDescr[nTempIndices], cpp_release );
+            TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndices] );
         }
         // return type
         if (pReturnTypeDescr)
diff --git a/bridges/source/cpp_uno/gcc3_linux_arm/cpp2uno.cxx b/bridges/source/cpp_uno/gcc3_linux_arm/cpp2uno.cxx
index 61d0fe5795a8..c9a114a9972a 100644
--- a/bridges/source/cpp_uno/gcc3_linux_arm/cpp2uno.cxx
+++ b/bridges/source/cpp_uno/gcc3_linux_arm/cpp2uno.cxx
@@ -97,14 +97,14 @@ namespace
         // parameters
         void ** pUnoArgs = (void **)alloca( 4 * sizeof(void *) * nParams );
         void ** pCppArgs = pUnoArgs + nParams;
-        // indizes of values this have to be converted (interface conversion
+        // indices of values this have to be converted (interface conversion
         // cpp<=>uno)
-        sal_Int32 * pTempIndizes = (sal_Int32 *)(pUnoArgs + (2 * nParams));
+        sal_Int32 * pTempIndices = (sal_Int32 *)(pUnoArgs + (2 * nParams));
         // type descriptions for reconversions
         typelib_TypeDescription ** ppTempParamTypeDescr =
             (typelib_TypeDescription **)(pUnoArgs + (3 * nParams));
 
-        sal_Int32 nTempIndizes   = 0;
+        sal_Int32 nTempIndices   = 0;
 
         for ( sal_Int32 nPos = 0; nPos < nParams; ++nPos )
         {
@@ -174,9 +174,9 @@ namespace
                 {
                     // uno out is unconstructed mem!
                     pUnoArgs[nPos] = alloca( pParamTypeDescr->nSize );
-                    pTempIndizes[nTempIndizes] = nPos;
+                    pTempIndices[nTempIndices] = nPos;
                     // will be released at reconversion
-                    ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+                    ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
                 }
                 // is in/inout
                 else if (bridges::cpp_uno::shared::relatesToInterfaceType(
@@ -186,9 +186,9 @@ namespace
                         alloca( pParamTypeDescr->nSize ),
                         *(void **)pCppStack, pParamTypeDescr,
                         pThis->getBridge()->getCpp2Uno() );
-                    pTempIndizes[nTempIndizes] = nPos; // has to be reconverted
+                    pTempIndices[nTempIndices] = nPos; // has to be reconverted
                     // will be released at reconversion
-                    ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+                    ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
                 }
                 else // direct way
                 {
@@ -219,14 +219,14 @@ namespace
         if (pUnoExc)
         {
             // destruct temporary in/inout params
-            for ( ; nTempIndizes--; )
+            for ( ; nTempIndices--; )
             {
-                sal_Int32 nIndex = pTempIndizes[nTempIndizes];
+                sal_Int32 nIndex = pTempIndices[nTempIndices];
 
                 if (pParams[nIndex].bIn) // is in/inout => was constructed
                     uno_destructData( pUnoArgs[nIndex],
-                        ppTempParamTypeDescr[nTempIndizes], 0 );
-                TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndizes] );
+                        ppTempParamTypeDescr[nTempIndices], 0 );
+                TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndices] );
             }
             if (pReturnTypeDescr)
                 TYPELIB_DANGER_RELEASE( pReturnTypeDescr );
@@ -239,11 +239,11 @@ namespace
         else // else no exception occurred...
         {
             // temporary params
-            for ( ; nTempIndizes--; )
+            for ( ; nTempIndices--; )
             {
-                sal_Int32 nIndex = pTempIndizes[nTempIndizes];
+                sal_Int32 nIndex = pTempIndices[nTempIndices];
                 typelib_TypeDescription * pParamTypeDescr =
-                    ppTempParamTypeDescr[nTempIndizes];
+                    ppTempParamTypeDescr[nTempIndices];
 
                 if (pParams[nIndex].bOut) // inout/out
                 {
diff --git a/bridges/source/cpp_uno/gcc3_linux_arm/uno2cpp.cxx b/bridges/source/cpp_uno/gcc3_linux_arm/uno2cpp.cxx
index c2c7d28332c9..943cbd85e8a5 100644
--- a/bridges/source/cpp_uno/gcc3_linux_arm/uno2cpp.cxx
+++ b/bridges/source/cpp_uno/gcc3_linux_arm/uno2cpp.cxx
@@ -435,12 +435,12 @@ static void cpp_call(
     OSL_ENSURE( sizeof(void *) == sizeof(sal_Int32), "### unexpected size!" );
     // args
     void ** pCppArgs  = (void **)alloca( 3 * sizeof(void *) * nParams );
-    // indizes of values this have to be converted (interface conversion cpp<=>uno)
-    sal_Int32 * pTempIndizes = (sal_Int32 *)(pCppArgs + nParams);
+    // indices of values this have to be converted (interface conversion cpp<=>uno)
+    sal_Int32 * pTempIndices = (sal_Int32 *)(pCppArgs + nParams);
     // type descriptions for reconversions
     typelib_TypeDescription ** ppTempParamTypeDescr = (typelib_TypeDescription **)(pCppArgs + (2 * nParams));
 
-    sal_Int32 nTempIndizes   = 0;
+    sal_Int32 nTempIndices   = 0;
 
     for ( sal_Int32 nPos = 0; nPos < nParams; ++nPos )
     {
@@ -500,9 +500,9 @@ static void cpp_call(
                 uno_constructData(
                     pCppArgs[nPos] = alloca( pParamTypeDescr->nSize ),
                     pParamTypeDescr );
-                pTempIndizes[nTempIndizes] = nPos; // default constructed for cpp call
+                pTempIndices[nTempIndices] = nPos; // default constructed for cpp call
                 // will be released at reconversion
-                ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
             }
             // is in/inout
             else if (bridges::cpp_uno::shared::relatesToInterfaceType( pParamTypeDescr ))
@@ -511,9 +511,9 @@ static void cpp_call(
                     pCppArgs[nPos] = alloca( pParamTypeDescr->nSize ),
                     pUnoArgs[nPos], pParamTypeDescr, pThis->getBridge()->getUno2Cpp() );
 
-                pTempIndizes[nTempIndizes] = nPos; // has to be reconverted
+                pTempIndices[nTempIndices] = nPos; // has to be reconverted
                 // will be released at reconversion
-                ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
             }
             else // direct way
             {
@@ -539,10 +539,10 @@ static void cpp_call(
         *ppUnoExc = 0;
 
         // reconvert temporary params
-        for ( ; nTempIndizes--; )
+        for ( ; nTempIndices--; )
         {
-            sal_Int32 nIndex = pTempIndizes[nTempIndizes];
-            typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndizes];
+            sal_Int32 nIndex = pTempIndices[nTempIndices];
+            typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndices];
 
             if (pParams[nIndex].bIn)
             {
@@ -579,12 +579,12 @@ static void cpp_call(
         fillUnoException( CPPU_CURRENT_NAMESPACE::__cxa_get_globals()->caughtExceptions, *ppUnoExc, pThis->getBridge()->getCpp2Uno() );
 
         // temporary params
-        for ( ; nTempIndizes--; )
+        for ( ; nTempIndices--; )
         {
-            sal_Int32 nIndex = pTempIndizes[nTempIndizes];
+            sal_Int32 nIndex = pTempIndices[nTempIndices];
             // destroy temp cpp param => cpp: every param was constructed
-            uno_destructData( pCppArgs[nIndex], ppTempParamTypeDescr[nTempIndizes], cpp_release );
-            TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndizes] );
+            uno_destructData( pCppArgs[nIndex], ppTempParamTypeDescr[nTempIndices], cpp_release );
+            TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndices] );
         }
 
         // return type
diff --git a/bridges/source/cpp_uno/gcc3_linux_hppa/cpp2uno.cxx b/bridges/source/cpp_uno/gcc3_linux_hppa/cpp2uno.cxx
index 0befa137b699..065db3cd7ca4 100644
--- a/bridges/source/cpp_uno/gcc3_linux_hppa/cpp2uno.cxx
+++ b/bridges/source/cpp_uno/gcc3_linux_hppa/cpp2uno.cxx
@@ -99,14 +99,14 @@ namespace
         // parameters
         void ** pUnoArgs = (void **)alloca( 4 * sizeof(void *) * nParams );
         void ** pCppArgs = pUnoArgs + nParams;
-        // indizes of values this have to be converted (interface conversion
+        // indices of values this have to be converted (interface conversion
         // cpp<=>uno)
-        sal_Int32 * pTempIndizes = (sal_Int32 *)(pUnoArgs + (2 * nParams));
+        sal_Int32 * pTempIndices = (sal_Int32 *)(pUnoArgs + (2 * nParams));
         // type descriptions for reconversions
         typelib_TypeDescription ** ppTempParamTypeDescr =
             (typelib_TypeDescription **)(pUnoArgs + (3 * nParams));
 
-        sal_Int32 nTempIndizes   = 0;
+        sal_Int32 nTempIndices   = 0;
         bool bOverFlowUsed = false;
         for ( sal_Int32 nPos = 0; nPos < nParams; ++nPos )
         {
@@ -258,9 +258,9 @@ namespace
                 {
                     // uno out is unconstructed mem!
                     pUnoArgs[nPos] = alloca( pParamTypeDescr->nSize );
-                    pTempIndizes[nTempIndizes] = nPos;
+                    pTempIndices[nTempIndices] = nPos;
                     // will be released at reconversion
-                    ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+                    ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
                 }
                 // is in/inout
                 else if (bridges::cpp_uno::shared::relatesToInterfaceType(
@@ -269,9 +269,9 @@ namespace
                    uno_copyAndConvertData( pUnoArgs[nPos] = alloca( pParamTypeDescr->nSize ),
                         pCppStack, pParamTypeDescr,
                         pThis->getBridge()->getCpp2Uno() );
-                    pTempIndizes[nTempIndizes] = nPos; // has to be reconverted
+                    pTempIndices[nTempIndices] = nPos; // has to be reconverted
                     // will be released at reconversion
-                    ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+                    ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
                 }
                 else // direct way
                 {
@@ -301,14 +301,14 @@ namespace
         if (pUnoExc)
         {
             // destruct temporary in/inout params
-            for ( ; nTempIndizes--; )
+            for ( ; nTempIndices--; )
             {
-                sal_Int32 nIndex = pTempIndizes[nTempIndizes];
+                sal_Int32 nIndex = pTempIndices[nTempIndices];
 
                 if (pParams[nIndex].bIn) // is in/inout => was constructed
                     uno_destructData( pUnoArgs[nIndex],
-                        ppTempParamTypeDescr[nTempIndizes], 0 );
-                TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndizes] );
+                        ppTempParamTypeDescr[nTempIndices], 0 );
+                TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndices] );
             }
             if (pReturnTypeDescr)
                 TYPELIB_DANGER_RELEASE( pReturnTypeDescr );
@@ -321,11 +321,11 @@ namespace
         else // else no exception occurred...
         {
             // temporary params
-            for ( ; nTempIndizes--; )
+            for ( ; nTempIndices--; )
             {
-                sal_Int32 nIndex = pTempIndizes[nTempIndizes];
+                sal_Int32 nIndex = pTempIndices[nTempIndices];
                 typelib_TypeDescription * pParamTypeDescr =
-                    ppTempParamTypeDescr[nTempIndizes];
+                    ppTempParamTypeDescr[nTempIndices];
 
                 if (pParams[nIndex].bOut) // inout/out
                 {
diff --git a/bridges/source/cpp_uno/gcc3_linux_hppa/uno2cpp.cxx b/bridges/source/cpp_uno/gcc3_linux_hppa/uno2cpp.cxx
index 8475b2733b0f..f554a2cfad0e 100644
--- a/bridges/source/cpp_uno/gcc3_linux_hppa/uno2cpp.cxx
+++ b/bridges/source/cpp_uno/gcc3_linux_hppa/uno2cpp.cxx
@@ -217,12 +217,12 @@ static void cpp_call(
     OSL_ENSURE( sizeof(void *) == sizeof(sal_Int32), "### unexpected size!" );
     // args
     void ** pCppArgs  = (void **)alloca( 3 * sizeof(void *) * nParams );
-    // indizes of values this have to be converted (interface conversion cpp<=>uno)
-    sal_Int32 * pTempIndizes = (sal_Int32 *)(pCppArgs + nParams);
+    // indices of values this have to be converted (interface conversion cpp<=>uno)
+    sal_Int32 * pTempIndices = (sal_Int32 *)(pCppArgs + nParams);
     // type descriptions for reconversions
     typelib_TypeDescription ** ppTempParamTypeDescr = (typelib_TypeDescription **)(pCppArgs + (2 * nParams));
 
-    sal_Int32 nTempIndizes   = 0;
+    sal_Int32 nTempIndices   = 0;
 
     for ( sal_Int32 nPos = 0; nPos < nParams; ++nPos )
     {
@@ -281,9 +281,9 @@ static void cpp_call(
                 uno_constructData(
                     pCppArgs[nPos] = alloca( pParamTypeDescr->nSize ),
                     pParamTypeDescr );
-                pTempIndizes[nTempIndizes] = nPos; // default constructed for cpp call
+                pTempIndices[nTempIndices] = nPos; // default constructed for cpp call
                 // will be released at reconversion
-                ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
             }
             // is in/inout
             else if (bridges::cpp_uno::shared::relatesToInterfaceType( pParamTypeDescr ))
@@ -292,9 +292,9 @@ static void cpp_call(
                     pCppArgs[nPos] = alloca( pParamTypeDescr->nSize ),
                     pUnoArgs[nPos], pParamTypeDescr, pThis->getBridge()->getUno2Cpp() );
 
-                pTempIndizes[nTempIndizes] = nPos; // has to be reconverted
+                pTempIndices[nTempIndices] = nPos; // has to be reconverted
                 // will be released at reconversion
-                ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
             }
             else // direct way
             {
@@ -318,10 +318,10 @@ static void cpp_call(
         *ppUnoExc = 0;
 
         // reconvert temporary params
-        for ( ; nTempIndizes--; )
+        for ( ; nTempIndices--; )
         {
-            sal_Int32 nIndex = pTempIndizes[nTempIndizes];
-            typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndizes];
+            sal_Int32 nIndex = pTempIndices[nTempIndices];
+            typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndices];
 
             if (pParams[nIndex].bIn)
             {
@@ -356,12 +356,12 @@ static void cpp_call(
         fillUnoException( CPPU_CURRENT_NAMESPACE::__cxa_get_globals()->caughtExceptions, *ppUnoExc, pThis->getBridge()->getCpp2Uno() );
 
         // temporary params
-        for ( ; nTempIndizes--; )
+        for ( ; nTempIndices--; )
         {
-            sal_Int32 nIndex = pTempIndizes[nTempIndizes];
+            sal_Int32 nIndex = pTempIndices[nTempIndices];
             // destroy temp cpp param => cpp: every param was constructed
-            uno_destructData( pCppArgs[nIndex], ppTempParamTypeDescr[nTempIndizes], cpp_release );
-            TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndizes] );
+            uno_destructData( pCppArgs[nIndex], ppTempParamTypeDescr[nTempIndices], cpp_release );
+            TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndices] );
         }
 
         // return type
diff --git a/bridges/source/cpp_uno/gcc3_linux_ia64/cpp2uno.cxx b/bridges/source/cpp_uno/gcc3_linux_ia64/cpp2uno.cxx
index 8017045bcb7d..e3ece108f8b0 100644
--- a/bridges/source/cpp_uno/gcc3_linux_ia64/cpp2uno.cxx
+++ b/bridges/source/cpp_uno/gcc3_linux_ia64/cpp2uno.cxx
@@ -97,12 +97,12 @@ static typelib_TypeClass cpp2uno_call(
     // parameters
     void ** pUnoArgs = (void **)alloca( 4 * sizeof(void *) * nParams );
     void ** pCppArgs = pUnoArgs + nParams;
-    // indizes of values this have to be converted (interface conversion cpp<=>uno)
-    sal_Int32 * pTempIndizes = (sal_Int32 *)(pUnoArgs + (2 * nParams));
+    // indices of values this have to be converted (interface conversion cpp<=>uno)
+    sal_Int32 * pTempIndices = (sal_Int32 *)(pUnoArgs + (2 * nParams));
     // type descriptions for reconversions
     typelib_TypeDescription ** ppTempParamTypeDescr = (typelib_TypeDescription **)(pUnoArgs + (3 * nParams));
 
-    sal_Int32 nTempIndizes = 0;
+    sal_Int32 nTempIndices = 0;
     bool bOverFlowUsed = false;
     for ( sal_Int32 nPos = 0; nPos < nParams; ++nPos )
     {
@@ -204,9 +204,9 @@ static typelib_TypeClass cpp2uno_call(
             {
                 // uno out is unconstructed mem!
                 pUnoArgs[nPos] = alloca( pParamTypeDescr->nSize );
-                pTempIndizes[nTempIndizes] = nPos;
+                pTempIndices[nTempIndices] = nPos;
                 // will be released at reconversion
-                ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
             }
             // is in/inout
             else if (bridges::cpp_uno::shared::relatesToInterfaceType( pParamTypeDescr ))
@@ -214,9 +214,9 @@ static typelib_TypeClass cpp2uno_call(
                 uno_copyAndConvertData( pUnoArgs[nPos] = alloca( pParamTypeDescr->nSize ),
                                         pCppStack, pParamTypeDescr,
                                         pThis->getBridge()->getCpp2Uno() );
-                pTempIndizes[nTempIndizes] = nPos; // has to be reconverted
+                pTempIndices[nTempIndices] = nPos; // has to be reconverted
                 // will be released at reconversion
-                ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
             }
             else // direct way
             {
@@ -242,13 +242,13 @@ static typelib_TypeClass cpp2uno_call(
     if (pUnoExc)
     {
         // destruct temporary in/inout params
-        for ( ; nTempIndizes--; )
+        for ( ; nTempIndices--; )
         {
-            sal_Int32 nIndex = pTempIndizes[nTempIndizes];
+            sal_Int32 nIndex = pTempIndices[nTempIndices];
 
             if (pParams[nIndex].bIn) // is in/inout => was constructed
-                uno_destructData( pUnoArgs[nIndex], ppTempParamTypeDescr[nTempIndizes], 0 );
-            TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndizes] );
+                uno_destructData( pUnoArgs[nIndex], ppTempParamTypeDescr[nTempIndices], 0 );
+            TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndices] );
         }
         if (pReturnTypeDescr)
             TYPELIB_DANGER_RELEASE( pReturnTypeDescr );
@@ -261,10 +261,10 @@ static typelib_TypeClass cpp2uno_call(
     else // else no exception occurred...
     {
         // temporary params
-        for ( ; nTempIndizes--; )
+        for ( ; nTempIndices--; )
         {
-            sal_Int32 nIndex = pTempIndizes[nTempIndizes];
-            typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndizes];
+            sal_Int32 nIndex = pTempIndices[nTempIndices];
+            typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndices];
 
             if (pParams[nIndex].bOut) // inout/out
             {
diff --git a/bridges/source/cpp_uno/gcc3_linux_ia64/uno2cpp.cxx b/bridges/source/cpp_uno/gcc3_linux_ia64/uno2cpp.cxx
index b7b0020e1f98..177be5224b2e 100644
--- a/bridges/source/cpp_uno/gcc3_linux_ia64/uno2cpp.cxx
+++ b/bridges/source/cpp_uno/gcc3_linux_ia64/uno2cpp.cxx
@@ -361,12 +361,12 @@ static void cpp_call(
 
         // Args
         void ** pCppArgs = (void **)alloca( 3 * sizeof(void *) * nParams );
-    // indizes of values this have to be converted (interface conversion cpp<=>uno)
-    sal_Int32 * pTempIndizes = (sal_Int32 *)(pCppArgs + nParams);
+    // indices of values this have to be converted (interface conversion cpp<=>uno)
+    sal_Int32 * pTempIndices = (sal_Int32 *)(pCppArgs + nParams);
     // type descriptions for reconversions
     typelib_TypeDescription ** ppTempParamTypeDescr = (typelib_TypeDescription **)(pCppArgs + (2 * nParams));
 
-    sal_Int32 nTempIndizes   = 0;
+    sal_Int32 nTempIndices   = 0;
 
 #if OSL_DEBUG_LEVEL > 2
     fprintf(stderr, "n params is %d\n", nParams);
@@ -455,9 +455,9 @@ static void cpp_call(
                                 uno_constructData(
                                         pCppArgs[nPos] = alloca( pParamTypeDescr->nSize ),
                                         pParamTypeDescr );
-                                pTempIndizes[nTempIndizes] = nPos; // default constructed for cpp call
+                                pTempIndices[nTempIndices] = nPos; // default constructed for cpp call
                                 // will be released at reconversion
-                                ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+                                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
                         }
                         // is in/inout
                         else if (bridges::cpp_uno::shared::relatesToInterfaceType( pParamTypeDescr ))
@@ -469,9 +469,9 @@ static void cpp_call(
                                         pCppArgs[nPos] = alloca( pParamTypeDescr->nSize ),
                                         pUnoArgs[nPos], pParamTypeDescr, pThis->getBridge()->getUno2Cpp() );
 
-                                pTempIndizes[nTempIndizes] = nPos; // has to be reconverted
+                                pTempIndices[nTempIndices] = nPos; // has to be reconverted
                                 // will be released at reconversion
-                                ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+                                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
                         }
                         else // direct way
                         {
@@ -498,10 +498,10 @@ static void cpp_call(
         *ppUnoExc = 0;
 
         // reconvert temporary params
-        for ( ; nTempIndizes--; )
+        for ( ; nTempIndices--; )
         {
-            sal_Int32 nIndex = pTempIndizes[nTempIndizes];
-            typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndizes];
+            sal_Int32 nIndex = pTempIndices[nTempIndices];
+            typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndices];
 
             if (pParams[nIndex].bIn)
             {
@@ -537,12 +537,12 @@ static void cpp_call(
                                   *ppUnoExc, pThis->getBridge()->getCpp2Uno() );
 
         // temporary params
-        for ( ; nTempIndizes--; )
+        for ( ; nTempIndices--; )
         {
-            sal_Int32 nIndex = pTempIndizes[nTempIndizes];
+            sal_Int32 nIndex = pTempIndices[nTempIndices];
             // destroy temp cpp param => cpp: every param was constructed
-            uno_destructData( pCppArgs[nIndex], ppTempParamTypeDescr[nTempIndizes], cpp_release );
-            TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndizes] );
+            uno_destructData( pCppArgs[nIndex], ppTempParamTypeDescr[nTempIndices], cpp_release );
+            TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndices] );
         }
         // return type
         if (pReturnTypeDescr)
diff --git a/bridges/source/cpp_uno/gcc3_linux_intel/cpp2uno.cxx b/bridges/source/cpp_uno/gcc3_linux_intel/cpp2uno.cxx
index 665415290bcb..5a3fa81208bf 100644
--- a/bridges/source/cpp_uno/gcc3_linux_intel/cpp2uno.cxx
+++ b/bridges/source/cpp_uno/gcc3_linux_intel/cpp2uno.cxx
@@ -80,12 +80,12 @@ void cpp2uno_call(
     // parameters
     void ** pUnoArgs = (void **)alloca( 4 * sizeof(void *) * nParams );
     void ** pCppArgs = pUnoArgs + nParams;
-    // indizes of values this have to be converted (interface conversion cpp<=>uno)
-    sal_Int32 * pTempIndizes = (sal_Int32 *)(pUnoArgs + (2 * nParams));
+    // indices of values this have to be converted (interface conversion cpp<=>uno)
+    sal_Int32 * pTempIndices = (sal_Int32 *)(pUnoArgs + (2 * nParams));
     // type descriptions for reconversions
     typelib_TypeDescription ** ppTempParamTypeDescr = (typelib_TypeDescription **)(pUnoArgs + (3 * nParams));
 
-    sal_Int32 nTempIndizes   = 0;
+    sal_Int32 nTempIndices   = 0;
 
     for ( sal_Int32 nPos = 0; nPos < nParams; ++nPos )
     {
@@ -120,9 +120,9 @@ void cpp2uno_call(
             {
                 // uno out is unconstructed mem!
                 pUnoArgs[nPos] = alloca( pParamTypeDescr->nSize );
-                pTempIndizes[nTempIndizes] = nPos;
+                pTempIndices[nTempIndices] = nPos;
                 // will be released at reconversion
-                ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
             }
             // is in/inout
             else if (bridges::cpp_uno::shared::relatesToInterfaceType(
@@ -131,9 +131,9 @@ void cpp2uno_call(
                 uno_copyAndConvertData( pUnoArgs[nPos] = alloca( pParamTypeDescr->nSize ),
                                         *(void **)pCppStack, pParamTypeDescr,
                                         pThis->getBridge()->getCpp2Uno() );
-                pTempIndizes[nTempIndizes] = nPos; // has to be reconverted
+                pTempIndices[nTempIndices] = nPos; // has to be reconverted
                 // will be released at reconversion
-                ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
             }
             else // direct way
             {
@@ -157,13 +157,13 @@ void cpp2uno_call(
     if (pUnoExc)
     {
         // destruct temporary in/inout params
-        for ( ; nTempIndizes--; )
+        for ( ; nTempIndices--; )
         {
-            sal_Int32 nIndex = pTempIndizes[nTempIndizes];
+            sal_Int32 nIndex = pTempIndices[nTempIndices];
 
             if (pParams[nIndex].bIn) // is in/inout => was constructed
-                uno_destructData( pUnoArgs[nIndex], ppTempParamTypeDescr[nTempIndizes], 0 );
-            TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndizes] );
+                uno_destructData( pUnoArgs[nIndex], ppTempParamTypeDescr[nTempIndices], 0 );
+            TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndices] );
         }
         if (pReturnTypeDescr)
             TYPELIB_DANGER_RELEASE( pReturnTypeDescr );
@@ -175,10 +175,10 @@ void cpp2uno_call(
     else // else no exception occurred...
     {
         // temporary params
-        for ( ; nTempIndizes--; )
+        for ( ; nTempIndices--; )
         {
-            sal_Int32 nIndex = pTempIndizes[nTempIndizes];
-            typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndizes];
+            sal_Int32 nIndex = pTempIndices[nTempIndices];
+            typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndices];
 
             if (pParams[nIndex].bOut) // inout/out
             {
diff --git a/bridges/source/cpp_uno/gcc3_linux_intel/uno2cpp.cxx b/bridges/source/cpp_uno/gcc3_linux_intel/uno2cpp.cxx
index 55a1250f94cc..37605ca88886 100644
--- a/bridges/source/cpp_uno/gcc3_linux_intel/uno2cpp.cxx
+++ b/bridges/source/cpp_uno/gcc3_linux_intel/uno2cpp.cxx
@@ -90,12 +90,12 @@ static void cpp_call(
     OSL_ENSURE( sizeof(void *) == sizeof(sal_Int32), "### unexpected size!" );
     // args
     void ** pCppArgs  = (void **)alloca( 3 * sizeof(void *) * nParams );
-    // indizes of values this have to be converted (interface conversion cpp<=>uno)
-    sal_Int32 * pTempIndizes = (sal_Int32 *)(pCppArgs + nParams);
+    // indices of values this have to be converted (interface conversion cpp<=>uno)
+    sal_Int32 * pTempIndices = (sal_Int32 *)(pCppArgs + nParams);
     // type descriptions for reconversions
     typelib_TypeDescription ** ppTempParamTypeDescr = (typelib_TypeDescription **)(pCppArgs + (2 * nParams));
 
-    sal_Int32 nTempIndizes   = 0;
+    sal_Int32 nTempIndices   = 0;
 
     for ( sal_Int32 nPos = 0; nPos < nParams; ++nPos )
     {
@@ -130,9 +130,9 @@ static void cpp_call(
                 uno_constructData(
                     *(void **)pCppStack = pCppArgs[nPos] = alloca( pParamTypeDescr->nSize ),
                     pParamTypeDescr );
-                pTempIndizes[nTempIndizes] = nPos; // default constructed for cpp call
+                pTempIndices[nTempIndices] = nPos; // default constructed for cpp call
                 // will be released at reconversion
-                ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
             }
             // is in/inout
             else if (bridges::cpp_uno::shared::relatesToInterfaceType(
@@ -143,9 +143,9 @@ static void cpp_call(
                     pUnoArgs[nPos], pParamTypeDescr,
                     pThis->getBridge()->getUno2Cpp() );
 
-                pTempIndizes[nTempIndizes] = nPos; // has to be reconverted
+                pTempIndices[nTempIndices] = nPos; // has to be reconverted
                 // will be released at reconversion
-                ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
             }
             else // direct way
             {
@@ -168,10 +168,10 @@ static void cpp_call(
         *ppUnoExc = 0;
 
         // reconvert temporary params
-        for ( ; nTempIndizes--; )
+        for ( ; nTempIndices--; )
         {
-            sal_Int32 nIndex = pTempIndizes[nTempIndizes];
-            typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndizes];
+            sal_Int32 nIndex = pTempIndices[nTempIndices];
+            typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndices];
 
             if (pParams[nIndex].bIn)
             {
@@ -206,12 +206,12 @@ static void cpp_call(
         fillUnoException( __cxa_get_globals()->caughtExceptions, *ppUnoExc, pThis->getBridge()->getCpp2Uno() );
 
         // temporary params
-        for ( ; nTempIndizes--; )
+        for ( ; nTempIndices--; )
         {
-            sal_Int32 nIndex = pTempIndizes[nTempIndizes];
+            sal_Int32 nIndex = pTempIndices[nTempIndices];
             // destroy temp cpp param => cpp: every param was constructed
-            uno_destructData( pCppArgs[nIndex], ppTempParamTypeDescr[nTempIndizes], cpp_release );
-            TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndizes] );
+            uno_destructData( pCppArgs[nIndex], ppTempParamTypeDescr[nTempIndices], cpp_release );
+            TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndices] );
         }
         // return type
         if (pReturnTypeDescr)
diff --git a/bridges/source/cpp_uno/gcc3_linux_m68k/cpp2uno.cxx b/bridges/source/cpp_uno/gcc3_linux_m68k/cpp2uno.cxx
index 8d0ee8cfd10b..dd7f98c53f61 100644
--- a/bridges/source/cpp_uno/gcc3_linux_m68k/cpp2uno.cxx
+++ b/bridges/source/cpp_uno/gcc3_linux_m68k/cpp2uno.cxx
@@ -98,14 +98,14 @@ namespace
         // parameters
         void ** pUnoArgs = (void **)alloca( 4 * sizeof(void *) * nParams );
         void ** pCppArgs = pUnoArgs + nParams;
-        // indizes of values this have to be converted (interface conversion
+        // indices of values this have to be converted (interface conversion
         // cpp<=>uno)
-        sal_Int32 * pTempIndizes = (sal_Int32 *)(pUnoArgs + (2 * nParams));
+        sal_Int32 * pTempIndices = (sal_Int32 *)(pUnoArgs + (2 * nParams));
         // type descriptions for reconversions
         typelib_TypeDescription ** ppTempParamTypeDescr =
             (typelib_TypeDescription **)(pUnoArgs + (3 * nParams));
 
-        sal_Int32 nTempIndizes   = 0;
+        sal_Int32 nTempIndices   = 0;
 
         for ( sal_Int32 nPos = 0; nPos < nParams; ++nPos )
         {
@@ -152,9 +152,9 @@ namespace
                 {
                     // uno out is unconstructed mem!
                     pUnoArgs[nPos] = alloca( pParamTypeDescr->nSize );
-                    pTempIndizes[nTempIndizes] = nPos;
+                    pTempIndices[nTempIndices] = nPos;
                     // will be released at reconversion
-                    ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+                    ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
                 }
                 // is in/inout
                 else if (bridges::cpp_uno::shared::relatesToInterfaceType(
@@ -163,9 +163,9 @@ namespace
                    uno_copyAndConvertData( pUnoArgs[nPos] = alloca( pParamTypeDescr->nSize ),
                         *(void **)pCppStack, pParamTypeDescr,
                         pThis->getBridge()->getCpp2Uno() );
-                    pTempIndizes[nTempIndizes] = nPos; // has to be reconverted
+                    pTempIndices[nTempIndices] = nPos; // has to be reconverted
                     // will be released at reconversion
-                    ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+                    ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
                 }
                 else // direct way
                 {
@@ -196,14 +196,14 @@ namespace
         if (pUnoExc)
         {
             // destruct temporary in/inout params
-            for ( ; nTempIndizes--; )
+            for ( ; nTempIndices--; )
             {
-                sal_Int32 nIndex = pTempIndizes[nTempIndizes];
+                sal_Int32 nIndex = pTempIndices[nTempIndices];
 
                 if (pParams[nIndex].bIn) // is in/inout => was constructed
                     uno_destructData( pUnoArgs[nIndex],
-                        ppTempParamTypeDescr[nTempIndizes], 0 );
-                TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndizes] );
+                        ppTempParamTypeDescr[nTempIndices], 0 );
+                TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndices] );
             }
             if (pReturnTypeDescr)
                 TYPELIB_DANGER_RELEASE( pReturnTypeDescr );
@@ -216,11 +216,11 @@ namespace
         else // else no exception occurred...
         {
             // temporary params
-            for ( ; nTempIndizes--; )
+            for ( ; nTempIndices--; )
             {
-                sal_Int32 nIndex = pTempIndizes[nTempIndizes];
+                sal_Int32 nIndex = pTempIndices[nTempIndices];
                 typelib_TypeDescription * pParamTypeDescr =
-                    ppTempParamTypeDescr[nTempIndizes];
+                    ppTempParamTypeDescr[nTempIndices];
 
                 if (pParams[nIndex].bOut) // inout/out
                 {
diff --git a/bridges/source/cpp_uno/gcc3_linux_m68k/uno2cpp.cxx b/bridges/source/cpp_uno/gcc3_linux_m68k/uno2cpp.cxx
index ba66b6e0da9f..e8d5085572d8 100644
--- a/bridges/source/cpp_uno/gcc3_linux_m68k/uno2cpp.cxx
+++ b/bridges/source/cpp_uno/gcc3_linux_m68k/uno2cpp.cxx
@@ -197,12 +197,12 @@ static void cpp_call(
     OSL_ENSURE( sizeof(void *) == sizeof(sal_Int32), "### unexpected size!" );
     // args
     void ** pCppArgs  = (void **)alloca( 3 * sizeof(void *) * nParams );
-    // indizes of values this have to be converted (interface conversion cpp<=>uno)
-    sal_Int32 * pTempIndizes = (sal_Int32 *)(pCppArgs + nParams);
+    // indices of values this have to be converted (interface conversion cpp<=>uno)
+    sal_Int32 * pTempIndices = (sal_Int32 *)(pCppArgs + nParams);
     // type descriptions for reconversions
     typelib_TypeDescription ** ppTempParamTypeDescr = (typelib_TypeDescription **)(pCppArgs + (2 * nParams));
 
-    sal_Int32 nTempIndizes   = 0;
+    sal_Int32 nTempIndices   = 0;
 
     for ( sal_Int32 nPos = 0; nPos < nParams; ++nPos )
     {
@@ -260,9 +260,9 @@ static void cpp_call(
                 uno_constructData(
                     pCppArgs[nPos] = alloca( pParamTypeDescr->nSize ),
                     pParamTypeDescr );
-                pTempIndizes[nTempIndizes] = nPos; // default constructed for cpp call
+                pTempIndices[nTempIndices] = nPos; // default constructed for cpp call
                 // will be released at reconversion
-                ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
             }
             // is in/inout
             else if (bridges::cpp_uno::shared::relatesToInterfaceType( pParamTypeDescr ))
@@ -271,9 +271,9 @@ static void cpp_call(
                     pCppArgs[nPos] = alloca( pParamTypeDescr->nSize ),
                     pUnoArgs[nPos], pParamTypeDescr, pThis->getBridge()->getUno2Cpp() );
 
-                pTempIndizes[nTempIndizes] = nPos; // has to be reconverted
+                pTempIndices[nTempIndices] = nPos; // has to be reconverted
                 // will be released at reconversion
-                ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
             }
             else // direct way
             {
@@ -297,10 +297,10 @@ static void cpp_call(
         *ppUnoExc = 0;
 
         // reconvert temporary params
-        for ( ; nTempIndizes--; )
+        for ( ; nTempIndices--; )
         {
-            sal_Int32 nIndex = pTempIndizes[nTempIndizes];
-            typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndizes];
+            sal_Int32 nIndex = pTempIndices[nTempIndices];
+            typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndices];
 
             if (pParams[nIndex].bIn)
             {
@@ -335,12 +335,12 @@ static void cpp_call(
         fillUnoException( CPPU_CURRENT_NAMESPACE::__cxa_get_globals()->caughtExceptions, *ppUnoExc, pThis->getBridge()->getCpp2Uno() );
 
         // temporary params
-        for ( ; nTempIndizes--; )
+        for ( ; nTempIndices--; )
         {
-            sal_Int32 nIndex = pTempIndizes[nTempIndizes];
+            sal_Int32 nIndex = pTempIndices[nTempIndices];
             // destroy temp cpp param => cpp: every param was constructed
-            uno_destructData( pCppArgs[nIndex], ppTempParamTypeDescr[nTempIndizes], cpp_release );
-            TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndizes] );
+            uno_destructData( pCppArgs[nIndex], ppTempParamTypeDescr[nTempIndices], cpp_release );
+            TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndices] );
         }
 
         // return type
diff --git a/bridges/source/cpp_uno/gcc3_linux_mips/cpp2uno.cxx b/bridges/source/cpp_uno/gcc3_linux_mips/cpp2uno.cxx
index 970431fce11b..7a4a607c0a94 100644
--- a/bridges/source/cpp_uno/gcc3_linux_mips/cpp2uno.cxx
+++ b/bridges/source/cpp_uno/gcc3_linux_mips/cpp2uno.cxx
@@ -136,12 +136,12 @@ namespace
     // parameters
     void ** pUnoArgs = (void **)alloca( 4 * sizeof(void *) * nParams );
     void ** pCppArgs = pUnoArgs + nParams;
-    // indizes of values this have to be converted (interface conversion cpp<=>uno)
-    sal_Int32 * pTempIndizes = (sal_Int32 *)(pUnoArgs + (2 * nParams));
+    // indices of values this have to be converted (interface conversion cpp<=>uno)
+    sal_Int32 * pTempIndices = (sal_Int32 *)(pUnoArgs + (2 * nParams));
     // type descriptions for reconversions
     typelib_TypeDescription ** ppTempParamTypeDescr = (typelib_TypeDescription **)(pUnoArgs + (3 * nParams));
 
-    sal_Int32 nTempIndizes   = 0;
+    sal_Int32 nTempIndices   = 0;
 
 #ifdef BRDEBUG
     fprintf(stderr,"cpp2uno_call:nParams=%d\n",nParams);
@@ -269,9 +269,9 @@ namespace
         {
           // uno out is unconstructed mem!
           pUnoArgs[nPos] = alloca( pParamTypeDescr->nSize );
-          pTempIndizes[nTempIndizes] = nPos;
+          pTempIndices[nTempIndices] = nPos;
           // will be released at reconversion
-          ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+          ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
         }
         // is in/inout
         else if (bridges::cpp_uno::shared::relatesToInterfaceType( pParamTypeDescr ))
@@ -279,9 +279,9 @@ namespace
           uno_copyAndConvertData( pUnoArgs[nPos] = alloca( pParamTypeDescr->nSize ),
               *(void **)pCppStack, pParamTypeDescr,
               pThis->getBridge()->getCpp2Uno() );
-          pTempIndizes[nTempIndizes] = nPos; // has to be reconverted
+          pTempIndices[nTempIndices] = nPos; // has to be reconverted
           // will be released at reconversion
-          ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+          ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
 #ifdef BRDEBUG
     fprintf(stderr,"cpp2uno_call:related to interface,%p,%d,pUnoargs[%d]=%p\n",*(void**)pCppStack,pParamTypeDescr->nSize,nPos,pUnoArgs[nPos]);
 #endif
@@ -315,13 +315,13 @@ namespace
     if (pUnoExc)
     {
       // destruct temporary in/inout params
-      for ( ; nTempIndizes--; )
+      for ( ; nTempIndices--; )
       {
-        sal_Int32 nIndex = pTempIndizes[nTempIndizes];
+        sal_Int32 nIndex = pTempIndices[nTempIndices];
 
         if (pParams[nIndex].bIn) // is in/inout => was constructed
-          uno_destructData( pUnoArgs[nIndex], ppTempParamTypeDescr[nTempIndizes], 0 );
-        TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndizes] );
+          uno_destructData( pUnoArgs[nIndex], ppTempParamTypeDescr[nTempIndices], 0 );
+        TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndices] );
       }
       if (pReturnTypeDescr)
         TYPELIB_DANGER_RELEASE( pReturnTypeDescr );
@@ -334,10 +334,10 @@ namespace
     else // else no exception occurred...
     {
       // temporary params
-      for ( ; nTempIndizes--; )
+      for ( ; nTempIndices--; )
       {
-        sal_Int32 nIndex = pTempIndizes[nTempIndizes];
-        typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndizes];
+        sal_Int32 nIndex = pTempIndices[nTempIndices];
+        typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndices];
 
         if (pParams[nIndex].bOut) // inout/out
         {
diff --git a/bridges/source/cpp_uno/gcc3_linux_mips/uno2cpp.cxx b/bridges/source/cpp_uno/gcc3_linux_mips/uno2cpp.cxx
index 19f429491955..5984735ce4b6 100644
--- a/bridges/source/cpp_uno/gcc3_linux_mips/uno2cpp.cxx
+++ b/bridges/source/cpp_uno/gcc3_linux_mips/uno2cpp.cxx
@@ -286,12 +286,12 @@ namespace
     // OSL_ENSURE( sizeof(void *) == sizeof(sal_Int32), "### unexpected size!" );
     // args
     void ** pCppArgs  = (void **)alloca( 3 * sizeof(void *) * nParams );
-    // indizes of values this have to be converted (interface conversion cpp<=>uno)
-    sal_Int32 * pTempIndizes = (sal_Int32 *)(pCppArgs + nParams);
+    // indices of values this have to be converted (interface conversion cpp<=>uno)
+    sal_Int32 * pTempIndices = (sal_Int32 *)(pCppArgs + nParams);
     // type descriptions for reconversions
     typelib_TypeDescription ** ppTempParamTypeDescr = (typelib_TypeDescription **)(pCppArgs + (2 * nParams));
 
-    sal_Int32 nTempIndizes   = 0;
+    sal_Int32 nTempIndices   = 0;
 
     for ( sal_Int32 nPos = 0; nPos < nParams; ++nPos )
     {
@@ -358,9 +358,9 @@ namespace
           uno_constructData(
               *(void **)pCppStack = pCppArgs[nPos] = alloca( pParamTypeDescr->nSize ),
               pParamTypeDescr );
-          pTempIndizes[nTempIndizes] = nPos; // default constructed for cpp call
+          pTempIndices[nTempIndices] = nPos; // default constructed for cpp call
           // will be released at reconversion
-          ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+          ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
         }
         // is in/inout
         else if (bridges::cpp_uno::shared::relatesToInterfaceType( pParamTypeDescr ))
@@ -370,9 +370,9 @@ namespace
               pUnoArgs[nPos], pParamTypeDescr,
               pThis->getBridge()->getUno2Cpp() );
 
-          pTempIndizes[nTempIndizes] = nPos; // has to be reconverted
+          pTempIndices[nTempIndices] = nPos; // has to be reconverted
           // will be released at reconversion
-          ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+          ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
         }
         else // direct way
         {
@@ -401,10 +401,10 @@ namespace
       *ppUnoExc = 0;
 
       // reconvert temporary params
-      for ( ; nTempIndizes--; )
+      for ( ; nTempIndices--; )
       {
-        sal_Int32 nIndex = pTempIndizes[nTempIndizes];
-        typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndizes];
+        sal_Int32 nIndex = pTempIndices[nTempIndices];
+        typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndices];
 
         if (pParams[nIndex].bIn)
         {
@@ -440,12 +440,12 @@ namespace
           *ppUnoExc, pThis->getBridge()->getCpp2Uno() );
 
       // temporary params
-      for ( ; nTempIndizes--; )
+      for ( ; nTempIndices--; )
       {
-        sal_Int32 nIndex = pTempIndizes[nTempIndizes];
+        sal_Int32 nIndex = pTempIndices[nTempIndices];
         // destroy temp cpp param => cpp: every param was constructed
-        uno_destructData( pCppArgs[nIndex], ppTempParamTypeDescr[nTempIndizes], cpp_release );
-        TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndizes] );
+        uno_destructData( pCppArgs[nIndex], ppTempParamTypeDescr[nTempIndices], cpp_release );
+        TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndices] );
       }
       // return type
       if (pReturnTypeDescr)
diff --git a/bridges/source/cpp_uno/gcc3_linux_powerpc/cpp2uno.cxx b/bridges/source/cpp_uno/gcc3_linux_powerpc/cpp2uno.cxx
index fa96ed3c3704..a04c1e2b9261 100644
--- a/bridges/source/cpp_uno/gcc3_linux_powerpc/cpp2uno.cxx
+++ b/bridges/source/cpp_uno/gcc3_linux_powerpc/cpp2uno.cxx
@@ -89,12 +89,12 @@ static typelib_TypeClass cpp2uno_call(
     // parameters
     void ** pUnoArgs = (void **)alloca( 4 * sizeof(void *) * nParams );
     void ** pCppArgs = pUnoArgs + nParams;
-    // indizes of values this have to be converted (interface conversion cpp<=>uno)
-    sal_Int32 * pTempIndizes = (sal_Int32 *)(pUnoArgs + (2 * nParams));
+    // indices of values this have to be converted (interface conversion cpp<=>uno)
+    sal_Int32 * pTempIndices = (sal_Int32 *)(pUnoArgs + (2 * nParams));
     // type descriptions for reconversions
     typelib_TypeDescription ** ppTempParamTypeDescr = (typelib_TypeDescription **)(pUnoArgs + (3 * nParams));
 
-    sal_Int32 nTempIndizes   = 0;
+    sal_Int32 nTempIndices   = 0;
 
     for ( sal_Int32 nPos = 0; nPos < nParams; ++nPos )
     {
@@ -254,9 +254,9 @@ static typelib_TypeClass cpp2uno_call(
             {
                 // uno out is unconstructed mem!
                 pUnoArgs[nPos] = alloca( pParamTypeDescr->nSize );
-                pTempIndizes[nTempIndizes] = nPos;
+                pTempIndices[nTempIndices] = nPos;
                 // will be released at reconversion
-                ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
             }
             // is in/inout
             else if (bridges::cpp_uno::shared::relatesToInterfaceType( pParamTypeDescr ))
@@ -264,9 +264,9 @@ static typelib_TypeClass cpp2uno_call(
                 uno_copyAndConvertData( pUnoArgs[nPos] = alloca( pParamTypeDescr->nSize ),
                                         *(void **)pCppStack, pParamTypeDescr,
                                         pThis->getBridge()->getCpp2Uno() );
-                pTempIndizes[nTempIndizes] = nPos; // has to be reconverted
+                pTempIndices[nTempIndices] = nPos; // has to be reconverted
                 // will be released at reconversion
-                ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
             }
             else // direct way
             {
@@ -288,13 +288,13 @@ static typelib_TypeClass cpp2uno_call(
     if (pUnoExc)
     {
         // destruct temporary in/inout params
-        for ( ; nTempIndizes--; )
+        for ( ; nTempIndices--; )
         {
-            sal_Int32 nIndex = pTempIndizes[nTempIndizes];
+            sal_Int32 nIndex = pTempIndices[nTempIndices];
 
             if (pParams[nIndex].bIn) // is in/inout => was constructed
-                uno_destructData( pUnoArgs[nIndex], ppTempParamTypeDescr[nTempIndizes], 0 );
-            TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndizes] );
+                uno_destructData( pUnoArgs[nIndex], ppTempParamTypeDescr[nTempIndices], 0 );
+            TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndices] );
         }
         if (pReturnTypeDescr)
             TYPELIB_DANGER_RELEASE( pReturnTypeDescr );
@@ -307,10 +307,10 @@ static typelib_TypeClass cpp2uno_call(
     else // else no exception occurred...
     {
         // temporary params
-        for ( ; nTempIndizes--; )
+        for ( ; nTempIndices--; )
         {
-            sal_Int32 nIndex = pTempIndizes[nTempIndizes];
-            typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndizes];
+            sal_Int32 nIndex = pTempIndices[nTempIndices];
+            typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndices];
 
             if (pParams[nIndex].bOut) // inout/out
             {
diff --git a/bridges/source/cpp_uno/gcc3_linux_powerpc/uno2cpp.cxx b/bridges/source/cpp_uno/gcc3_linux_powerpc/uno2cpp.cxx
index e3c2dd3facd2..bb3061138123 100644
--- a/bridges/source/cpp_uno/gcc3_linux_powerpc/uno2cpp.cxx
+++ b/bridges/source/cpp_uno/gcc3_linux_powerpc/uno2cpp.cxx
@@ -377,12 +377,12 @@ static void cpp_call(
     // OSL_ENSURE( sizeof(void *) == sizeof(sal_Int32), "### unexpected size!" );
     // args
     void ** pCppArgs  = (void **)alloca( 3 * sizeof(void *) * nParams );
-    // indizes of values this have to be converted (interface conversion cpp<=>uno)
-    sal_Int32 * pTempIndizes = (sal_Int32 *)(pCppArgs + nParams);
+    // indices of values this have to be converted (interface conversion cpp<=>uno)
+    sal_Int32 * pTempIndices = (sal_Int32 *)(pCppArgs + nParams);
     // type descriptions for reconversions
     typelib_TypeDescription ** ppTempParamTypeDescr = (typelib_TypeDescription **)(pCppArgs + (2 * nParams));
 
-    sal_Int32 nTempIndizes   = 0;
+    sal_Int32 nTempIndices   = 0;
 
     for ( sal_Int32 nPos = 0; nPos < nParams; ++nPos )
     {
@@ -448,9 +448,9 @@ static void cpp_call(
                 uno_constructData(
                     *(void **)pCppStack = pCppArgs[nPos] = alloca( pParamTypeDescr->nSize ),
                     pParamTypeDescr );
-                pTempIndizes[nTempIndizes] = nPos; // default constructed for cpp call
+                pTempIndices[nTempIndices] = nPos; // default constructed for cpp call
                 // will be released at reconversion
-                ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
             }
             // is in/inout
             else if (bridges::cpp_uno::shared::relatesToInterfaceType( pParamTypeDescr ))
@@ -460,9 +460,9 @@ static void cpp_call(
                     pUnoArgs[nPos], pParamTypeDescr,
                                         pThis->getBridge()->getUno2Cpp() );
 
-                pTempIndizes[nTempIndizes] = nPos; // has to be reconverted
+                pTempIndices[nTempIndices] = nPos; // has to be reconverted
                 // will be released at reconversion
-                ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
             }
             else // direct way
             {
@@ -491,10 +491,10 @@ static void cpp_call(
         *ppUnoExc = 0;
 
         // reconvert temporary params
-        for ( ; nTempIndizes--; )
+        for ( ; nTempIndices--; )
         {
-            sal_Int32 nIndex = pTempIndizes[nTempIndizes];
-            typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndizes];
+            sal_Int32 nIndex = pTempIndices[nTempIndices];
+            typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndices];
 
             if (pParams[nIndex].bIn)
             {
@@ -530,12 +530,12 @@ static void cpp_call(
                                   *ppUnoExc, pThis->getBridge()->getCpp2Uno() );
 
         // temporary params
-        for ( ; nTempIndizes--; )
+        for ( ; nTempIndices--; )
         {
-            sal_Int32 nIndex = pTempIndizes[nTempIndizes];
+            sal_Int32 nIndex = pTempIndices[nTempIndices];
             // destroy temp cpp param => cpp: every param was constructed
-            uno_destructData( pCppArgs[nIndex], ppTempParamTypeDescr[nTempIndizes], cpp_release );
-            TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndizes] );
+            uno_destructData( pCppArgs[nIndex], ppTempParamTypeDescr[nTempIndices], cpp_release );
+            TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndices] );
         }
         // return type
         if (pReturnTypeDescr)
diff --git a/bridges/source/cpp_uno/gcc3_linux_powerpc64/cpp2uno.cxx b/bridges/source/cpp_uno/gcc3_linux_powerpc64/cpp2uno.cxx
index a06269a4477c..8bb611f93259 100644
--- a/bridges/source/cpp_uno/gcc3_linux_powerpc64/cpp2uno.cxx
+++ b/bridges/source/cpp_uno/gcc3_linux_powerpc64/cpp2uno.cxx
@@ -91,12 +91,12 @@ static typelib_TypeClass cpp2uno_call(
     // parameters
     void ** pUnoArgs = (void **)alloca( 4 * sizeof(void *) * nParams );
     void ** pCppArgs = pUnoArgs + nParams;
-    // indizes of values this have to be converted (interface conversion cpp<=>uno)
-    sal_Int32 * pTempIndizes = (sal_Int32 *)(pUnoArgs + (2 * nParams));
+    // indices of values this have to be converted (interface conversion cpp<=>uno)
+    sal_Int32 * pTempIndices = (sal_Int32 *)(pUnoArgs + (2 * nParams));
     // type descriptions for reconversions
     typelib_TypeDescription ** ppTempParamTypeDescr = (typelib_TypeDescription **)(pUnoArgs + (3 * nParams));
 
-    sal_Int32 nTempIndizes = 0;
+    sal_Int32 nTempIndices = 0;
     bool bOverFlowUsed = false;
     for ( sal_Int32 nPos = 0; nPos < nParams; ++nPos )
     {
@@ -223,9 +223,9 @@ static typelib_TypeClass cpp2uno_call(
             {
                 // uno out is unconstructed mem!
                 pUnoArgs[nPos] = alloca( pParamTypeDescr->nSize );
-                pTempIndizes[nTempIndizes] = nPos;
+                pTempIndices[nTempIndices] = nPos;
                 // will be released at reconversion
-                ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
             }
             // is in/inout
             else if (bridges::cpp_uno::shared::relatesToInterfaceType( pParamTypeDescr ))
@@ -233,9 +233,9 @@ static typelib_TypeClass cpp2uno_call(
                 uno_copyAndConvertData( pUnoArgs[nPos] = alloca( pParamTypeDescr->nSize ),
                                         pCppStack, pParamTypeDescr,
                                         pThis->getBridge()->getCpp2Uno() );
-                pTempIndizes[nTempIndizes] = nPos; // has to be reconverted
+                pTempIndices[nTempIndices] = nPos; // has to be reconverted
                 // will be released at reconversion
-                ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
             }
             else // direct way
             {
@@ -261,13 +261,13 @@ static typelib_TypeClass cpp2uno_call(
     if (pUnoExc)
     {
         // destruct temporary in/inout params
-        for ( ; nTempIndizes--; )
+        for ( ; nTempIndices--; )
         {
-            sal_Int32 nIndex = pTempIndizes[nTempIndizes];
+            sal_Int32 nIndex = pTempIndices[nTempIndices];
 
             if (pParams[nIndex].bIn) // is in/inout => was constructed
-                uno_destructData( pUnoArgs[nIndex], ppTempParamTypeDescr[nTempIndizes], 0 );
-            TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndizes] );
+                uno_destructData( pUnoArgs[nIndex], ppTempParamTypeDescr[nTempIndices], 0 );
+            TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndices] );
         }
         if (pReturnTypeDescr)
             TYPELIB_DANGER_RELEASE( pReturnTypeDescr );
@@ -280,10 +280,10 @@ static typelib_TypeClass cpp2uno_call(
     else // else no exception occurred...
     {
         // temporary params
-        for ( ; nTempIndizes--; )
+        for ( ; nTempIndices--; )
         {
-            sal_Int32 nIndex = pTempIndizes[nTempIndizes];
-            typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndizes];
+            sal_Int32 nIndex = pTempIndices[nTempIndices];
+            typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndices];
 
             if (pParams[nIndex].bOut) // inout/out
             {
diff --git a/bridges/source/cpp_uno/gcc3_linux_powerpc64/uno2cpp.cxx b/bridges/source/cpp_uno/gcc3_linux_powerpc64/uno2cpp.cxx
index bc8a1a40406b..a1874d82bf30 100644
--- a/bridges/source/cpp_uno/gcc3_linux_powerpc64/uno2cpp.cxx
+++ b/bridges/source/cpp_uno/gcc3_linux_powerpc64/uno2cpp.cxx
@@ -286,12 +286,12 @@ static void cpp_call(
 
         // Args
         void ** pCppArgs = (void **)alloca( 3 * sizeof(void *) * nParams );
-    // indizes of values this have to be converted (interface conversion cpp<=>uno)
-    sal_Int32 * pTempIndizes = (sal_Int32 *)(pCppArgs + nParams);
+    // indices of values this have to be converted (interface conversion cpp<=>uno)
+    sal_Int32 * pTempIndices = (sal_Int32 *)(pCppArgs + nParams);
     // type descriptions for reconversions
     typelib_TypeDescription ** ppTempParamTypeDescr = (typelib_TypeDescription **)(pCppArgs + (2 * nParams));
 
-    sal_Int32 nTempIndizes   = 0;
+    sal_Int32 nTempIndices   = 0;
 
 #if OSL_DEBUG_LEVEL > 2
     fprintf(stderr, "n params is %d\n", nParams);
@@ -365,9 +365,9 @@ static void cpp_call(
                                 uno_constructData(
                                         pCppArgs[nPos] = alloca( pParamTypeDescr->nSize ),
                                         pParamTypeDescr );
-                                pTempIndizes[nTempIndizes] = nPos; // default constructed for cpp call
+                                pTempIndices[nTempIndices] = nPos; // default constructed for cpp call
                                 // will be released at reconversion
-                                ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+                                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
                         }
                         // is in/inout
                         else if (bridges::cpp_uno::shared::relatesToInterfaceType( pParamTypeDescr ))
@@ -379,9 +379,9 @@ static void cpp_call(
                                         pCppArgs[nPos] = alloca( pParamTypeDescr->nSize ),
                                         pUnoArgs[nPos], pParamTypeDescr, pThis->getBridge()->getUno2Cpp() );
 
-                                pTempIndizes[nTempIndizes] = nPos; // has to be reconverted
+                                pTempIndices[nTempIndices] = nPos; // has to be reconverted
                                 // will be released at reconversion
-                                ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+                                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
                         }
                         else // direct way
                         {
@@ -408,10 +408,10 @@ static void cpp_call(
         *ppUnoExc = 0;
 
         // reconvert temporary params
-        for ( ; nTempIndizes--; )
+        for ( ; nTempIndices--; )
         {
-            sal_Int32 nIndex = pTempIndizes[nTempIndizes];
-            typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndizes];
+            sal_Int32 nIndex = pTempIndices[nTempIndices];
+            typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndices];
 
             if (pParams[nIndex].bIn)
             {
@@ -447,12 +447,12 @@ static void cpp_call(
                                   *ppUnoExc, pThis->getBridge()->getCpp2Uno() );
 
         // temporary params
-        for ( ; nTempIndizes--; )
+        for ( ; nTempIndices--; )
         {
-            sal_Int32 nIndex = pTempIndizes[nTempIndizes];
+            sal_Int32 nIndex = pTempIndices[nTempIndices];
             // destroy temp cpp param => cpp: every param was constructed
-            uno_destructData( pCppArgs[nIndex], ppTempParamTypeDescr[nTempIndizes], cpp_release );
-            TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndizes] );
+            uno_destructData( pCppArgs[nIndex], ppTempParamTypeDescr[nTempIndices], cpp_release );
+            TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndices] );
         }
         // return type
         if (pReturnTypeDescr)
diff --git a/bridges/source/cpp_uno/gcc3_linux_s390/cpp2uno.cxx b/bridges/source/cpp_uno/gcc3_linux_s390/cpp2uno.cxx
index 2240df0d2cbb..0abea46c928d 100644
--- a/bridges/source/cpp_uno/gcc3_linux_s390/cpp2uno.cxx
+++ b/bridges/source/cpp_uno/gcc3_linux_s390/cpp2uno.cxx
@@ -86,12 +86,12 @@ static typelib_TypeClass cpp2uno_call(
     // parameters
     void ** pUnoArgs = (void **)alloca( 4 * sizeof(void *) * nParams );
     void ** pCppArgs = pUnoArgs + nParams;
-    // indizes of values this have to be converted (interface conversion cpp<=>uno)
-    sal_Int32 * pTempIndizes = (sal_Int32 *)(pUnoArgs + (2 * nParams));
+    // indices of values this have to be converted (interface conversion cpp<=>uno)
+    sal_Int32 * pTempIndices = (sal_Int32 *)(pUnoArgs + (2 * nParams));
     // type descriptions for reconversions
     typelib_TypeDescription ** ppTempParamTypeDescr = (typelib_TypeDescription **)(pUnoArgs + (3 * nParams));
 
-    sal_Int32 nTempIndizes   = 0;
+    sal_Int32 nTempIndices   = 0;
 
     for ( sal_Int32 nPos = 0; nPos < nParams; ++nPos )
     {
@@ -215,9 +215,9 @@ static typelib_TypeClass cpp2uno_call(
             {
                 // uno out is unconstructed mem!
                 pUnoArgs[nPos] = alloca( pParamTypeDescr->nSize );
-                pTempIndizes[nTempIndizes] = nPos;
+                pTempIndices[nTempIndices] = nPos;
                 // will be released at reconversion
-                ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
             }
             // is in/inout
             else if (bridges::cpp_uno::shared::relatesToInterfaceType( pParamTypeDescr ))
@@ -225,9 +225,9 @@ static typelib_TypeClass cpp2uno_call(
                 uno_copyAndConvertData( pUnoArgs[nPos] = alloca( pParamTypeDescr->nSize ),
                                         *(void **)pCppStack, pParamTypeDescr,
                                         pThis->getBridge()->getCpp2Uno() );
-                pTempIndizes[nTempIndizes] = nPos; // has to be reconverted
+                pTempIndices[nTempIndices] = nPos; // has to be reconverted
                 // will be released at reconversion
-                ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
             }
             else // direct way
             {
@@ -249,13 +249,13 @@ static typelib_TypeClass cpp2uno_call(
     if (pUnoExc)
     {
         // destruct temporary in/inout params
-        for ( ; nTempIndizes--; )
+        for ( ; nTempIndices--; )
         {
-            sal_Int32 nIndex = pTempIndizes[nTempIndizes];
+            sal_Int32 nIndex = pTempIndices[nTempIndices];
 
             if (pParams[nIndex].bIn) // is in/inout => was constructed
-                uno_destructData( pUnoArgs[nIndex], ppTempParamTypeDescr[nTempIndizes], 0 );
-            TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndizes] );
+                uno_destructData( pUnoArgs[nIndex], ppTempParamTypeDescr[nTempIndices], 0 );
+            TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndices] );
         }
         if (pReturnTypeDescr)
             TYPELIB_DANGER_RELEASE( pReturnTypeDescr );
@@ -267,10 +267,10 @@ static typelib_TypeClass cpp2uno_call(
     else // else no exception occurred...
     {
         // temporary params
-        for ( ; nTempIndizes--; )
+        for ( ; nTempIndices--; )
         {
-            sal_Int32 nIndex = pTempIndizes[nTempIndizes];
-            typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndizes];
+            sal_Int32 nIndex = pTempIndices[nTempIndices];
+            typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndices];
 
             if (pParams[nIndex].bOut) // inout/out
             {
diff --git a/bridges/source/cpp_uno/gcc3_linux_s390/uno2cpp.cxx b/bridges/source/cpp_uno/gcc3_linux_s390/uno2cpp.cxx
index 3582aaeb8658..7fa5db25bb46 100644
--- a/bridges/source/cpp_uno/gcc3_linux_s390/uno2cpp.cxx
+++ b/bridges/source/cpp_uno/gcc3_linux_s390/uno2cpp.cxx
@@ -322,12 +322,12 @@ static void cpp_call(
     OSL_ENSURE( sizeof(void *) == sizeof(sal_Int32), "### unexpected size!" );
     // args
     void ** pCppArgs  = (void **)alloca( 3 * sizeof(void *) * nParams );
-    // indizes of values this have to be converted (interface conversion cpp<=>uno)
-    sal_Int32 * pTempIndizes = (sal_Int32 *)(pCppArgs + nParams);
+    // indices of values this have to be converted (interface conversion cpp<=>uno)
+    sal_Int32 * pTempIndices = (sal_Int32 *)(pCppArgs + nParams);
     // type descriptions for reconversions
     typelib_TypeDescription ** ppTempParamTypeDescr = (typelib_TypeDescription **)(pCppArgs + (2 * nParams));
 
-    sal_Int32 nTempIndizes   = 0;
+    sal_Int32 nTempIndices   = 0;
 
     for ( sal_Int32 nPos = 0; nPos < nParams; ++nPos )
     {
@@ -395,9 +395,9 @@ static void cpp_call(
                 uno_constructData(
                     *(void **)pCppStack = pCppArgs[nPos] = alloca( pParamTypeDescr->nSize ),
                     pParamTypeDescr );
-                pTempIndizes[nTempIndizes] = nPos; // default constructed for cpp call
+                pTempIndices[nTempIndices] = nPos; // default constructed for cpp call
                 // will be released at reconversion
-                ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
             }
             // is in/inout
             else if (bridges::cpp_uno::shared::relatesToInterfaceType( pParamTypeDescr ))
@@ -406,9 +406,9 @@ static void cpp_call(
                     *(void **)pCppStack = pCppArgs[nPos] = alloca( pParamTypeDescr->nSize ),
                     pUnoArgs[nPos], pParamTypeDescr, pThis->getBridge()->getUno2Cpp() );
 
-                pTempIndizes[nTempIndizes] = nPos; // has to be reconverted
+                pTempIndices[nTempIndices] = nPos; // has to be reconverted
                 // will be released at reconversion
-                ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
             }
             else // direct way
             {
@@ -437,10 +437,10 @@ static void cpp_call(
         *ppUnoExc = 0;
 
         // reconvert temporary params
-        for ( ; nTempIndizes--; )
+        for ( ; nTempIndices--; )
         {
-            sal_Int32 nIndex = pTempIndizes[nTempIndizes];
-            typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndizes];
+            sal_Int32 nIndex = pTempIndices[nTempIndices];
+            typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndices];
 
             if (pParams[nIndex].bIn)
             {
@@ -477,12 +477,12 @@ static void cpp_call(
 
 
         // temporary params
-        for ( ; nTempIndizes--; )
+        for ( ; nTempIndices--; )
         {
-            sal_Int32 nIndex = pTempIndizes[nTempIndizes];
+            sal_Int32 nIndex = pTempIndices[nTempIndices];
             // destroy temp cpp param => cpp: every param was constructed
-            uno_destructData( pCppArgs[nIndex], ppTempParamTypeDescr[nTempIndizes], cpp_release );
-            TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndizes] );
+            uno_destructData( pCppArgs[nIndex], ppTempParamTypeDescr[nTempIndices], cpp_release );
+            TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndices] );
         }
         // return type
         if (pReturnTypeDescr)
diff --git a/bridges/source/cpp_uno/gcc3_linux_s390x/cpp2uno.cxx b/bridges/source/cpp_uno/gcc3_linux_s390x/cpp2uno.cxx
index 8242ed1434c8..00b8a344a9df 100644
--- a/bridges/source/cpp_uno/gcc3_linux_s390x/cpp2uno.cxx
+++ b/bridges/source/cpp_uno/gcc3_linux_s390x/cpp2uno.cxx
@@ -86,12 +86,12 @@ static typelib_TypeClass cpp2uno_call(
     // parameters
     void ** pUnoArgs = (void **)alloca( 4 * sizeof(void *) * nParams );
     void ** pCppArgs = pUnoArgs + nParams;
-    // indizes of values this have to be converted (interface conversion cpp<=>uno)
-    sal_Int32 * pTempIndizes = (sal_Int32 *)(pUnoArgs + (2 * nParams));
+    // indices of values this have to be converted (interface conversion cpp<=>uno)
+    sal_Int32 * pTempIndices = (sal_Int32 *)(pUnoArgs + (2 * nParams));
     // type descriptions for reconversions
     typelib_TypeDescription ** ppTempParamTypeDescr = (typelib_TypeDescription **)(pUnoArgs + (3 * nParams));
 
-    sal_Int32 nTempIndizes   = 0;
+    sal_Int32 nTempIndices   = 0;
     for ( sal_Int32 nPos = 0; nPos < nParams; ++nPos )
     {
         const typelib_MethodParameter & rParam = pParams[nPos];
@@ -213,9 +213,9 @@ static typelib_TypeClass cpp2uno_call(
             {
                 // uno out is unconstructed mem!
                 pUnoArgs[nPos] = alloca( pParamTypeDescr->nSize );
-                pTempIndizes[nTempIndizes] = nPos;
+                pTempIndices[nTempIndices] = nPos;
                 // will be released at reconversion
-                ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
             }
             // is in/inout
             else if (bridges::cpp_uno::shared::relatesToInterfaceType( pParamTypeDescr ))
@@ -223,9 +223,9 @@ static typelib_TypeClass cpp2uno_call(
                 uno_copyAndConvertData( pUnoArgs[nPos] = alloca( pParamTypeDescr->nSize ),
                                         pCppStack, pParamTypeDescr,
                                         pThis->getBridge()->getCpp2Uno() );
-                pTempIndizes[nTempIndizes] = nPos; // has to be reconverted
+                pTempIndices[nTempIndices] = nPos; // has to be reconverted
                 // will be released at reconversion
-                ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
             }
             else // direct way
             {
@@ -251,13 +251,13 @@ static typelib_TypeClass cpp2uno_call(
     if (pUnoExc)
     {
         // destruct temporary in/inout params
-        for ( ; nTempIndizes--; )
+        for ( ; nTempIndices--; )
         {
-            sal_Int32 nIndex = pTempIndizes[nTempIndizes];
+            sal_Int32 nIndex = pTempIndices[nTempIndices];
 
             if (pParams[nIndex].bIn) // is in/inout => was constructed
-                uno_destructData( pUnoArgs[nIndex], ppTempParamTypeDescr[nTempIndizes], 0 );
-            TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndizes] );
+                uno_destructData( pUnoArgs[nIndex], ppTempParamTypeDescr[nTempIndices], 0 );
+            TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndices] );
         }
         if (pReturnTypeDescr)
             TYPELIB_DANGER_RELEASE( pReturnTypeDescr );
@@ -269,10 +269,10 @@ static typelib_TypeClass cpp2uno_call(
     else // else no exception occurred...
     {
         // temporary params
-        for ( ; nTempIndizes--; )
+        for ( ; nTempIndices--; )
         {
-            sal_Int32 nIndex = pTempIndizes[nTempIndizes];
-            typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndizes];
+            sal_Int32 nIndex = pTempIndices[nTempIndices];
+            typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndices];
 
             if (pParams[nIndex].bOut) // inout/out
             {
diff --git a/bridges/source/cpp_uno/gcc3_linux_s390x/uno2cpp.cxx b/bridges/source/cpp_uno/gcc3_linux_s390x/uno2cpp.cxx
index b8fa8ad86f2c..ddd43b25c51a 100644
--- a/bridges/source/cpp_uno/gcc3_linux_s390x/uno2cpp.cxx
+++ b/bridges/source/cpp_uno/gcc3_linux_s390x/uno2cpp.cxx
@@ -244,12 +244,12 @@ static void cpp_call(
     OSL_ENSURE( sizeof(void *) == sizeof(sal_Int64), "### unexpected size!" );
     // args
     void ** pCppArgs  = (void **)alloca( 3 * sizeof(void *) * nParams );
-    // indizes of values this have to be converted (interface conversion cpp<=>uno)
-    sal_Int32 * pTempIndizes = (sal_Int32 *)(pCppArgs + nParams);
+    // indices of values this have to be converted (interface conversion cpp<=>uno)
+    sal_Int32 * pTempIndices = (sal_Int32 *)(pCppArgs + nParams);
     // type descriptions for reconversions
     typelib_TypeDescription ** ppTempParamTypeDescr = (typelib_TypeDescription **)(pCppArgs + (2 * nParams));
 
-    sal_Int32 nTempIndizes   = 0;
+    sal_Int32 nTempIndices   = 0;
 
     for ( sal_Int32 nPos = 0; nPos < nParams; ++nPos )
     {
@@ -303,9 +303,9 @@ static void cpp_call(
                 uno_constructData(
                     pCppArgs[nPos] = alloca( pParamTypeDescr->nSize ),
                     pParamTypeDescr );
-                pTempIndizes[nTempIndizes] = nPos; // default constructed for cpp call
+                pTempIndices[nTempIndices] = nPos; // default constructed for cpp call
                 // will be released at reconversion
-                ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
             }
             // is in/inout
             else if (bridges::cpp_uno::shared::relatesToInterfaceType( pParamTypeDescr ))
@@ -314,9 +314,9 @@ static void cpp_call(
                     pCppArgs[nPos] = alloca( pParamTypeDescr->nSize ),
                     pUnoArgs[nPos], pParamTypeDescr, pThis->getBridge()->getUno2Cpp() );
 
-                pTempIndizes[nTempIndizes] = nPos; // has to be reconverted
+                pTempIndices[nTempIndices] = nPos; // has to be reconverted
                 // will be released at reconversion
-                ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
             }
             else // direct way
             {
@@ -340,10 +340,10 @@ static void cpp_call(
         *ppUnoExc = 0;
 
         // reconvert temporary params
-        for ( ; nTempIndizes--; )
+        for ( ; nTempIndices--; )
         {
-            sal_Int32 nIndex = pTempIndizes[nTempIndizes];
-            typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndizes];
+            sal_Int32 nIndex = pTempIndices[nTempIndices];
+            typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndices];
 
             if (pParams[nIndex].bIn)
             {
@@ -380,12 +380,12 @@ static void cpp_call(
 
 
         // temporary params
-        for ( ; nTempIndizes--; )
+        for ( ; nTempIndices--; )
         {
-            sal_Int32 nIndex = pTempIndizes[nTempIndizes];
+            sal_Int32 nIndex = pTempIndices[nTempIndices];
             // destroy temp cpp param => cpp: every param was constructed
-            uno_destructData( pCppArgs[nIndex], ppTempParamTypeDescr[nTempIndizes], cpp_release );
-            TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndizes] );
+            uno_destructData( pCppArgs[nIndex], ppTempParamTypeDescr[nTempIndices], cpp_release );
+            TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndices] );
         }
         // return type
         if (pReturnTypeDescr)
diff --git a/bridges/source/cpp_uno/gcc3_linux_sparc/cpp2uno.cxx b/bridges/source/cpp_uno/gcc3_linux_sparc/cpp2uno.cxx
index 2e0f06fa0b1c..334297b4fe74 100644
--- a/bridges/source/cpp_uno/gcc3_linux_sparc/cpp2uno.cxx
+++ b/bridges/source/cpp_uno/gcc3_linux_sparc/cpp2uno.cxx
@@ -72,12 +72,12 @@ static typelib_TypeClass cpp2uno_call(
     // parameters
     void ** pUnoArgs = (void **)alloca( 4 * sizeof(void *) * nParams );
     void ** pCppArgs = pUnoArgs + nParams;
-    // indizes of values this have to be converted (interface conversion cpp<=>uno)
-    sal_Int32 * pTempIndizes = (sal_Int32 *)(pUnoArgs + (2 * nParams));
+    // indices of values this have to be converted (interface conversion cpp<=>uno)
+    sal_Int32 * pTempIndices = (sal_Int32 *)(pUnoArgs + (2 * nParams));
     // type descriptions for reconversions
     typelib_TypeDescription ** ppTempParamTypeDescr = (typelib_TypeDescription **)(pUnoArgs + (3 * nParams));
 
-    sal_Int32 nTempIndizes   = 0;
+    sal_Int32 nTempIndices   = 0;
 
     for ( sal_Int32 nPos = 0; nPos < nParams; ++nPos )
     {
@@ -121,9 +121,9 @@ static typelib_TypeClass cpp2uno_call(
             {
                 // uno out is unconstructed mem!
                 pUnoArgs[nPos] = alloca( pParamTypeDescr->nSize );
-                pTempIndizes[nTempIndizes] = nPos;
+                pTempIndices[nTempIndices] = nPos;
                 // will be released at reconversion
-                ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
             }
             // is in/inout
             else if (bridges::cpp_uno::shared::relatesToInterfaceType(
@@ -132,9 +132,9 @@ static typelib_TypeClass cpp2uno_call(
                 uno_copyAndConvertData( pUnoArgs[nPos] = alloca( pParamTypeDescr->nSize ),
                                         *(void **)pCppStack, pParamTypeDescr,
                                           pThis->getBridge()->getCpp2Uno() );
-                pTempIndizes[nTempIndizes] = nPos; // has to be reconverted
+                pTempIndices[nTempIndices] = nPos; // has to be reconverted
                 // will be released at reconversion
-                ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
             }
             else // direct way
             {
@@ -157,13 +157,13 @@ static typelib_TypeClass cpp2uno_call(
     if (pUnoExc)
     {
         // destruct temporary in/inout params
-        for ( ; nTempIndizes--; )
+        for ( ; nTempIndices--; )
         {
-            sal_Int32 nIndex = pTempIndizes[nTempIndizes];
+            sal_Int32 nIndex = pTempIndices[nTempIndices];
 
             if (pParams[nIndex].bIn) // is in/inout => was constructed
-                uno_destructData( pUnoArgs[nIndex], ppTempParamTypeDescr[nTempIndizes], 0 );
-            TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndizes] );
+                uno_destructData( pUnoArgs[nIndex], ppTempParamTypeDescr[nTempIndices], 0 );
+            TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndices] );
         }
         if (pReturnTypeDescr)
             TYPELIB_DANGER_RELEASE( pReturnTypeDescr );
@@ -175,10 +175,10 @@ static typelib_TypeClass cpp2uno_call(
     else // else no exception occurred...
     {
         // temporary params
-        for ( ; nTempIndizes--; )
+        for ( ; nTempIndices--; )
         {
-            sal_Int32 nIndex = pTempIndizes[nTempIndizes];
-            typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndizes];
+            sal_Int32 nIndex = pTempIndices[nTempIndices];
+            typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndices];
 
             if (pParams[nIndex].bOut) // inout/out
             {
diff --git a/bridges/source/cpp_uno/gcc3_linux_sparc/uno2cpp.cxx b/bridges/source/cpp_uno/gcc3_linux_sparc/uno2cpp.cxx
index 1a73ed5188ee..063b8eb0144e 100644
--- a/bridges/source/cpp_uno/gcc3_linux_sparc/uno2cpp.cxx
+++ b/bridges/source/cpp_uno/gcc3_linux_sparc/uno2cpp.cxx
@@ -317,12 +317,12 @@ static void cpp_call(
     OSL_ENSURE( sizeof(void *) == sizeof(sal_Int32), "### unexpected size!" );
     // args
     void ** pCppArgs  = (void **)alloca( 3 * sizeof(void *) * nParams );
-    // indizes of values this have to be converted (interface conversion cpp<=>uno)
-    sal_Int32 * pTempIndizes = (sal_Int32 *)(pCppArgs + nParams);
+    // indices of values this have to be converted (interface conversion cpp<=>uno)
+    sal_Int32 * pTempIndices = (sal_Int32 *)(pCppArgs + nParams);
     // type descriptions for reconversions
     typelib_TypeDescription ** ppTempParamTypeDescr = (typelib_TypeDescription **)(pCppArgs + (2 * nParams));
 
-    sal_Int32 nTempIndizes   = 0;
+    sal_Int32 nTempIndices   = 0;
 
     for ( sal_Int32 nPos = 0; nPos < nParams; ++nPos )
     {
@@ -362,9 +362,9 @@ static void cpp_call(
                 uno_constructData(
                     *(void **)pCppStack = pCppArgs[nPos] = alloca( pParamTypeDescr->nSize ),
                     pParamTypeDescr );
-                pTempIndizes[nTempIndizes] = nPos; // default constructed for cpp call
+                pTempIndices[nTempIndices] = nPos; // default constructed for cpp call
                 // will be released at reconversion
-                ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
             }
             // is in/inout
             else if (bridges::cpp_uno::shared::relatesToInterfaceType(
@@ -375,9 +375,9 @@ static void cpp_call(
                                     pUnoArgs[nPos], pParamTypeDescr,
                     pThis->getBridge()->getUno2Cpp() );
 
-                pTempIndizes[nTempIndizes] = nPos; // has to be reconverted
+                pTempIndices[nTempIndices] = nPos; // has to be reconverted
                 // will be released at reconversion
-                ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
             }
             else // direct way
             {
@@ -408,10 +408,10 @@ static void cpp_call(
         *ppUnoExc = 0;
 
         // reconvert temporary params
-        for ( ; nTempIndizes--; )
+        for ( ; nTempIndices--; )
         {
-            sal_Int32 nIndex = pTempIndizes[nTempIndizes];
-            typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndizes];
+            sal_Int32 nIndex = pTempIndices[nTempIndices];
+            typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndices];
 
             if (pParams[nIndex].bIn)
             {
@@ -447,12 +447,12 @@ static void cpp_call(
                                 *ppUnoExc, pThis->getBridge()->getCpp2Uno() );
 
         // temporary params
-        for ( ; nTempIndizes--; )
+        for ( ; nTempIndices--; )
         {
-            sal_Int32 nIndex = pTempIndizes[nTempIndizes];
+            sal_Int32 nIndex = pTempIndices[nTempIndices];
             // destroy temp cpp param => cpp: every param was constructed
-            uno_destructData( pCppArgs[nIndex], ppTempParamTypeDescr[nTempIndizes], cpp_release );
-            TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndizes] );
+            uno_destructData( pCppArgs[nIndex], ppTempParamTypeDescr[nTempIndices], cpp_release );
+            TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndices] );
         }
         // return type
         if (pReturnTypeDescr)
diff --git a/bridges/source/cpp_uno/gcc3_linux_x86-64/cpp2uno.cxx b/bridges/source/cpp_uno/gcc3_linux_x86-64/cpp2uno.cxx
index b926dadf5523..3d773d08144e 100644
--- a/bridges/source/cpp_uno/gcc3_linux_x86-64/cpp2uno.cxx
+++ b/bridges/source/cpp_uno/gcc3_linux_x86-64/cpp2uno.cxx
@@ -98,12 +98,12 @@ static typelib_TypeClass cpp2uno_call(
     // parameters
     void ** pUnoArgs = (void **)alloca( 4 * sizeof(void *) * nParams );
     void ** pCppArgs = pUnoArgs + nParams;
-    // indizes of values this have to be converted (interface conversion cpp<=>uno)
-    sal_Int32 * pTempIndizes = (sal_Int32 *)(pUnoArgs + (2 * nParams));
+    // indices of values this have to be converted (interface conversion cpp<=>uno)
+    sal_Int32 * pTempIndices = (sal_Int32 *)(pUnoArgs + (2 * nParams));
     // type descriptions for reconversions
     typelib_TypeDescription ** ppTempParamTypeDescr = (typelib_TypeDescription **)(pUnoArgs + (3 * nParams));
 
-    sal_Int32 nTempIndizes = 0;
+    sal_Int32 nTempIndices = 0;
 
     for ( sal_Int32 nPos = 0; nPos < nParams; ++nPos )
     {
@@ -159,18 +159,18 @@ static typelib_TypeClass cpp2uno_call(
             {
                 // uno out is unconstructed mem!
                 pUnoArgs[nPos] = alloca( pParamTypeDescr->nSize );
-                pTempIndizes[nTempIndizes] = nPos;
+                pTempIndices[nTempIndices] = nPos;
                 // will be released at reconversion
-                ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
             }
             else if ( bridges::cpp_uno::shared::relatesToInterfaceType( pParamTypeDescr ) ) // is in/inout
             {
                 uno_copyAndConvertData( pUnoArgs[nPos] = alloca( pParamTypeDescr->nSize ),
                                         pCppStack, pParamTypeDescr,
                                         pThis->getBridge()->getCpp2Uno() );
-                pTempIndizes[nTempIndizes] = nPos; // has to be reconverted
+                pTempIndices[nTempIndices] = nPos; // has to be reconverted
                 // will be released at reconversion
-                ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
             }
             else // direct way
             {
@@ -192,13 +192,13 @@ static typelib_TypeClass cpp2uno_call(
     if ( pUnoExc )
     {
         // destruct temporary in/inout params
-        for ( ; nTempIndizes--; )
+        for ( ; nTempIndices--; )
         {
-            sal_Int32 nIndex = pTempIndizes[nTempIndizes];
+            sal_Int32 nIndex = pTempIndices[nTempIndices];
 
             if (pParams[nIndex].bIn) // is in/inout => was constructed
-                uno_destructData( pUnoArgs[nIndex], ppTempParamTypeDescr[nTempIndizes], 0 );
-            TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndizes] );
+                uno_destructData( pUnoArgs[nIndex], ppTempParamTypeDescr[nTempIndices], 0 );
+            TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndices] );
         }
         if (pReturnTypeDescr)
             TYPELIB_DANGER_RELEASE( pReturnTypeDescr );
@@ -210,10 +210,10 @@ static typelib_TypeClass cpp2uno_call(
     else // else no exception occurred...
     {
         // temporary params
-        for ( ; nTempIndizes--; )
+        for ( ; nTempIndices--; )
         {
-            sal_Int32 nIndex = pTempIndizes[nTempIndizes];
-            typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndizes];
+            sal_Int32 nIndex = pTempIndices[nTempIndices];
+            typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndices];
 
             if ( pParams[nIndex].bOut ) // inout/out
             {
diff --git a/bridges/source/cpp_uno/gcc3_linux_x86-64/uno2cpp.cxx b/bridges/source/cpp_uno/gcc3_linux_x86-64/uno2cpp.cxx
index 08c797c8bd02..4dae7d2586cb 100644
--- a/bridges/source/cpp_uno/gcc3_linux_x86-64/uno2cpp.cxx
+++ b/bridges/source/cpp_uno/gcc3_linux_x86-64/uno2cpp.cxx
@@ -144,12 +144,12 @@ static void cpp_call(
 
     // Args
     void ** pCppArgs = (void **)alloca( 3 * sizeof(void *) * nParams );
-    // Indizes of values this have to be converted (interface conversion cpp<=>uno)
-    sal_Int32 * pTempIndizes = (sal_Int32 *)(pCppArgs + nParams);
+    // Indices of values this have to be converted (interface conversion cpp<=>uno)
+    sal_Int32 * pTempIndices = (sal_Int32 *)(pCppArgs + nParams);
     // Type descriptions for reconversions
     typelib_TypeDescription ** ppTempParamTypeDescr = (typelib_TypeDescription **)(pCppArgs + (2 * nParams));
 
-    sal_Int32 nTempIndizes = 0;
+    sal_Int32 nTempIndices = 0;
 
     for ( sal_Int32 nPos = 0; nPos < nParams; ++nPos )
     {
@@ -201,9 +201,9 @@ static void cpp_call(
                 uno_constructData(
                     pCppArgs[nPos] = alloca( pParamTypeDescr->nSize ),
                     pParamTypeDescr );
-                pTempIndizes[nTempIndizes] = nPos; // default constructed for cpp call
+                pTempIndices[nTempIndices] = nPos; // default constructed for cpp call
                 // will be released at reconversion
-                ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
             }
             // is in/inout
             else if (bridges::cpp_uno::shared::relatesToInterfaceType( pParamTypeDescr ))
@@ -212,9 +212,9 @@ static void cpp_call(
                     pCppArgs[nPos] = alloca( pParamTypeDescr->nSize ),
                     pUnoArgs[nPos], pParamTypeDescr, pThis->getBridge()->getUno2Cpp() );
 
-                pTempIndizes[nTempIndizes] = nPos; // has to be reconverted
+                pTempIndices[nTempIndices] = nPos; // has to be reconverted
                 // will be released at reconversion
-                ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
             }
             else // direct way
             {
@@ -255,10 +255,10 @@ static void cpp_call(
         *ppUnoExc = 0;
 
         // reconvert temporary params
-        for ( ; nTempIndizes--; )
+        for ( ; nTempIndices--; )
         {
-            sal_Int32 nIndex = pTempIndizes[nTempIndizes];
-            typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndizes];
+            sal_Int32 nIndex = pTempIndices[nTempIndices];
+            typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndices];
 
             if (pParams[nIndex].bIn)
             {
@@ -296,12 +296,12 @@ static void cpp_call(
              *ppUnoExc, pThis->getBridge()->getCpp2Uno());
 
         // temporary params
-        for ( ; nTempIndizes--; )
+        for ( ; nTempIndices--; )
         {
-            sal_Int32 nIndex = pTempIndizes[nTempIndizes];
+            sal_Int32 nIndex = pTempIndices[nTempIndices];
             // destroy temp cpp param => cpp: every param was constructed
-            uno_destructData( pCppArgs[nIndex], ppTempParamTypeDescr[nTempIndizes], cpp_release );
-            TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndizes] );
+            uno_destructData( pCppArgs[nIndex], ppTempParamTypeDescr[nTempIndices], cpp_release );
+            TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndices] );
         }
         // return type
         if (pReturnTypeDescr)
diff --git a/bridges/source/cpp_uno/gcc3_macosx_intel/cpp2uno.cxx b/bridges/source/cpp_uno/gcc3_macosx_intel/cpp2uno.cxx
index e893ef022142..4fe5377f449b 100644
--- a/bridges/source/cpp_uno/gcc3_macosx_intel/cpp2uno.cxx
+++ b/bridges/source/cpp_uno/gcc3_macosx_intel/cpp2uno.cxx
@@ -84,12 +84,12 @@ void cpp2uno_call(
     // parameters
     void ** pUnoArgs = (void **)alloca( 4 * sizeof(void *) * nParams );
     void ** pCppArgs = pUnoArgs + nParams;
-    // indizes of values this have to be converted (interface conversion cpp<=>uno)
-    sal_Int32 * pTempIndizes = (sal_Int32 *)(pUnoArgs + (2 * nParams));
+    // indices of values this have to be converted (interface conversion cpp<=>uno)
+    sal_Int32 * pTempIndices = (sal_Int32 *)(pUnoArgs + (2 * nParams));
     // type descriptions for reconversions
     typelib_TypeDescription ** ppTempParamTypeDescr = (typelib_TypeDescription **)(pUnoArgs + (3 * nParams));
 
-    sal_Int32 nTempIndizes   = 0;
+    sal_Int32 nTempIndices   = 0;
 
     for ( sal_Int32 nPos = 0; nPos < nParams; ++nPos )
     {
@@ -123,9 +123,9 @@ void cpp2uno_call(
             {
                 // uno out is unconstructed mem!
                 pUnoArgs[nPos] = alloca( pParamTypeDescr->nSize );
-                pTempIndizes[nTempIndizes] = nPos;
+                pTempIndices[nTempIndices] = nPos;
                 // will be released at reconversion
-                ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
             }
             // is in/inout
             else if (bridges::cpp_uno::shared::relatesToInterfaceType(
@@ -134,9 +134,9 @@ void cpp2uno_call(
                 uno_copyAndConvertData( pUnoArgs[nPos] = alloca( pParamTypeDescr->nSize ),
                                         *(void **)pCppStack, pParamTypeDescr,
                                         pThis->getBridge()->getCpp2Uno() );
-                pTempIndizes[nTempIndizes] = nPos; // has to be reconverted
+                pTempIndices[nTempIndices] = nPos; // has to be reconverted
                 // will be released at reconversion
-                ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
             }
             else // direct way
             {
@@ -160,13 +160,13 @@ void cpp2uno_call(
     if (pUnoExc)
     {
         // destruct temporary in/inout params
-        for ( ; nTempIndizes--; )
+        for ( ; nTempIndices--; )
         {
-            sal_Int32 nIndex = pTempIndizes[nTempIndizes];
+            sal_Int32 nIndex = pTempIndices[nTempIndices];
 
             if (pParams[nIndex].bIn) // is in/inout => was constructed
-                uno_destructData( pUnoArgs[nIndex], ppTempParamTypeDescr[nTempIndizes], 0 );
-            TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndizes] );
+                uno_destructData( pUnoArgs[nIndex], ppTempParamTypeDescr[nTempIndices], 0 );
+            TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndices] );
         }
         if (pReturnTypeDescr)
             TYPELIB_DANGER_RELEASE( pReturnTypeDescr );
@@ -178,10 +178,10 @@ void cpp2uno_call(
     else // else no exception occurred...
     {
         // temporary params
-        for ( ; nTempIndizes--; )
+        for ( ; nTempIndices--; )
         {
-            sal_Int32 nIndex = pTempIndizes[nTempIndizes];
-            typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndizes];
+            sal_Int32 nIndex = pTempIndices[nTempIndices];
+            typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndices];
 
             if (pParams[nIndex].bOut) // inout/out
             {
diff --git a/bridges/source/cpp_uno/gcc3_macosx_intel/uno2cpp.cxx b/bridges/source/cpp_uno/gcc3_macosx_intel/uno2cpp.cxx
index 7c09e3ce7369..0771234025f3 100644
--- a/bridges/source/cpp_uno/gcc3_macosx_intel/uno2cpp.cxx
+++ b/bridges/source/cpp_uno/gcc3_macosx_intel/uno2cpp.cxx
@@ -197,12 +197,12 @@ static void cpp_call(
     OSL_ENSURE( sizeof(void *) == sizeof(sal_Int32), "### unexpected size!" );
     // args
     void ** pCppArgs  = (void **)alloca( 3 * sizeof(void *) * nParams );
-    // indizes of values this have to be converted (interface conversion cpp<=>uno)
-    sal_Int32 * pTempIndizes = (sal_Int32 *)(pCppArgs + nParams);
+    // indices of values this have to be converted (interface conversion cpp<=>uno)
+    sal_Int32 * pTempIndices = (sal_Int32 *)(pCppArgs + nParams);
     // type descriptions for reconversions
     typelib_TypeDescription ** ppTempParamTypeDescr = (typelib_TypeDescription **)(pCppArgs + (2 * nParams));
 
-    sal_Int32 nTempIndizes   = 0;
+    sal_Int32 nTempIndices   = 0;
 
     for ( sal_Int32 nPos = 0; nPos < nParams; ++nPos )
     {
@@ -236,9 +236,9 @@ static void cpp_call(
                 uno_constructData(
                     *(void **)pCppStack = pCppArgs[nPos] = alloca( pParamTypeDescr->nSize ),
                     pParamTypeDescr );
-                pTempIndizes[nTempIndizes] = nPos; // default constructed for cpp call
+                pTempIndices[nTempIndices] = nPos; // default constructed for cpp call
                 // will be released at reconversion
-                ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
             }
             // is in/inout
             else if (bridges::cpp_uno::shared::relatesToInterfaceType(
@@ -249,9 +249,9 @@ static void cpp_call(
                     pUnoArgs[nPos], pParamTypeDescr,
                     pThis->getBridge()->getUno2Cpp() );
 
-                pTempIndizes[nTempIndizes] = nPos; // has to be reconverted
+                pTempIndices[nTempIndices] = nPos; // has to be reconverted
                 // will be released at reconversion
-                ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
             }
             else // direct way
             {
@@ -274,10 +274,10 @@ static void cpp_call(
         *ppUnoExc = 0;
 
         // reconvert temporary params
-        for ( ; nTempIndizes--; )
+        for ( ; nTempIndices--; )
         {
-            sal_Int32 nIndex = pTempIndizes[nTempIndizes];
-            typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndizes];
+            sal_Int32 nIndex = pTempIndices[nTempIndices];
+            typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndices];
 
             if (pParams[nIndex].bIn)
             {
@@ -315,12 +315,12 @@ static void cpp_call(
         fillUnoException( CPPU_CURRENT_NAMESPACE::__cxa_get_globals()->caughtExceptions, *ppUnoExc, pThis->getBridge()->getCpp2Uno() );
 
         // temporary params
-        for ( ; nTempIndizes--; )
+        for ( ; nTempIndices--; )
         {
-            sal_Int32 nIndex = pTempIndizes[nTempIndizes];
+            sal_Int32 nIndex = pTempIndices[nTempIndices];
             // destroy temp cpp param => cpp: every param was constructed
-            uno_destructData( pCppArgs[nIndex], ppTempParamTypeDescr[nTempIndizes], cpp_release );
-            TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndizes] );
+            uno_destructData( pCppArgs[nIndex], ppTempParamTypeDescr[nTempIndices], cpp_release );
+            TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndices] );
         }
         // return type
         if (pReturnTypeDescr)
diff --git a/bridges/source/cpp_uno/gcc3_macosx_x86-64/cpp2uno.cxx b/bridges/source/cpp_uno/gcc3_macosx_x86-64/cpp2uno.cxx
index 900798e0e27c..94844fedf742 100644
--- a/bridges/source/cpp_uno/gcc3_macosx_x86-64/cpp2uno.cxx
+++ b/bridges/source/cpp_uno/gcc3_macosx_x86-64/cpp2uno.cxx
@@ -98,12 +98,12 @@ static typelib_TypeClass cpp2uno_call(
     // parameters
     void ** pUnoArgs = (void **)alloca( 4 * sizeof(void *) * nParams );
     void ** pCppArgs = pUnoArgs + nParams;
-    // indizes of values this have to be converted (interface conversion cpp<=>uno)
-    sal_Int32 * pTempIndizes = (sal_Int32 *)(pUnoArgs + (2 * nParams));
+    // indices of values this have to be converted (interface conversion cpp<=>uno)
+    sal_Int32 * pTempIndices = (sal_Int32 *)(pUnoArgs + (2 * nParams));
     // type descriptions for reconversions
     typelib_TypeDescription ** ppTempParamTypeDescr = (typelib_TypeDescription **)(pUnoArgs + (3 * nParams));
 
-    sal_Int32 nTempIndizes = 0;
+    sal_Int32 nTempIndices = 0;
 
     for ( sal_Int32 nPos = 0; nPos < nParams; ++nPos )
     {
@@ -159,18 +159,18 @@ static typelib_TypeClass cpp2uno_call(
             {
                 // uno out is unconstructed mem!
                 pUnoArgs[nPos] = alloca( pParamTypeDescr->nSize );
-                pTempIndizes[nTempIndizes] = nPos;
+                pTempIndices[nTempIndices] = nPos;
                 // will be released at reconversion
-                ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
             }
             else if ( bridges::cpp_uno::shared::relatesToInterfaceType( pParamTypeDescr ) ) // is in/inout
             {
                 uno_copyAndConvertData( pUnoArgs[nPos] = alloca( pParamTypeDescr->nSize ),
                                         pCppStack, pParamTypeDescr,
                                         pThis->getBridge()->getCpp2Uno() );
-                pTempIndizes[nTempIndizes] = nPos; // has to be reconverted
+                pTempIndices[nTempIndices] = nPos; // has to be reconverted
                 // will be released at reconversion
-                ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
             }
             else // direct way
             {
@@ -192,13 +192,13 @@ static typelib_TypeClass cpp2uno_call(
     if ( pUnoExc )
     {
         // destruct temporary in/inout params
-        for ( ; nTempIndizes--; )
+        for ( ; nTempIndices--; )
         {
-            sal_Int32 nIndex = pTempIndizes[nTempIndizes];
+            sal_Int32 nIndex = pTempIndices[nTempIndices];
 
             if (pParams[nIndex].bIn) // is in/inout => was constructed
-                uno_destructData( pUnoArgs[nIndex], ppTempParamTypeDescr[nTempIndizes], 0 );
-            TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndizes] );
+                uno_destructData( pUnoArgs[nIndex], ppTempParamTypeDescr[nTempIndices], 0 );
+            TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndices] );
         }
         if (pReturnTypeDescr)
             TYPELIB_DANGER_RELEASE( pReturnTypeDescr );
@@ -210,10 +210,10 @@ static typelib_TypeClass cpp2uno_call(
     else // else no exception occurred...
     {
         // temporary params
-        for ( ; nTempIndizes--; )
+        for ( ; nTempIndices--; )
         {
-            sal_Int32 nIndex = pTempIndizes[nTempIndizes];
-            typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndizes];
+            sal_Int32 nIndex = pTempIndices[nTempIndices];
+            typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndices];
 
             if ( pParams[nIndex].bOut ) // inout/out
             {
diff --git a/bridges/source/cpp_uno/gcc3_macosx_x86-64/uno2cpp.cxx b/bridges/source/cpp_uno/gcc3_macosx_x86-64/uno2cpp.cxx
index cbf45bb094d2..17f93fec177d 100644
--- a/bridges/source/cpp_uno/gcc3_macosx_x86-64/uno2cpp.cxx
+++ b/bridges/source/cpp_uno/gcc3_macosx_x86-64/uno2cpp.cxx
@@ -144,12 +144,12 @@ static void cpp_call(
 
     // Args
     void ** pCppArgs = (void **)alloca( 3 * sizeof(void *) * nParams );
-    // Indizes of values this have to be converted (interface conversion cpp<=>uno)
-    sal_Int32 * pTempIndizes = (sal_Int32 *)(pCppArgs + nParams);
+    // Indices of values this have to be converted (interface conversion cpp<=>uno)
+    sal_Int32 * pTempIndices = (sal_Int32 *)(pCppArgs + nParams);
     // Type descriptions for reconversions
     typelib_TypeDescription ** ppTempParamTypeDescr = (typelib_TypeDescription **)(pCppArgs + (2 * nParams));
 
-    sal_Int32 nTempIndizes = 0;
+    sal_Int32 nTempIndices = 0;
 
     for ( sal_Int32 nPos = 0; nPos < nParams; ++nPos )
     {
@@ -201,9 +201,9 @@ static void cpp_call(
                 uno_constructData(
                     pCppArgs[nPos] = alloca( pParamTypeDescr->nSize ),
                     pParamTypeDescr );
-                pTempIndizes[nTempIndizes] = nPos; // default constructed for cpp call
+                pTempIndices[nTempIndices] = nPos; // default constructed for cpp call
                 // will be released at reconversion
-                ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
             }
             // is in/inout
             else if (bridges::cpp_uno::shared::relatesToInterfaceType( pParamTypeDescr ))
@@ -212,9 +212,9 @@ static void cpp_call(
                     pCppArgs[nPos] = alloca( pParamTypeDescr->nSize ),
                     pUnoArgs[nPos], pParamTypeDescr, pThis->getBridge()->getUno2Cpp() );
 
-                pTempIndizes[nTempIndizes] = nPos; // has to be reconverted
+                pTempIndices[nTempIndices] = nPos; // has to be reconverted
                 // will be released at reconversion
-                ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
             }
             else // direct way
             {
@@ -255,10 +255,10 @@ static void cpp_call(
         *ppUnoExc = 0;
 
         // reconvert temporary params
-        for ( ; nTempIndizes--; )
+        for ( ; nTempIndices--; )
         {
-            sal_Int32 nIndex = pTempIndizes[nTempIndizes];
-            typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndizes];
+            sal_Int32 nIndex = pTempIndices[nTempIndices];
+            typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndices];
 
             if (pParams[nIndex].bIn)
             {
@@ -293,12 +293,12 @@ static void cpp_call(
         fillUnoException( __cxa_get_globals()->caughtExceptions, *ppUnoExc, pThis->getBridge()->getCpp2Uno() );
 
         // temporary params
-        for ( ; nTempIndizes--; )
+        for ( ; nTempIndices--; )
         {
-            sal_Int32 nIndex = pTempIndizes[nTempIndizes];
+            sal_Int32 nIndex = pTempIndices[nTempIndices];
             // destroy temp cpp param => cpp: every param was constructed
-            uno_destructData( pCppArgs[nIndex], ppTempParamTypeDescr[nTempIndizes], cpp_release );
-            TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndizes] );
+            uno_destructData( pCppArgs[nIndex], ppTempParamTypeDescr[nTempIndices], cpp_release );
+            TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndices] );
         }
         // return type
         if (pReturnTypeDescr)
diff --git a/bridges/source/cpp_uno/gcc3_solaris_intel/cpp2uno.cxx b/bridges/source/cpp_uno/gcc3_solaris_intel/cpp2uno.cxx
index 689e54f092b2..930f6d18e9b0 100644
--- a/bridges/source/cpp_uno/gcc3_solaris_intel/cpp2uno.cxx
+++ b/bridges/source/cpp_uno/gcc3_solaris_intel/cpp2uno.cxx
@@ -83,12 +83,12 @@ static typelib_TypeClass cpp2uno_call(
     // parameters
     void ** pUnoArgs = (void **)alloca( 4 * sizeof(void *) * nParams );
     void ** pCppArgs = pUnoArgs + nParams;
-    // indizes of values this have to be converted (interface conversion cpp<=>uno)
-    sal_Int32 * pTempIndizes = (sal_Int32 *)(pUnoArgs + (2 * nParams));
+    // indices of values this have to be converted (interface conversion cpp<=>uno)
+    sal_Int32 * pTempIndices = (sal_Int32 *)(pUnoArgs + (2 * nParams));
     // type descriptions for reconversions
     typelib_TypeDescription ** ppTempParamTypeDescr = (typelib_TypeDescription **)(pUnoArgs + (3 * nParams));
 
-    sal_Int32 nTempIndizes   = 0;
+    sal_Int32 nTempIndices   = 0;
 
     for ( sal_Int32 nPos = 0; nPos < nParams; ++nPos )
     {
@@ -120,9 +120,9 @@ static typelib_TypeClass cpp2uno_call(
             {
                 // uno out is unconstructed mem!
                 pUnoArgs[nPos] = alloca( pParamTypeDescr->nSize );
-                pTempIndizes[nTempIndizes] = nPos;
+                pTempIndices[nTempIndices] = nPos;
                 // will be released at reconversion
-                ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
             }
             // is in/inout
             else if (bridges::cpp_uno::shared::relatesToInterfaceType(
@@ -131,9 +131,9 @@ static typelib_TypeClass cpp2uno_call(
                 uno_copyAndConvertData( pUnoArgs[nPos] = alloca( pParamTypeDescr->nSize ),
                                         *(void **)pCppStack, pParamTypeDescr,
                                         pThis->getBridge()->getCpp2Uno() );
-                pTempIndizes[nTempIndizes] = nPos; // has to be reconverted
+                pTempIndices[nTempIndices] = nPos; // has to be reconverted
                 // will be released at reconversion
-                ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
             }
             else // direct way
             {
@@ -157,13 +157,13 @@ static typelib_TypeClass cpp2uno_call(
     if (pUnoExc)
     {
         // destruct temporary in/inout params
-        for ( ; nTempIndizes--; )
+        for ( ; nTempIndices--; )
         {
-            sal_Int32 nIndex = pTempIndizes[nTempIndizes];
+            sal_Int32 nIndex = pTempIndices[nTempIndices];
 
             if (pParams[nIndex].bIn) // is in/inout => was constructed
-                uno_destructData( pUnoArgs[nIndex], ppTempParamTypeDescr[nTempIndizes], 0 );
-            TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndizes] );
+                uno_destructData( pUnoArgs[nIndex], ppTempParamTypeDescr[nTempIndices], 0 );
+            TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndices] );
         }
         if (pReturnTypeDescr)
             TYPELIB_DANGER_RELEASE( pReturnTypeDescr );
@@ -177,10 +177,10 @@ static typelib_TypeClass cpp2uno_call(
     else // else no exception occurred...
     {
         // temporary params
-        for ( ; nTempIndizes--; )
+        for ( ; nTempIndices--; )
         {
-            sal_Int32 nIndex = pTempIndizes[nTempIndizes];
-            typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndizes];
+            sal_Int32 nIndex = pTempIndices[nTempIndices];
+            typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndices];
 
             if (pParams[nIndex].bOut) // inout/out
             {
diff --git a/bridges/source/cpp_uno/gcc3_solaris_intel/uno2cpp.cxx b/bridges/source/cpp_uno/gcc3_solaris_intel/uno2cpp.cxx
index 13ac8df07663..2999fffe886e 100644
--- a/bridges/source/cpp_uno/gcc3_solaris_intel/uno2cpp.cxx
+++ b/bridges/source/cpp_uno/gcc3_solaris_intel/uno2cpp.cxx
@@ -163,12 +163,12 @@ static void cpp_call(
     OSL_ENSURE( sizeof(void *) == sizeof(sal_Int32), "### unexpected size!" );
     // args
     void ** pCppArgs  = (void **)alloca( 3 * sizeof(void *) * nParams );
-    // indizes of values this have to be converted (interface conversion cpp<=>uno)
-    sal_Int32 * pTempIndizes = (sal_Int32 *)(pCppArgs + nParams);
+    // indices of values this have to be converted (interface conversion cpp<=>uno)
+    sal_Int32 * pTempIndices = (sal_Int32 *)(pCppArgs + nParams);
     // type descriptions for reconversions
     typelib_TypeDescription ** ppTempParamTypeDescr = (typelib_TypeDescription **)(pCppArgs + (2 * nParams));
 
-    sal_Int32 nTempIndizes   = 0;
+    sal_Int32 nTempIndices   = 0;
 
     for ( sal_Int32 nPos = 0; nPos < nParams; ++nPos )
     {
@@ -200,9 +200,9 @@ static void cpp_call(
                 uno_constructData(
                     *(void **)pCppStack = pCppArgs[nPos] = alloca( pParamTypeDescr->nSize ),
                     pParamTypeDescr );
-                pTempIndizes[nTempIndizes] = nPos; // default constructed for cpp call
+                pTempIndices[nTempIndices] = nPos; // default constructed for cpp call
                 // will be released at reconversion
-                ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
             }
             // is in/inout
             else if (bridges::cpp_uno::shared::relatesToInterfaceType(
@@ -213,9 +213,9 @@ static void cpp_call(
                     pUnoArgs[nPos], pParamTypeDescr,
                     pThis->getBridge()->getUno2Cpp() );
 
-                pTempIndizes[nTempIndizes] = nPos; // has to be reconverted
+                pTempIndices[nTempIndices] = nPos; // has to be reconverted
                 // will be released at reconversion
-                ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
             }
             else // direct way
             {
@@ -238,10 +238,10 @@ static void cpp_call(
         *ppUnoExc = 0;
 
         // reconvert temporary params
-        for ( ; nTempIndizes--; )
+        for ( ; nTempIndices--; )
         {
-            sal_Int32 nIndex = pTempIndizes[nTempIndizes];
-            typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndizes];
+            sal_Int32 nIndex = pTempIndices[nTempIndices];
+            typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndices];
 
             if (pParams[nIndex].bIn)
             {
@@ -276,12 +276,12 @@ static void cpp_call(
         fillUnoException( CPPU_CURRENT_NAMESPACE::__cxa_get_globals()->caughtExceptions, *ppUnoExc, pThis->getBridge()->getCpp2Uno() );
 
         // temporary params
-        for ( ; nTempIndizes--; )
+        for ( ; nTempIndices--; )
         {
-            sal_Int32 nIndex = pTempIndizes[nTempIndizes];
+            sal_Int32 nIndex = pTempIndices[nTempIndices];
             // destroy temp cpp param => cpp: every param was constructed
-            uno_destructData( pCppArgs[nIndex], ppTempParamTypeDescr[nTempIndizes], cpp_release );
-            TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndizes] );
+            uno_destructData( pCppArgs[nIndex], ppTempParamTypeDescr[nTempIndices], cpp_release );
+            TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndices] );
         }
         // return type
         if (pReturnTypeDescr)
diff --git a/bridges/source/cpp_uno/gcc3_solaris_sparc/cpp2uno.cxx b/bridges/source/cpp_uno/gcc3_solaris_sparc/cpp2uno.cxx
index 456b44e73f3a..af388d592d6a 100644
--- a/bridges/source/cpp_uno/gcc3_solaris_sparc/cpp2uno.cxx
+++ b/bridges/source/cpp_uno/gcc3_solaris_sparc/cpp2uno.cxx
@@ -73,12 +73,12 @@ static typelib_TypeClass cpp2uno_call(
     // parameters
     void ** pUnoArgs = (void **)alloca( 4 * sizeof(void *) * nParams );
     void ** pCppArgs = pUnoArgs + nParams;
-    // indizes of values this have to be converted (interface conversion cpp<=>uno)
-    sal_Int32 * pTempIndizes = (sal_Int32 *)(pUnoArgs + (2 * nParams));
+    // indices of values this have to be converted (interface conversion cpp<=>uno)
+    sal_Int32 * pTempIndices = (sal_Int32 *)(pUnoArgs + (2 * nParams));
     // type descriptions for reconversions
     typelib_TypeDescription ** ppTempParamTypeDescr = (typelib_TypeDescription **)(pUnoArgs + (3 * nParams));
 
-    sal_Int32 nTempIndizes   = 0;
+    sal_Int32 nTempIndices   = 0;
 
     for ( sal_Int32 nPos = 0; nPos < nParams; ++nPos )
     {
@@ -120,9 +120,9 @@ static typelib_TypeClass cpp2uno_call(
             {
                 // uno out is unconstructed mem!
                 pUnoArgs[nPos] = alloca( pParamTypeDescr->nSize );
-                pTempIndizes[nTempIndizes] = nPos;
+                pTempIndices[nTempIndices] = nPos;
                 // will be released at reconversion
-                ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
             }
             // is in/inout
             else if (bridges::cpp_uno::shared::relatesToInterfaceType(
@@ -131,9 +131,9 @@ static typelib_TypeClass cpp2uno_call(
                 uno_copyAndConvertData( pUnoArgs[nPos] = alloca( pParamTypeDescr->nSize ),
                                         *(void **)pCppStack, pParamTypeDescr,
                                           pThis->getBridge()->getCpp2Uno() );
-                pTempIndizes[nTempIndizes] = nPos; // has to be reconverted
+                pTempIndices[nTempIndices] = nPos; // has to be reconverted
                 // will be released at reconversion
-                ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
             }
             else // direct way
             {
@@ -156,13 +156,13 @@ static typelib_TypeClass cpp2uno_call(
     if (pUnoExc)
     {
         // destruct temporary in/inout params
-        for ( ; nTempIndizes--; )
+        for ( ; nTempIndices--; )
         {
-            sal_Int32 nIndex = pTempIndizes[nTempIndizes];
+            sal_Int32 nIndex = pTempIndices[nTempIndices];
 
             if (pParams[nIndex].bIn) // is in/inout => was constructed
-                uno_destructData( pUnoArgs[nIndex], ppTempParamTypeDescr[nTempIndizes], 0 );
-            TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndizes] );
+                uno_destructData( pUnoArgs[nIndex], ppTempParamTypeDescr[nTempIndices], 0 );
+            TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndices] );
         }
         if (pReturnTypeDescr)
             TYPELIB_DANGER_RELEASE( pReturnTypeDescr );
@@ -174,10 +174,10 @@ static typelib_TypeClass cpp2uno_call(
     else // else no exception occurred...
     {
         // temporary params
-        for ( ; nTempIndizes--; )
+        for ( ; nTempIndices--; )
         {
-            sal_Int32 nIndex = pTempIndizes[nTempIndizes];
-            typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndizes];
+            sal_Int32 nIndex = pTempIndices[nTempIndices];
+            typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndices];
 
             if (pParams[nIndex].bOut) // inout/out
             {
diff --git a/bridges/source/cpp_uno/gcc3_solaris_sparc/uno2cpp.cxx b/bridges/source/cpp_uno/gcc3_solaris_sparc/uno2cpp.cxx
index ae9f0b889ebc..a794fa520962 100644
--- a/bridges/source/cpp_uno/gcc3_solaris_sparc/uno2cpp.cxx
+++ b/bridges/source/cpp_uno/gcc3_solaris_sparc/uno2cpp.cxx
@@ -312,12 +312,12 @@ static void cpp_call(
     OSL_ENSURE( sizeof(void *) == sizeof(sal_Int32), "### unexpected size!" );
     // args
     void ** pCppArgs  = (void **)alloca( 3 * sizeof(void *) * nParams );
-    // indizes of values this have to be converted (interface conversion cpp<=>uno)
-    sal_Int32 * pTempIndizes = (sal_Int32 *)(pCppArgs + nParams);
+    // indices of values this have to be converted (interface conversion cpp<=>uno)
+    sal_Int32 * pTempIndices = (sal_Int32 *)(pCppArgs + nParams);
     // type descriptions for reconversions
     typelib_TypeDescription ** ppTempParamTypeDescr = (typelib_TypeDescription **)(pCppArgs + (2 * nParams));
 
-    sal_Int32 nTempIndizes   = 0;
+    sal_Int32 nTempIndices   = 0;
 
     for ( sal_Int32 nPos = 0; nPos < nParams; ++nPos )
     {
@@ -357,9 +357,9 @@ static void cpp_call(
                 uno_constructData(
                     *(void **)pCppStack = pCppArgs[nPos] = alloca( pParamTypeDescr->nSize ),
                     pParamTypeDescr );
-                pTempIndizes[nTempIndizes] = nPos; // default constructed for cpp call
+                pTempIndices[nTempIndices] = nPos; // default constructed for cpp call
                 // will be released at reconversion
-                ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
             }
             // is in/inout
             else if (bridges::cpp_uno::shared::relatesToInterfaceType(
@@ -370,9 +370,9 @@ static void cpp_call(
                                     pUnoArgs[nPos], pParamTypeDescr,
                     pThis->getBridge()->getUno2Cpp() );
 
-                pTempIndizes[nTempIndizes] = nPos; // has to be reconverted
+                pTempIndices[nTempIndices] = nPos; // has to be reconverted
                 // will be released at reconversion
-                ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
             }
             else // direct way
             {
@@ -403,10 +403,10 @@ static void cpp_call(
         *ppUnoExc = 0;
 
         // reconvert temporary params
-        for ( ; nTempIndizes--; )
+        for ( ; nTempIndices--; )
         {
-            sal_Int32 nIndex = pTempIndizes[nTempIndizes];
-            typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndizes];
+            sal_Int32 nIndex = pTempIndices[nTempIndices];
+            typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndices];
 
             if (pParams[nIndex].bIn)
             {
@@ -442,12 +442,12 @@ static void cpp_call(
                                 *ppUnoExc, pThis->getBridge()->getCpp2Uno() );
 
         // temporary params
-        for ( ; nTempIndizes--; )
+        for ( ; nTempIndices--; )
         {
-            sal_Int32 nIndex = pTempIndizes[nTempIndizes];
+            sal_Int32 nIndex = pTempIndices[nTempIndices];
             // destroy temp cpp param => cpp: every param was constructed
-            uno_destructData( pCppArgs[nIndex], ppTempParamTypeDescr[nTempIndizes], cpp_release );
-            TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndizes] );
+            uno_destructData( pCppArgs[nIndex], ppTempParamTypeDescr[nTempIndices], cpp_release );
+            TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndices] );
         }
         // return type
         if (pReturnTypeDescr)
diff --git a/bridges/source/cpp_uno/mingw_intel/cpp2uno.cxx b/bridges/source/cpp_uno/mingw_intel/cpp2uno.cxx
index e87512a571fc..20fc8994c3a7 100644
--- a/bridges/source/cpp_uno/mingw_intel/cpp2uno.cxx
+++ b/bridges/source/cpp_uno/mingw_intel/cpp2uno.cxx
@@ -87,12 +87,12 @@ void cpp2uno_call(
     // parameters
     void ** pUnoArgs = (void **)alloca( 4 * sizeof(void *) * nParams );
     void ** pCppArgs = pUnoArgs + nParams;
-    // indizes of values this have to be converted (interface conversion cpp<=>uno)
-    sal_Int32 * pTempIndizes = (sal_Int32 *)(pUnoArgs + (2 * nParams));
+    // indices of values this have to be converted (interface conversion cpp<=>uno)
+    sal_Int32 * pTempIndices = (sal_Int32 *)(pUnoArgs + (2 * nParams));
     // type descriptions for reconversions
     typelib_TypeDescription ** ppTempParamTypeDescr = (typelib_TypeDescription **)(pUnoArgs + (3 * nParams));
 
-    sal_Int32 nTempIndizes   = 0;
+    sal_Int32 nTempIndices   = 0;
 
     for ( sal_Int32 nPos = 0; nPos < nParams; ++nPos )
     {
@@ -127,9 +127,9 @@ void cpp2uno_call(
             {
                 // uno out is unconstructed mem!
                 pUnoArgs[nPos] = alloca( pParamTypeDescr->nSize );
-                pTempIndizes[nTempIndizes] = nPos;
+                pTempIndices[nTempIndices] = nPos;
                 // will be released at reconversion
-                ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
             }
             // is in/inout
             else if (bridges::cpp_uno::shared::relatesToInterfaceType(
@@ -138,9 +138,9 @@ void cpp2uno_call(
                 uno_copyAndConvertData( pUnoArgs[nPos] = alloca( pParamTypeDescr->nSize ),
                                         *(void **)pCppStack, pParamTypeDescr,
                                         pThis->getBridge()->getCpp2Uno() );
-                pTempIndizes[nTempIndizes] = nPos; // has to be reconverted
+                pTempIndices[nTempIndices] = nPos; // has to be reconverted
                 // will be released at reconversion
-                ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
             }
             else // direct way
             {
@@ -164,13 +164,13 @@ void cpp2uno_call(
     if (pUnoExc)
     {
         // destruct temporary in/inout params
-        for ( ; nTempIndizes--; )
+        for ( ; nTempIndices--; )
         {
-            sal_Int32 nIndex = pTempIndizes[nTempIndizes];
+            sal_Int32 nIndex = pTempIndices[nTempIndices];
 
             if (pParams[nIndex].bIn) // is in/inout => was constructed
-                uno_destructData( pUnoArgs[nIndex], ppTempParamTypeDescr[nTempIndizes], 0 );
-            TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndizes] );
+                uno_destructData( pUnoArgs[nIndex], ppTempParamTypeDescr[nTempIndices], 0 );
+            TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndices] );
         }
         if (pReturnTypeDescr)
             TYPELIB_DANGER_RELEASE( pReturnTypeDescr );
@@ -182,10 +182,10 @@ void cpp2uno_call(
     else // else no exception occurred...
     {
         // temporary params
-        for ( ; nTempIndizes--; )
+        for ( ; nTempIndices--; )
         {
-            sal_Int32 nIndex = pTempIndizes[nTempIndizes];
-            typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndizes];
+            sal_Int32 nIndex = pTempIndices[nTempIndices];
+            typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndices];
 
             if (pParams[nIndex].bOut) // inout/out
             {
diff --git a/bridges/source/cpp_uno/mingw_intel/uno2cpp.cxx b/bridges/source/cpp_uno/mingw_intel/uno2cpp.cxx
index 60a57a4b5a3b..2d9d10733fc3 100644
--- a/bridges/source/cpp_uno/mingw_intel/uno2cpp.cxx
+++ b/bridges/source/cpp_uno/mingw_intel/uno2cpp.cxx
@@ -99,12 +99,12 @@ static void cpp_call(
 #else
     void ** pCppArgs  = (void **)alloca( 3 * sizeof(void *) * nParams );
 #endif
-    // indizes of values this have to be converted (interface conversion cpp<=>uno)
-    sal_Int32 * pTempIndizes = (sal_Int32 *)(pCppArgs + nParams);
+    // indices of values this have to be converted (interface conversion cpp<=>uno)
+    sal_Int32 * pTempIndices = (sal_Int32 *)(pCppArgs + nParams);
     // type descriptions for reconversions
     typelib_TypeDescription ** ppTempParamTypeDescr = (typelib_TypeDescription **)(pCppArgs + (2 * nParams));
 
-    sal_Int32 nTempIndizes   = 0;
+    sal_Int32 nTempIndices   = 0;
 
     for ( sal_Int32 nPos = 0; nPos < nParams; ++nPos )
     {
@@ -143,9 +143,9 @@ static void cpp_call(
                     *(void **)pCppStack = pCppArgs[nPos] = alloca( pParamTypeDescr->nSize ),
 #endif
                     pParamTypeDescr );
-                pTempIndizes[nTempIndizes] = nPos; // default constructed for cpp call
+                pTempIndices[nTempIndices] = nPos; // default constructed for cpp call
                 // will be released at reconversion
-                ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
             }
             // is in/inout
             else if (bridges::cpp_uno::shared::relatesToInterfaceType(
@@ -160,9 +160,9 @@ static void cpp_call(
                     pUnoArgs[nPos], pParamTypeDescr,
                     pThis->getBridge()->getUno2Cpp() );
 
-                pTempIndizes[nTempIndizes] = nPos; // has to be reconverted
+                pTempIndices[nTempIndices] = nPos; // has to be reconverted
                 // will be released at reconversion
-                ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
             }
             else // direct way
             {
@@ -185,10 +185,10 @@ static void cpp_call(
         *ppUnoExc = 0;
 
         // reconvert temporary params
-        for ( ; nTempIndizes--; )
+        for ( ; nTempIndices--; )
         {
-            sal_Int32 nIndex = pTempIndizes[nTempIndizes];
-            typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndizes];
+            sal_Int32 nIndex = pTempIndices[nTempIndices];
+            typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndices];
 
             if (pParams[nIndex].bIn)
             {
@@ -226,12 +226,12 @@ static void cpp_call(
         fillUnoException( __cxa_get_globals()->caughtExceptions, *ppUnoExc, pThis->getBridge()->getCpp2Uno() );
 
         // temporary params
-        for ( ; nTempIndizes--; )
+        for ( ; nTempIndices--; )
         {
-            sal_Int32 nIndex = pTempIndizes[nTempIndizes];
+            sal_Int32 nIndex = pTempIndices[nTempIndices];
             // destroy temp cpp param => cpp: every param was constructed
-            uno_destructData( pCppArgs[nIndex], ppTempParamTypeDescr[nTempIndizes], cpp_release );
-            TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndizes] );
+            uno_destructData( pCppArgs[nIndex], ppTempParamTypeDescr[nTempIndices], cpp_release );
+            TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndices] );
 #ifdef BROKEN_ALLOCA
             free( pCppArgs[nIndex] );
 #endif
diff --git a/bridges/source/cpp_uno/mingw_x86-64/cpp2uno.cxx b/bridges/source/cpp_uno/mingw_x86-64/cpp2uno.cxx
index 7ba9b77660ea..1c4ea6695245 100644
--- a/bridges/source/cpp_uno/mingw_x86-64/cpp2uno.cxx
+++ b/bridges/source/cpp_uno/mingw_x86-64/cpp2uno.cxx
@@ -98,12 +98,12 @@ static typelib_TypeClass cpp2uno_call(
     // parameters
     void ** pUnoArgs = (void **)alloca( 4 * sizeof(void *) * nParams );
     void ** pCppArgs = pUnoArgs + nParams;
-    // indizes of values this have to be converted (interface conversion cpp<=>uno)
-    sal_Int32 * pTempIndizes = (sal_Int32 *)(pUnoArgs + (2 * nParams));
+    // indices of values this have to be converted (interface conversion cpp<=>uno)
+    sal_Int32 * pTempIndices = (sal_Int32 *)(pUnoArgs + (2 * nParams));
     // type descriptions for reconversions
     typelib_TypeDescription ** ppTempParamTypeDescr = (typelib_TypeDescription **)(pUnoArgs + (3 * nParams));
 
-    sal_Int32 nTempIndizes = 0;
+    sal_Int32 nTempIndices = 0;
 
     for ( sal_Int32 nPos = 0; nPos < nParams; ++nPos )
     {
@@ -159,18 +159,18 @@ static typelib_TypeClass cpp2uno_call(
             {
                 // uno out is unconstructed mem!
                 pUnoArgs[nPos] = alloca( pParamTypeDescr->nSize );
-                pTempIndizes[nTempIndizes] = nPos;
+                pTempIndices[nTempIndices] = nPos;
                 // will be released at reconversion
-                ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
             }
             else if ( bridges::cpp_uno::shared::relatesToInterfaceType( pParamTypeDescr ) ) // is in/inout
             {
                 uno_copyAndConvertData( pUnoArgs[nPos] = alloca( pParamTypeDescr->nSize ),
                                         pCppStack, pParamTypeDescr,
                                         pThis->getBridge()->getCpp2Uno() );
-                pTempIndizes[nTempIndizes] = nPos; // has to be reconverted
+                pTempIndices[nTempIndices] = nPos; // has to be reconverted
                 // will be released at reconversion
-                ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
             }
             else // direct way
             {
@@ -192,13 +192,13 @@ static typelib_TypeClass cpp2uno_call(
     if ( pUnoExc )
     {
         // destruct temporary in/inout params
-        for ( ; nTempIndizes--; )
+        for ( ; nTempIndices--; )
         {
-            sal_Int32 nIndex = pTempIndizes[nTempIndizes];
+            sal_Int32 nIndex = pTempIndices[nTempIndices];
 
             if (pParams[nIndex].bIn) // is in/inout => was constructed
-                uno_destructData( pUnoArgs[nIndex], ppTempParamTypeDescr[nTempIndizes], 0 );
-            TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndizes] );
+                uno_destructData( pUnoArgs[nIndex], ppTempParamTypeDescr[nTempIndices], 0 );
+            TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndices] );
         }
         if (pReturnTypeDescr)
             TYPELIB_DANGER_RELEASE( pReturnTypeDescr );
@@ -210,10 +210,10 @@ static typelib_TypeClass cpp2uno_call(
     else // else no exception occurred...
     {
         // temporary params
-        for ( ; nTempIndizes--; )
+        for ( ; nTempIndices--; )
         {
-            sal_Int32 nIndex = pTempIndizes[nTempIndizes];
-            typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndizes];
+            sal_Int32 nIndex = pTempIndices[nTempIndices];
+            typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndices];
 
             if ( pParams[nIndex].bOut ) // inout/out
             {
diff --git a/bridges/source/cpp_uno/mingw_x86-64/uno2cpp.cxx b/bridges/source/cpp_uno/mingw_x86-64/uno2cpp.cxx
index 2760f17625cc..6baa18e54cbc 100644
--- a/bridges/source/cpp_uno/mingw_x86-64/uno2cpp.cxx
+++ b/bridges/source/cpp_uno/mingw_x86-64/uno2cpp.cxx
@@ -140,12 +140,12 @@ static void cpp_call(
 
     // Args
     void ** pCppArgs = (void **)alloca( 3 * sizeof(void *) * nParams );
-    // Indizes of values this have to be converted (interface conversion cpp<=>uno)
-    sal_Int32 * pTempIndizes = (sal_Int32 *)(pCppArgs + nParams);
+    // Indices of values this have to be converted (interface conversion cpp<=>uno)
+    sal_Int32 * pTempIndices = (sal_Int32 *)(pCppArgs + nParams);
     // Type descriptions for reconversions
     typelib_TypeDescription ** ppTempParamTypeDescr = (typelib_TypeDescription **)(pCppArgs + (2 * nParams));
 
-    sal_Int32 nTempIndizes = 0;
+    sal_Int32 nTempIndices = 0;
 
     for ( sal_Int32 nPos = 0; nPos < nParams; ++nPos )
     {
@@ -197,9 +197,9 @@ static void cpp_call(
                 uno_constructData(
                     pCppArgs[nPos] = alloca( pParamTypeDescr->nSize ),
                     pParamTypeDescr );
-                pTempIndizes[nTempIndizes] = nPos; // default constructed for cpp call
+                pTempIndices[nTempIndices] = nPos; // default constructed for cpp call
                 // will be released at reconversion
-                ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
             }
             // is in/inout
             else if (bridges::cpp_uno::shared::relatesToInterfaceType( pParamTypeDescr ))
@@ -208,9 +208,9 @@ static void cpp_call(
                     pCppArgs[nPos] = alloca( pParamTypeDescr->nSize ),
                     pUnoArgs[nPos], pParamTypeDescr, pThis->getBridge()->getUno2Cpp() );
 
-                pTempIndizes[nTempIndizes] = nPos; // has to be reconverted
+                pTempIndices[nTempIndices] = nPos; // has to be reconverted
                 // will be released at reconversion
-                ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
             }
             else // direct way
             {
@@ -251,10 +251,10 @@ static void cpp_call(
         *ppUnoExc = 0;
 
         // reconvert temporary params
-        for ( ; nTempIndizes--; )
+        for ( ; nTempIndices--; )
         {
-            sal_Int32 nIndex = pTempIndizes[nTempIndizes];
-            typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndizes];
+            sal_Int32 nIndex = pTempIndices[nTempIndices];
+            typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndices];
 
             if (pParams[nIndex].bIn)
             {
@@ -289,12 +289,12 @@ static void cpp_call(
         fillUnoException( __cxa_get_globals()->caughtExceptions, *ppUnoExc, pThis->getBridge()->getCpp2Uno() );
 
         // temporary params
-        for ( ; nTempIndizes--; )
+        for ( ; nTempIndices--; )
         {
-            sal_Int32 nIndex = pTempIndizes[nTempIndizes];
+            sal_Int32 nIndex = pTempIndices[nTempIndices];
             // destroy temp cpp param => cpp: every param was constructed
-            uno_destructData( pCppArgs[nIndex], ppTempParamTypeDescr[nTempIndizes], cpp_release );
-            TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndizes] );
+            uno_destructData( pCppArgs[nIndex], ppTempParamTypeDescr[nTempIndices], cpp_release );
+            TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndices] );
         }
         // return type
         if (pReturnTypeDescr)
diff --git a/bridges/source/cpp_uno/msvc_win32_intel/cpp2uno.cxx b/bridges/source/cpp_uno/msvc_win32_intel/cpp2uno.cxx
index 038fd01b1e09..1b90694028ca 100644
--- a/bridges/source/cpp_uno/msvc_win32_intel/cpp2uno.cxx
+++ b/bridges/source/cpp_uno/msvc_win32_intel/cpp2uno.cxx
@@ -81,12 +81,12 @@ static inline typelib_TypeClass cpp2uno_call(
     // parameters
     void ** pUnoArgs = (void **)alloca( 4 * sizeof(void *) * nParams );
     void ** pCppArgs = pUnoArgs + nParams;
-    // indizes of values this have to be converted (interface conversion cpp<=>uno)
-    sal_Int32 * pTempIndizes = (sal_Int32 *)(pUnoArgs + (2 * nParams));
+    // indices of values this have to be converted (interface conversion cpp<=>uno)
+    sal_Int32 * pTempIndices = (sal_Int32 *)(pUnoArgs + (2 * nParams));
     // type descriptions for reconversions
     typelib_TypeDescription ** ppTempParamTypeDescr = (typelib_TypeDescription **)(pUnoArgs + (3 * nParams));
 
-    sal_Int32 nTempIndizes = 0;
+    sal_Int32 nTempIndices = 0;
 
     for ( sal_Int32 nPos = 0; nPos < nParams; ++nPos )
     {
@@ -121,9 +121,9 @@ static inline typelib_TypeClass cpp2uno_call(
             {
                 // uno out is unconstructed mem!
                 pUnoArgs[nPos] = alloca( pParamTypeDescr->nSize );
-                pTempIndizes[nTempIndizes] = nPos;
+                pTempIndices[nTempIndices] = nPos;
                 // will be released at reconversion
-                ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
             }
             // is in/inout
             else if (bridges::cpp_uno::shared::relatesToInterfaceType(
@@ -133,9 +133,9 @@ static inline typelib_TypeClass cpp2uno_call(
                     pUnoArgs[nPos] = alloca( pParamTypeDescr->nSize ),
                     *(void **)pCppStack, pParamTypeDescr,
                     pThis->getBridge()->getCpp2Uno() );
-                pTempIndizes[nTempIndizes] = nPos; // has to be reconverted
+                pTempIndices[nTempIndices] = nPos; // has to be reconverted
                 // will be released at reconversion
-                ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
             }
             else // direct way
             {
@@ -159,15 +159,15 @@ static inline typelib_TypeClass cpp2uno_call(
     if (pUnoExc)
     {
         // destruct temporary in/inout params
-        while (nTempIndizes--)
+        while (nTempIndices--)
         {
-            sal_Int32 nIndex = pTempIndizes[nTempIndizes];
+            sal_Int32 nIndex = pTempIndices[nTempIndices];
 
             if (pParams[nIndex].bIn) // is in/inout => was constructed
             {
-                ::uno_destructData( pUnoArgs[nIndex], ppTempParamTypeDescr[nTempIndizes], 0 );
+                ::uno_destructData( pUnoArgs[nIndex], ppTempParamTypeDescr[nTempIndices], 0 );
             }
-            TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndizes] );
+            TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndices] );
         }
         if (pReturnTypeDescr)
         {
@@ -183,10 +183,10 @@ static inline typelib_TypeClass cpp2uno_call(
     else // else no exception occurred...
     {
         // temporary params
-        while (nTempIndizes--)
+        while (nTempIndices--)
         {
-            sal_Int32 nIndex = pTempIndizes[nTempIndizes];
-            typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndizes];
+            sal_Int32 nIndex = pTempIndices[nTempIndices];
+            typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndices];
 
             if (pParams[nIndex].bOut) // inout/out
             {
diff --git a/bridges/source/cpp_uno/msvc_win32_intel/uno2cpp.cxx b/bridges/source/cpp_uno/msvc_win32_intel/uno2cpp.cxx
index 301e617c2505..33bfd5865f64 100644
--- a/bridges/source/cpp_uno/msvc_win32_intel/uno2cpp.cxx
+++ b/bridges/source/cpp_uno/msvc_win32_intel/uno2cpp.cxx
@@ -178,12 +178,12 @@ static void cpp_call(
     OSL_ENSURE( sizeof(void *) == sizeof(sal_Int32), "### unexpected size!" );
     // args
     void ** pCppArgs  = (void **)alloca( 3 * sizeof(void *) * nParams );
-    // indizes of values this have to be converted (interface conversion cpp<=>uno)
-    sal_Int32 * pTempIndizes = (sal_Int32 *)(pCppArgs + nParams);
+    // indices of values this have to be converted (interface conversion cpp<=>uno)
+    sal_Int32 * pTempIndices = (sal_Int32 *)(pCppArgs + nParams);
     // type descriptions for reconversions
     typelib_TypeDescription ** ppTempParamTypeDescr = (typelib_TypeDescription **)(pCppArgs + (2 * nParams));
 
-    sal_Int32 nTempIndizes   = 0;
+    sal_Int32 nTempIndices   = 0;
 
     for ( sal_Int32 nPos = 0; nPos < nParams; ++nPos )
     {
@@ -219,9 +219,9 @@ static void cpp_call(
                 ::uno_constructData(
                     *(void **)pCppStack = pCppArgs[nPos] = alloca( pParamTypeDescr->nSize ),
                     pParamTypeDescr );
-                pTempIndizes[nTempIndizes] = nPos; // default constructed for cpp call
+                pTempIndices[nTempIndices] = nPos; // default constructed for cpp call
                 // will be released at reconversion
-                ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
             }
             // is in/inout
             else if (bridges::cpp_uno::shared::relatesToInterfaceType(
@@ -232,9 +232,9 @@ static void cpp_call(
                     pUnoArgs[nPos], pParamTypeDescr,
                     pThis->getBridge()->getUno2Cpp() );
 
-                pTempIndizes[nTempIndizes] = nPos; // has to be reconverted
+                pTempIndices[nTempIndices] = nPos; // has to be reconverted
                 // will be released at reconversion
-                ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
+                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
             }
             else // direct way
             {
@@ -262,14 +262,14 @@ static void cpp_call(
    {
         // *ppUnoExc was constructed by filter function
         // temporary params
-        while (nTempIndizes--)
+        while (nTempIndices--)
         {
-            sal_Int32 nIndex = pTempIndizes[nTempIndizes];
+            sal_Int32 nIndex = pTempIndices[nTempIndices];
             // destroy temp cpp param => cpp: every param was constructed
             ::uno_destructData(
-                pCppArgs[nIndex], ppTempParamTypeDescr[nTempIndizes],
+                pCppArgs[nIndex], ppTempParamTypeDescr[nTempIndices],
                 cpp_release );
-            TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndizes] );
+            TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndices] );
         }
         // return type
         if (pReturnTypeDescr)
@@ -284,11 +284,11 @@ static void cpp_call(
     *ppUnoExc = 0;
 
     // reconvert temporary params
-    while (nTempIndizes--)
+    while (nTempIndices--)
     {
-        sal_Int32 nIndex = pTempIndizes[nTempIndizes];
+        sal_Int32 nIndex = pTempIndices[nTempIndices];
         typelib_TypeDescription * pParamTypeDescr =
-            ppTempParamTypeDescr[nTempIndizes];
+            ppTempParamTypeDescr[nTempIndices];
 
         if (pParams[nIndex].bIn)
         {
diff --git a/chart2/source/controller/chartapiwrapper/DataSeriesPointWrapper.hxx b/chart2/source/controller/chartapiwrapper/DataSeriesPointWrapper.hxx
index 09d5596979ed..3a1747a9d208 100644
--- a/chart2/source/controller/chartapiwrapper/DataSeriesPointWrapper.hxx
+++ b/chart2/source/controller/chartapiwrapper/DataSeriesPointWrapper.hxx
@@ -138,7 +138,7 @@ private:
 
     //this should only be used, if the DataSeriesPointWrapper is initialized via the XInitialize interface
     //because a big change in the chartmodel may leed to an dataseriespointer thats not connected to the model anymore
-    //with the indizes instead we are can aleays get the new dataseries
+    //with the indices instead we are can aleays get the new dataseries
     ::com::sun::star::uno::Reference<
         ::com::sun::star::chart2::XDataSeries >     m_xDataSeries;
 };
diff --git a/cui/source/options/optlingu.cxx b/cui/source/options/optlingu.cxx
index 8bbda6a2a8ea..19dfa713e955 100644
--- a/cui/source/options/optlingu.cxx
+++ b/cui/source/options/optlingu.cxx
@@ -1139,7 +1139,7 @@ SvxLinguTabPage::SvxLinguTabPage( Window* pParent, const SfxItemSet& rSet ) :
         // Also we have to take care to not loose the last reference when
         // someone else removes a dictionary from the list.
         // removed dics will be replaced by NULL new entries be added to the end
-        // Thus we may use indizes as consistent references.
+        // Thus we may use indices as consistent references.
         aDics = xDicList->getDictionaries();
 
         UpdateDicBox_Impl();
diff --git a/dbaccess/source/ui/dlg/dbfindex.cxx b/dbaccess/source/ui/dlg/dbfindex.cxx
index c96df2b413fc..37b4e95bf6b5 100644
--- a/dbaccess/source/ui/dlg/dbfindex.cxx
+++ b/dbaccess/source/ui/dlg/dbfindex.cxx
@@ -278,9 +278,9 @@ void ODbaseIndexDialog::Init()
     aIB_AddAll.Disable();
     aIB_RemoveAll.Disable();
 
-    // All indizes are first added to a list of free indizes.
+    // All indices are first added to a list of free indices.
     // Afterwards, check the index of each table in the Inf-file.
-    // These indizes are removed from the list of free indizes and
+    // These indices are removed from the list of free indices and
     // entered in the indexlist of the table.
 
     // if the string does not contain a path, cut the string
@@ -400,7 +400,7 @@ void ODbaseIndexDialog::SetCtrls()
         const OTableInfo& rTabInfo = m_aTableInfoList.front();
         aCB_Tables.SetText( rTabInfo.aTableName );
 
-        // build ListBox of the table indizes
+        // build ListBox of the table indices
         for (   ConstTableIndexListIterator aIndex = rTabInfo.aIndexList.begin();
                 aIndex != rTabInfo.aIndexList.end();
                 ++aIndex
@@ -411,7 +411,7 @@ void ODbaseIndexDialog::SetCtrls()
             aLB_TableIndexes.SelectEntryPos( 0 );
     }
 
-    // ListBox of the free indizes
+    // ListBox of the free indices
     for (   ConstTableIndexListIterator aFree = m_aFreeIndexList.begin();
             aFree != m_aFreeIndexList.end();
             ++aFree
@@ -443,7 +443,7 @@ void OTableInfo::WriteInfFile( const OUString& rDSN ) const
     Config aInfFile( aTransformer.get(OFileNotation::N_SYSTEM) );
     aInfFile.SetGroup( aGroupIdent );
 
-    // first, delete all table indizes
+    // first, delete all table indices
     OString aNDX;
     sal_uInt16 nKeyCnt = aInfFile.GetKeyCount();
     sal_uInt16 nKey = 0;
@@ -465,7 +465,7 @@ void OTableInfo::WriteInfFile( const OUString& rDSN ) const
 
     }
 
-    // now add all saved indizes
+    // now add all saved indices
     sal_uInt16 nPos = 0;
     for (   ConstTableIndexListIterator aIndex = aIndexList.begin();
             aIndex != aIndexList.end();
diff --git a/extensions/source/ole/unoconversionutilities.hxx b/extensions/source/ole/unoconversionutilities.hxx
index 46db5c9db7f4..918899613194 100644
--- a/extensions/source/ole/unoconversionutilities.hxx
+++ b/extensions/source/ole/unoconversionutilities.hxx
@@ -1069,7 +1069,7 @@ SAFEARRAY*  UnoConversionUtilities<T>::createUnoSequenceWrapper(const Any& rSeq,
                 uno_Sequence * pMultiSeq= *(uno_Sequence* const*) rSeq.getValue();
                 sal_Int32 dimsSeq= dims - 1;
 
-                // arDimSeqIndizes contains the current index of a block of data.
+                // arDimSeqIndices contains the current index of a block of data.
                 // E.g. Sequence<Sequence<sal_Int32>> , the index would refer to Sequence<sal_Int32>
                 // In this case arDimSeqIndices would have the size 1. That is the elements are not counted
                 // but the Sequences that contain those elements.
diff --git a/extensions/test/ole/cpnt/cpnt.cxx b/extensions/test/ole/cpnt/cpnt.cxx
index ae4604b42e6c..e938b87b79f3 100644
--- a/extensions/test/ole/cpnt/cpnt.cxx
+++ b/extensions/test/ole/cpnt/cpnt.cxx
@@ -1732,9 +1732,9 @@ void SAL_CALL OComponent::testInterface(  const Reference< XCallback >& xCallbac
 
             Reference<XInterface> xIntCallback= oleFact->createInstance(L"XCallback_Impl.Callback");
             Reference<XInvocation> xInv( xIntCallback, UNO_QUERY);
-            Sequence<sal_Int16> seqIndizes;
+            Sequence<sal_Int16> seqIndices;
             Sequence<Any> seqOutParams;
-            xInv->invoke( OUString( L"outValuesAll"), Sequence<Any>(), seqIndizes, seqOutParams);
+            xInv->invoke( OUString( L"outValuesAll"), Sequence<Any>(), seqIndices, seqOutParams);
 
             if( seqOutParams.getLength() == 12)
             {
@@ -1776,7 +1776,7 @@ void SAL_CALL OComponent::testInterface(  const Reference< XCallback >& xCallbac
 
             Reference<XInterface> xIntCallback= oleFact->createInstance(L"XCallback_Impl.Callback");
             Reference<XInvocation> xInv( xIntCallback, UNO_QUERY);
-            Sequence<sal_Int16> seqIndizes;
+            Sequence<sal_Int16> seqIndices;
             Sequence<Any> seqOutParams;
 
 
@@ -1829,7 +1829,7 @@ void SAL_CALL OComponent::testInterface(  const Reference< XCallback >& xCallbac
 //
             Sequence<Any> params( arAny, 13);
 
-            xInv->invoke( OUString( L"inoutValuesAll"), params, seqIndizes, seqOutParams);
+            xInv->invoke( OUString( L"inoutValuesAll"), params, seqIndices, seqOutParams);
 
             if( seqOutParams.getLength() == 12)
             {
@@ -1871,7 +1871,7 @@ void SAL_CALL OComponent::testInterface(  const Reference< XCallback >& xCallbac
 
             Reference<XInterface> xIntCallback= oleFact->createInstance(L"XCallback_Impl.Callback");
             Reference<XInvocation> xInv( xIntCallback, UNO_QUERY);
-            Sequence<sal_Int16> seqIndizes;
+            Sequence<sal_Int16> seqIndices;
             Sequence<Any> seqOutParams;
 
             Any arAny[3];
@@ -1882,7 +1882,7 @@ void SAL_CALL OComponent::testInterface(  const Reference< XCallback >& xCallbac
             OUString aString(L" a string parameter");
             arAny[2] <<= aString;
 
-            xInv->invoke( OUString( L"inValues"), Sequence<Any>(arAny,3), seqIndizes, seqOutParams);
+            xInv->invoke( OUString( L"inValues"), Sequence<Any>(arAny,3), seqIndices, seqOutParams);
 
             break;
         }
diff --git a/forms/source/component/GroupManager.hxx b/forms/source/component/GroupManager.hxx
index 484412525767..c9fa1ae639ba 100644
--- a/forms/source/component/GroupManager.hxx
+++ b/forms/source/component/GroupManager.hxx
@@ -178,9 +178,9 @@ DECLARE_STL_VECTOR(OGroupArr::iterator, OActiveGroups);
 //========================================================================
 class OGroupManager : public ::cppu::WeakImplHelper2< ::com::sun::star::beans::XPropertyChangeListener, ::com::sun::star::container::XContainerListener>
 {
-    OGroup*         m_pCompGroup;           // Alle Components nach TabIndizes sortiert
+    OGroup*         m_pCompGroup;           // Alle Components nach TabIndices sortiert
     OGroupArr       m_aGroupArr;            // Alle Components nach Gruppen sortiert
-    OActiveGroups   m_aActiveGroupMap;      // In dieser Map werden die Indizes aller Gruppen gehalten,
+    OActiveGroups   m_aActiveGroupMap;      // In dieser Map werden die Indices aller Gruppen gehalten,
                                         // die mehr als 1 Element haben
 
     ::com::sun::star::uno::Reference< ::com::sun::star::container::XContainer >
diff --git a/sc/source/core/tool/reffind.cxx b/sc/source/core/tool/reffind.cxx
index 3379c60ddfad..d329cfc86a87 100644
--- a/sc/source/core/tool/reffind.cxx
+++ b/sc/source/core/tool/reffind.cxx
@@ -273,7 +273,7 @@ void ScRefFinder::ToggleRel( sal_Int32 nStartPos, sal_Int32 nEndPos )
 
             if (!mnFound)                            // first reference ?
                 mnSelStart = nAbsStart;
-            mnSelEnd = nAbsStart + aExpr.getLength();        // selection, no indizes
+            mnSelEnd = nAbsStart + aExpr.getLength();        // selection, no indices
             ++mnFound;
         }
 
diff --git a/stoc/source/invocation/invocation.cxx b/stoc/source/invocation/invocation.cxx
index f6604f8befd9..b9084ab1c1ef 100644
--- a/stoc/source/invocation/invocation.cxx
+++ b/stoc/source/invocation/invocation.cxx
@@ -609,11 +609,11 @@ void Invocation_Impl::setValue( const OUString& PropertyName, const Any& Value )
 
 //--------------------------------------------------------------------------------------------------
 Any Invocation_Impl::invoke( const OUString& FunctionName, const Sequence<Any>& InParams,
-                                Sequence<sal_Int16>& OutIndizes, Sequence<Any>& OutParams )
+                                Sequence<sal_Int16>& OutIndices, Sequence<Any>& OutParams )
     throw( IllegalArgumentException, CannotConvertException, InvocationTargetException, RuntimeException )
 {
     if (_xDirect.is())
-        return _xDirect->invoke( FunctionName, InParams, OutIndizes, OutParams );
+        return _xDirect->invoke( FunctionName, InParams, OutIndices, OutParams );
 
     if (_xIntrospectionAccess.is())
     {
@@ -639,9 +639,9 @@ Any Invocation_Impl::invoke( const OUString& FunctionName, const Sequence<Any>&
         Sequence<Any> aInvokeParams( nFParamsLen );
         Any* pInvokeParams                  = aInvokeParams.getArray();
 
-        // OUT Indizes
-        OutIndizes.realloc( nFParamsLen );
-        sal_Int16* pOutIndizes              = OutIndizes.getArray();
+        // OUT Indices
+        OutIndices.realloc( nFParamsLen );
+        sal_Int16* pOutIndices              = OutIndices.getArray();
         sal_uInt32 nOutIndex                = 0;
 
         for ( sal_Int32 nPos = 0; nPos < nFParamsLen; ++nPos )
@@ -675,7 +675,7 @@ Any Invocation_Impl::invoke( const OUString& FunctionName, const Sequence<Any>&
                 // is OUT/INOUT parameter?
                 if (rFParam.aMode != ParamMode_IN)
                 {
-                    pOutIndizes[nOutIndex] = (sal_Int16)nPos;
+                    pOutIndices[nOutIndex] = (sal_Int16)nPos;
                     if (rFParam.aMode == ParamMode_OUT)
                         rDestType->createObject( pInvokeParams[nPos] );     // default init
                     ++nOutIndex;
@@ -692,14 +692,14 @@ Any Invocation_Impl::invoke( const OUString& FunctionName, const Sequence<Any>&
         Any aRet = xMethod->invoke( _aMaterial, aInvokeParams );
 
         // OUT Params
-        OutIndizes.realloc( nOutIndex );
-        pOutIndizes        = OutIndizes.getArray();
+        OutIndices.realloc( nOutIndex );
+        pOutIndices        = OutIndices.getArray();
         OutParams.realloc( nOutIndex );
         Any* pOutParams = OutParams.getArray();
 
         while (nOutIndex--)
         {
-            pOutParams[nOutIndex] = pInvokeParams[ pOutIndizes[nOutIndex] ];
+            pOutParams[nOutIndex] = pInvokeParams[ pOutIndices[nOutIndex] ];
         }
 
         return aRet;
diff --git a/sw/source/core/doc/docnew.cxx b/sw/source/core/doc/docnew.cxx
index d4ba831493fc..c4af46822c21 100644
--- a/sw/source/core/doc/docnew.cxx
+++ b/sw/source/core/doc/docnew.cxx
@@ -166,7 +166,7 @@ void StartGrammarChecking( SwDoc &rDoc )
 /*
  * internal functions
  */
-static void lcl_DelFmtIndizes( SwFmt* pFmt )
+static void lcl_DelFmtIndices( SwFmt* pFmt )
 {
     SwFmtCntnt &rFmtCntnt = (SwFmtCntnt&)pFmt->GetCntnt();
     if ( rFmtCntnt.GetCntntIdx() )
@@ -582,11 +582,11 @@ SwDoc::~SwDoc()
     // Any of the FrmFormats can still have indices registered.
     // These need to be destroyed now at the latest.
     BOOST_FOREACH( SwFrmFmt* pFmt, *mpFrmFmtTbl )
-        lcl_DelFmtIndizes( pFmt );
+        lcl_DelFmtIndices( pFmt );
     BOOST_FOREACH( SwFrmFmt* pFmt, *mpSpzFrmFmtTbl )
-        lcl_DelFmtIndizes( pFmt );
+        lcl_DelFmtIndices( pFmt );
     BOOST_FOREACH( SwSectionFmt* pFmt, *mpSectionFmtTbl )
-        lcl_DelFmtIndizes( pFmt );
+        lcl_DelFmtIndices( pFmt );
 
     // The formats/styles that follow depend on the default formats.
     // Destroy these only after destroying the FmtIndices, because the content
diff --git a/sw/source/core/undo/undel.cxx b/sw/source/core/undo/undel.cxx
index c6ac06c8b979..34e9fcb66729 100644
--- a/sw/source/core/undo/undel.cxx
+++ b/sw/source/core/undo/undel.cxx
@@ -75,7 +75,7 @@ static void lcl_MakeAutoFrms( const SwFrmFmts& rSpzArr, sal_uLong nMovedIndex )
 // the first and last paragraph of the selection will be handled outside this
 // function.
 // Here are the main steps of the function:
-// 1. Deletion/recording of content indizes of the selection: footnotes, fly
+// 1. Deletion/recording of content indices of the selection: footnotes, fly
 //    frames and bookmarks
 // Step 1 could shift all nodes by deletion of footnotes => nNdDiff will be set.
 // 2. If the paragraph where the selection ends, is the last content of a
@@ -124,7 +124,7 @@ SwUndoDelete::SwUndoDelete( SwPaM& rPam, sal_Bool bFullPara, sal_Bool bCalledByT
                         ? rPam.GetMark()
                         : rPam.GetPoint();
 
-    // Step 1. deletion/record of content indizes
+    // Step 1. deletion/record of content indices
     if( bDelFullPara )
     {
         OSL_ENSURE( rPam.HasMark(), "PaM ohne Mark" );
diff --git a/vbahelper/source/vbahelper/vbacolorformat.cxx b/vbahelper/source/vbahelper/vbacolorformat.cxx
index b3a8576fbc16..86e8c71f1071 100644
--- a/vbahelper/source/vbahelper/vbacolorformat.cxx
+++ b/vbahelper/source/vbahelper/vbacolorformat.cxx
@@ -24,9 +24,9 @@ using namespace ooo::vba;
 using namespace com::sun::star;
 
 sal_Int32
-MsoColorIndizes::getColorIndex( sal_Int32 nIndex )
+MsoColorIndices::getColorIndex( sal_Int32 nIndex )
 {
-    const static sal_Int32 COLORINDIZES[56] =
+    const static sal_Int32 COLORINDICES[56] =
     {   HAPICOLOR_BLACK, HAPICOLOR_WITHE, HAPICOLOR_RED, HAPICOLOR_BRIGHTGREEN, HAPICOLOR_BLUE, HAPICOLOR_YELLOW, HAPICOLOR_PINK,
         HAPICOLOR_TURQUOISE, HAPICOLOR_DARKRED, HAPICOLOR_GREEN, HAPICOLOR_DARKBLUE, HAPICOLOR_DARKYELLOW, HAPICOLOR_VIOLET,
         HAPICOLOR_TEAL, HAPICOLOR_GRAY_25_PERCENT, HAPICOLOR_GRAY_50_PERCENT, HAPICOLOR_PERIWINCKLE, HAPICOLOR_PLUM,
@@ -38,7 +38,7 @@ MsoColorIndizes::getColorIndex( sal_Int32 nIndex )
         HAPICOLOR_SEAGREEN, HAPICOLOR_NONAME, HAPICOLOR_OLIVEGREEN, HAPICOLOR_BROWN, HAPICOLOR_PLUM, HAPICOLOR_INDIGO,
         HAPICOLOR_GRAY_80_PERCENT
     };
-    return COLORINDIZES[nIndex];
+    return COLORINDICES[nIndex];
 }
 ScVbaColorFormat::ScVbaColorFormat( const uno::Reference< XHelperInterface >& xParent, const uno::Reference< uno::XComponentContext >& xContext, const uno::Reference< XHelperInterface > xInternalParent, const uno::Reference< drawing::XShape > xShape, const sal_Int16 nColorFormatType ) : ScVbaColorFormat_BASE( xParent, xContext ), m_xInternalParent( xInternalParent ), m_xShape( xShape ), m_nColorFormatType( nColorFormatType )
 {
@@ -123,7 +123,7 @@ ScVbaColorFormat::getSchemeColor() throw (uno::RuntimeException)
     sal_Int32 i = 0;
     for( ; i < 56; i++ )
     {
-        if( nColor == MsoColorIndizes::getColorIndex(i) )
+        if( nColor == MsoColorIndices::getColorIndex(i) )
        break;
     }
 
@@ -146,7 +146,7 @@ void SAL_CALL
 ScVbaColorFormat::setSchemeColor( sal_Int32 _schemecolor ) throw (uno::RuntimeException)
 {
     // the table is 0 based
-    sal_Int32 nColor = MsoColorIndizes::getColorIndex( _schemecolor );
+    sal_Int32 nColor = MsoColorIndices::getColorIndex( _schemecolor );
     // nColor is already xl RGB
     setRGB( nColor );
 }
diff --git a/vbahelper/source/vbahelper/vbacolorformat.hxx b/vbahelper/source/vbahelper/vbacolorformat.hxx
index 881a6439fee7..fef669cd4651 100644
--- a/vbahelper/source/vbahelper/vbacolorformat.hxx
+++ b/vbahelper/source/vbahelper/vbacolorformat.hxx
@@ -37,7 +37,7 @@ public:
     const static sal_Int16 THREEDFORMAT_EXTRUSIONCOLOR = 5;
 };
 
-struct MsoColorIndizes
+struct MsoColorIndices
 {
     const static sal_Int32 HAPICOLOR_BLACK = 0;
     const static sal_Int32 HAPICOLOR_WITHE = 16777215;
diff --git a/vcl/generic/glyphs/gcach_ftyp.cxx b/vcl/generic/glyphs/gcach_ftyp.cxx
index ff0a428122e0..2bd1e0fbd977 100644
--- a/vcl/generic/glyphs/gcach_ftyp.cxx
+++ b/vcl/generic/glyphs/gcach_ftyp.cxx
@@ -1819,7 +1819,7 @@ sal_uLong ServerFont::GetKernPairs( ImplKernPairData** ppKernPairs ) const
     {
         // prepare glyphindex to character mapping
         // TODO: this is needed to support VCL's existing kerning infrastructure,
-        // eliminate it up by redesigning kerning infrastructure to work with glyph indizes
+        // eliminate it up by redesigning kerning infrastructure to work with glyph indices
         typedef boost::unordered_multimap<sal_uInt16,sal_Unicode> Cmap;
         Cmap aCmap;
         for( sal_Unicode aChar = 0x0020; aChar < 0xFFFE; ++aChar )
@@ -1829,7 +1829,7 @@ sal_uLong ServerFont::GetKernPairs( ImplKernPairData** ppKernPairs ) const
                 aCmap.insert( Cmap::value_type( nGlyphIndex, aChar ) );
         }
 
-        // translate both glyph indizes in kerning pairs to characters
+        // translate both glyph indices in kerning pairs to characters
         // problem is that these are 1:n mappings...
         KernVector aKernCharVector;
         aKernCharVector.reserve( nKernCount );