egl: Limit the EGL ver for android

[mesa.git] / src / egl / main / eglarray.c

diff --git a/src/egl/main/eglarray.c b/src/egl/main/eglarray.c
index e4faaf4d71e81d47dcbe7a9e9b6faac5e69dcaa3..ba6cb3e6a4e7b683fc9f39475c8fd02387860e8f 100644 (file)
--- a/src/egl/main/eglarray.c
+++ b/src/egl/main/eglarray.c
@@ -1,3 +1,32 @@
+/**************************************************************************
+ *
+ * Copyright 2010 LunarG, Inc.
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sub license, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ **************************************************************************/
+
+
+#include <assert.h>
 #include <stdlib.h>
 #include <string.h>
 
@@ -26,6 +55,7 @@ _eglGrowArray(_EGLArray *array)
    }
 
    array->Elements = elems;
+   array->MaxSize = new_size;
 
    return EGL_TRUE;
 }
@@ -82,6 +112,22 @@ _eglAppendArray(_EGLArray *array, void *elem)
 }
 
 
+/**
+ * Erase an element from an array.
+ */
+void
+_eglEraseArray(_EGLArray *array, EGLint i, void (*free_cb)(void *))
+{
+   if (free_cb)
+      free_cb(array->Elements[i]);
+   if (i < array->Size - 1) {
+      memmove(&array->Elements[i], &array->Elements[i + 1],
+            (array->Size - i - 1) * sizeof(array->Elements[0]));
+   }
+   array->Size--;
+}
+
+
 /**
  * Find in an array for the given element.
  */
@@ -101,38 +147,29 @@ _eglFindArray(_EGLArray *array, void *elem)
 
 
 /**
- * Filter an array and return the filtered data.  The returned data pointer
- * should be freed.
+ * Filter an array and return the number of filtered elements.
  */
-void **
-_eglFilterArray(_EGLArray *array, EGLint *size,
+EGLint
+_eglFilterArray(_EGLArray *array, void **data, EGLint size,
                 _EGLArrayForEach filter, void *filter_data)
 {
-   void **data;
    EGLint count = 0, i;
 
-   if (!array) {
-      *size = 0;
-      return malloc(0);
-   }
-
-   data = malloc(array->Size * sizeof(array->Elements[0]));
-   if (!data)
-      return NULL;
+   if (!array)
+      return 0;
 
-   if (filter) {
-      for (i = 0; i < array->Size; i++) {
-         if (filter(array->Elements[i], filter_data))
-            data[count++] = array->Elements[i];
+   assert(filter);
+   for (i = 0; i < array->Size; i++) {
+      if (filter(array->Elements[i], filter_data)) {
+         if (data && count < size)
+            data[count] = array->Elements[i];
+         count++;
       }
-   }
-   else {
-      memcpy(data, array->Elements, array->Size * sizeof(array->Elements[0]));
+      if (data && count >= size)
+         break;
    }
 
-   *size = count;
-
-   return data;
+   return count;
 }
 
 
@@ -149,8 +186,14 @@ _eglFlattenArray(_EGLArray *array, void *buffer, EGLint elem_size, EGLint size,
    if (!array)
       return 0;
 
-   count = (size < array->Size) ? size : array->Size;
+   count = array->Size;
    if (buffer) {
+      /* clamp size to 0 */
+      if (size < 0)
+         size = 0;
+      /* do not exceed buffer size */
+      if (count > size)
+         count = size;
       for (i = 0; i < count; i++)
          flatten(array->Elements[i],
                (void *) ((char *) buffer + elem_size * i));