Restoring authorship annotation for <neksard@yandex-team.ru>. Commit 1 of 2.

1 files changed, 213 insertions, 213 deletions

diff --git a/contrib/libs/icu/common/uvectr64.cpp b/contrib/libs/icu/common/uvectr64.cpp
index 081565959c..fbfad5e6b2 100644
--- a/contrib/libs/icu/common/uvectr64.cpp
+++ b/contrib/libs/icu/common/uvectr64.cpp
@@ -1,214 +1,214 @@
 // © 2016 and later: Unicode, Inc. and others.
-// License & terms of use: http://www.unicode.org/copyright.html
-/*
-******************************************************************************
-* Copyright (C) 1999-2015, International Business Machines Corporation and
-* others. All Rights Reserved.
-******************************************************************************
-*/
-
-#include "uvectr64.h"
-#include "cmemory.h"
-#include "putilimp.h"
-
-U_NAMESPACE_BEGIN
-
-#define DEFAULT_CAPACITY 8
-
-/*
- * Constants for hinting whether a key is an integer
- * or a pointer.  If a hint bit is zero, then the associated
- * token is assumed to be an integer. This is needed for iSeries
- */
- 
-UOBJECT_DEFINE_RTTI_IMPLEMENTATION(UVector64)
-
-UVector64::UVector64(UErrorCode &status) :
-    count(0),
-    capacity(0),
-    maxCapacity(0),
-    elements(NULL)
-{
-    _init(DEFAULT_CAPACITY, status);
-}
-
-UVector64::UVector64(int32_t initialCapacity, UErrorCode &status) :
-    count(0),
-    capacity(0),
-    maxCapacity(0),
-    elements(0)
-{
-    _init(initialCapacity, status);
-}
-
-
-
-void UVector64::_init(int32_t initialCapacity, UErrorCode &status) {
-    // Fix bogus initialCapacity values; avoid malloc(0)
-    if (initialCapacity < 1) {
-        initialCapacity = DEFAULT_CAPACITY;
-    }
-    if (maxCapacity>0 && maxCapacity<initialCapacity) {
-        initialCapacity = maxCapacity;
-    }
-    if (initialCapacity > (int32_t)(INT32_MAX / sizeof(int64_t))) {
-        initialCapacity = uprv_min(DEFAULT_CAPACITY, maxCapacity);
-    }
-    elements = (int64_t *)uprv_malloc(sizeof(int64_t)*initialCapacity);
-    if (elements == 0) {
-        status = U_MEMORY_ALLOCATION_ERROR;
-    } else {
-        capacity = initialCapacity;
-    }
-}
-
-UVector64::~UVector64() {
-    uprv_free(elements);
-    elements = 0;
-}
-
-/**
- * Assign this object to another (make this a copy of 'other').
- */
-void UVector64::assign(const UVector64& other, UErrorCode &ec) {
-    if (ensureCapacity(other.count, ec)) {
-        setSize(other.count);
-        for (int32_t i=0; i<other.count; ++i) {
-            elements[i] = other.elements[i];
-        }
-    }
-}
-
-
-UBool UVector64::operator==(const UVector64& other) {
-    int32_t i;
-    if (count != other.count) return FALSE;
-    for (i=0; i<count; ++i) {
-        if (elements[i] != other.elements[i]) {
-            return FALSE;
-        }
-    }
-    return TRUE;
-}
-
-
-void UVector64::setElementAt(int64_t elem, int32_t index) {
-    if (0 <= index && index < count) {
-        elements[index] = elem;
-    }
-    /* else index out of range */
-}
-
-void UVector64::insertElementAt(int64_t elem, int32_t index, UErrorCode &status) {
-    // must have 0 <= index <= count
-    if (0 <= index && index <= count && ensureCapacity(count + 1, status)) {
-        for (int32_t i=count; i>index; --i) {
-            elements[i] = elements[i-1];
-        }
-        elements[index] = elem;
-        ++count;
-    }
-    /* else index out of range */
-}
-
-void UVector64::removeAllElements(void) {
-    count = 0;
-}
-
-UBool UVector64::expandCapacity(int32_t minimumCapacity, UErrorCode &status) {
-    if (U_FAILURE(status)) {
-        return FALSE;
-    }
-    if (minimumCapacity < 0) {
-        status = U_ILLEGAL_ARGUMENT_ERROR;
-        return FALSE;
-    }
-    if (capacity >= minimumCapacity) {
-        return TRUE;
-    }
-    if (maxCapacity>0 && minimumCapacity>maxCapacity) {
-        status = U_BUFFER_OVERFLOW_ERROR;
-        return FALSE;
-    }
-    if (capacity > (INT32_MAX - 1) / 2) {  // integer overflow check
-        status = U_ILLEGAL_ARGUMENT_ERROR;
-        return FALSE;
-    }
-    int32_t newCap = capacity * 2;
-    if (newCap < minimumCapacity) {
-        newCap = minimumCapacity;
-    }
-    if (maxCapacity > 0 && newCap > maxCapacity) {
-        newCap = maxCapacity;
-    }
-    if (newCap > (int32_t)(INT32_MAX / sizeof(int64_t))) {  // integer overflow check
-        // We keep the original memory contents on bad minimumCapacity/maxCapacity.
-        status = U_ILLEGAL_ARGUMENT_ERROR;
-        return FALSE;
-    }
-    int64_t* newElems = (int64_t *)uprv_realloc(elements, sizeof(int64_t)*newCap);
-    if (newElems == NULL) {
-        // We keep the original contents on the memory failure on realloc.
-        status = U_MEMORY_ALLOCATION_ERROR;
-        return FALSE;
-    }
-    elements = newElems;
-    capacity = newCap;
-    return TRUE;
-}
-
-void UVector64::setMaxCapacity(int32_t limit) {
-    U_ASSERT(limit >= 0);
-    if (limit < 0) {
-        limit = 0;
-    }
-    if (limit > (int32_t)(INT32_MAX / sizeof(int64_t))) {  // integer overflow check for realloc
-        //  Something is very wrong, don't realloc, leave capacity and maxCapacity unchanged
-        return;
-    }
-    maxCapacity = limit;
-    if (capacity <= maxCapacity || maxCapacity == 0) {
-        // Current capacity is within the new limit.
-        return;
-    }
-    
-    // New maximum capacity is smaller than the current size.
-    // Realloc the storage to the new, smaller size.
-    int64_t* newElems = (int64_t *)uprv_realloc(elements, sizeof(int64_t)*maxCapacity);
-    if (newElems == NULL) {
-        // Realloc to smaller failed.
-        //   Just keep what we had.  No need to call it a failure.
-        return;
-    }
-    elements = newElems;
-    capacity = maxCapacity;
-    if (count > capacity) {
-        count = capacity;
-    }
-}
-
-/**
- * Change the size of this vector as follows: If newSize is smaller,
- * then truncate the array, possibly deleting held elements for i >=
- * newSize.  If newSize is larger, grow the array, filling in new
- * slots with NULL.
- */
-void UVector64::setSize(int32_t newSize) {
-    int32_t i;
-    if (newSize < 0) {
-        return;
-    }
-    if (newSize > count) {
-        UErrorCode ec = U_ZERO_ERROR;
-        if (!ensureCapacity(newSize, ec)) {
-            return;
-        }
-        for (i=count; i<newSize; ++i) {
-            elements[i] = 0;
-        }
-    } 
-    count = newSize;
-}
-
-U_NAMESPACE_END
-
+// License & terms of use: http://www.unicode.org/copyright.html 
+/* 
+****************************************************************************** 
+* Copyright (C) 1999-2015, International Business Machines Corporation and 
+* others. All Rights Reserved. 
+****************************************************************************** 
+*/ 
+ 
+#include "uvectr64.h" 
+#include "cmemory.h" 
+#include "putilimp.h" 
+ 
+U_NAMESPACE_BEGIN 
+ 
+#define DEFAULT_CAPACITY 8 
+ 
+/* 
+ * Constants for hinting whether a key is an integer 
+ * or a pointer.  If a hint bit is zero, then the associated 
+ * token is assumed to be an integer. This is needed for iSeries 
+ */ 
+  
+UOBJECT_DEFINE_RTTI_IMPLEMENTATION(UVector64) 
+ 
+UVector64::UVector64(UErrorCode &status) : 
+    count(0), 
+    capacity(0), 
+    maxCapacity(0), 
+    elements(NULL) 
+{ 
+    _init(DEFAULT_CAPACITY, status); 
+} 
+ 
+UVector64::UVector64(int32_t initialCapacity, UErrorCode &status) : 
+    count(0), 
+    capacity(0), 
+    maxCapacity(0), 
+    elements(0) 
+{ 
+    _init(initialCapacity, status); 
+} 
+ 
+ 
+ 
+void UVector64::_init(int32_t initialCapacity, UErrorCode &status) { 
+    // Fix bogus initialCapacity values; avoid malloc(0) 
+    if (initialCapacity < 1) { 
+        initialCapacity = DEFAULT_CAPACITY; 
+    } 
+    if (maxCapacity>0 && maxCapacity<initialCapacity) { 
+        initialCapacity = maxCapacity; 
+    } 
+    if (initialCapacity > (int32_t)(INT32_MAX / sizeof(int64_t))) { 
+        initialCapacity = uprv_min(DEFAULT_CAPACITY, maxCapacity); 
+    } 
+    elements = (int64_t *)uprv_malloc(sizeof(int64_t)*initialCapacity); 
+    if (elements == 0) { 
+        status = U_MEMORY_ALLOCATION_ERROR; 
+    } else { 
+        capacity = initialCapacity; 
+    } 
+} 
+ 
+UVector64::~UVector64() { 
+    uprv_free(elements); 
+    elements = 0; 
+} 
+ 
+/** 
+ * Assign this object to another (make this a copy of 'other'). 
+ */ 
+void UVector64::assign(const UVector64& other, UErrorCode &ec) { 
+    if (ensureCapacity(other.count, ec)) { 
+        setSize(other.count); 
+        for (int32_t i=0; i<other.count; ++i) { 
+            elements[i] = other.elements[i]; 
+        } 
+    } 
+} 
+ 
+ 
+UBool UVector64::operator==(const UVector64& other) { 
+    int32_t i; 
+    if (count != other.count) return FALSE; 
+    for (i=0; i<count; ++i) { 
+        if (elements[i] != other.elements[i]) { 
+            return FALSE; 
+        } 
+    } 
+    return TRUE; 
+} 
+ 
+ 
+void UVector64::setElementAt(int64_t elem, int32_t index) { 
+    if (0 <= index && index < count) { 
+        elements[index] = elem; 
+    } 
+    /* else index out of range */ 
+} 
+ 
+void UVector64::insertElementAt(int64_t elem, int32_t index, UErrorCode &status) { 
+    // must have 0 <= index <= count 
+    if (0 <= index && index <= count && ensureCapacity(count + 1, status)) { 
+        for (int32_t i=count; i>index; --i) { 
+            elements[i] = elements[i-1]; 
+        } 
+        elements[index] = elem; 
+        ++count; 
+    } 
+    /* else index out of range */ 
+} 
+ 
+void UVector64::removeAllElements(void) { 
+    count = 0; 
+} 
+ 
+UBool UVector64::expandCapacity(int32_t minimumCapacity, UErrorCode &status) { 
+    if (U_FAILURE(status)) { 
+        return FALSE; 
+    } 
+    if (minimumCapacity < 0) { 
+        status = U_ILLEGAL_ARGUMENT_ERROR; 
+        return FALSE; 
+    } 
+    if (capacity >= minimumCapacity) { 
+        return TRUE; 
+    } 
+    if (maxCapacity>0 && minimumCapacity>maxCapacity) { 
+        status = U_BUFFER_OVERFLOW_ERROR; 
+        return FALSE; 
+    } 
+    if (capacity > (INT32_MAX - 1) / 2) {  // integer overflow check 
+        status = U_ILLEGAL_ARGUMENT_ERROR; 
+        return FALSE; 
+    } 
+    int32_t newCap = capacity * 2; 
+    if (newCap < minimumCapacity) { 
+        newCap = minimumCapacity; 
+    } 
+    if (maxCapacity > 0 && newCap > maxCapacity) { 
+        newCap = maxCapacity; 
+    } 
+    if (newCap > (int32_t)(INT32_MAX / sizeof(int64_t))) {  // integer overflow check 
+        // We keep the original memory contents on bad minimumCapacity/maxCapacity. 
+        status = U_ILLEGAL_ARGUMENT_ERROR; 
+        return FALSE; 
+    } 
+    int64_t* newElems = (int64_t *)uprv_realloc(elements, sizeof(int64_t)*newCap); 
+    if (newElems == NULL) { 
+        // We keep the original contents on the memory failure on realloc. 
+        status = U_MEMORY_ALLOCATION_ERROR; 
+        return FALSE; 
+    } 
+    elements = newElems; 
+    capacity = newCap; 
+    return TRUE; 
+} 
+ 
+void UVector64::setMaxCapacity(int32_t limit) { 
+    U_ASSERT(limit >= 0); 
+    if (limit < 0) { 
+        limit = 0; 
+    } 
+    if (limit > (int32_t)(INT32_MAX / sizeof(int64_t))) {  // integer overflow check for realloc 
+        //  Something is very wrong, don't realloc, leave capacity and maxCapacity unchanged 
+        return; 
+    } 
+    maxCapacity = limit; 
+    if (capacity <= maxCapacity || maxCapacity == 0) { 
+        // Current capacity is within the new limit. 
+        return; 
+    } 
+     
+    // New maximum capacity is smaller than the current size. 
+    // Realloc the storage to the new, smaller size. 
+    int64_t* newElems = (int64_t *)uprv_realloc(elements, sizeof(int64_t)*maxCapacity); 
+    if (newElems == NULL) { 
+        // Realloc to smaller failed. 
+        //   Just keep what we had.  No need to call it a failure. 
+        return; 
+    } 
+    elements = newElems; 
+    capacity = maxCapacity; 
+    if (count > capacity) { 
+        count = capacity; 
+    } 
+} 
+ 
+/** 
+ * Change the size of this vector as follows: If newSize is smaller, 
+ * then truncate the array, possibly deleting held elements for i >= 
+ * newSize.  If newSize is larger, grow the array, filling in new 
+ * slots with NULL. 
+ */ 
+void UVector64::setSize(int32_t newSize) { 
+    int32_t i; 
+    if (newSize < 0) { 
+        return; 
+    } 
+    if (newSize > count) { 
+        UErrorCode ec = U_ZERO_ERROR; 
+        if (!ensureCapacity(newSize, ec)) { 
+            return; 
+        } 
+        for (i=count; i<newSize; ++i) { 
+            elements[i] = 0; 
+        } 
+    }  
+    count = newSize; 
+} 
+ 
+U_NAMESPACE_END 
+