src/mapi/glapi/gen/gl_enums.py

   1
   2 # (C) Copyright Zack Rusin 2005. All Rights Reserved.
   3 # Copyright (C) 2015 Intel Corporation
   4 # Copyright (C) 2015 Broadcom Corporation
   5 #
   6 # Permission is hereby granted, free of charge, to any person obtaining a
   7 # copy of this software and associated documentation files (the "Software"),
   8 # to deal in the Software without restriction, including without limitation
   9 # on the rights to use, copy, modify, merge, publish, distribute, sub
  10 # license, and/or sell copies of the Software, and to permit persons to whom
  11 # the Software is furnished to do so, subject to the following conditions:
  12 #
  13 # The above copyright notice and this permission notice (including the next
  14 # paragraph) shall be included in all copies or substantial portions of the
  15 # Software.
  16 #
  17 # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  18 # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19 # FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.  IN NO EVENT SHALL
  20 # IBM AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  21 # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  22 # FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  23 # IN THE SOFTWARE.
  24 #
  25 # Authors:
  26 #    Zack Rusin <zack@kde.org>
  27
  28 from __future__ import print_function
  29
  30 import argparse
  31
  32 import license
  33 import gl_XML
  34 import xml.etree.ElementTree as ET
  35 import sys, getopt
  36 import re
  37
  38 class PrintGlEnums(gl_XML.gl_print_base):
  39
  40     def __init__(self):
  41         gl_XML.gl_print_base.__init__(self)
  42
  43         self.name = "gl_enums.py (from Mesa)"
  44         self.license = license.bsd_license_template % ( \
  45 """Copyright (C) 1999-2005 Brian Paul All Rights Reserved.""", "BRIAN PAUL")
  46         # Mapping from enum value to (name, priority) tuples.
  47         self.enum_table = {}
  48         # Mapping from enum name to value
  49         self.string_to_int = {}
  50
  51
  52     def printRealHeader(self):
  53         print('#include "main/glheader.h"')
  54         print('#include "main/enums.h"')
  55         print('#include "util/imports.h"')
  56         print('#include "main/mtypes.h"')
  57         print('')
  58         print('typedef struct PACKED {')
  59         print('   uint32_t offset;')
  60         print('   int n;')
  61         print('} enum_elt;')
  62         print('')
  63         return
  64
  65     def print_code(self):
  66         print("""
  67 typedef int (*cfunc)(const void *, const void *);
  68
  69 /**
  70  * Compare a key enum value to an element in the \c enum_string_table_offsets array.
  71  *
  72  * \c bsearch always passes the key as the first parameter and the pointer
  73  * to the array element as the second parameter.  We can elimiate some
  74  * extra work by taking advantage of that fact.
  75  *
  76  * \param a  Pointer to the desired enum name.
  77  * \param b  Pointer into the \c enum_string_table_offsets array.
  78  */
  79 static int compar_nr( const int *a, enum_elt *b )
  80 {
  81    return a[0] - b->n;
  82 }
  83
  84
  85 static char token_tmp[20];
  86
  87 /**
  88  * This function always returns a string. If the number is a valid enum, it
  89  * returns the enum name. Otherwise, it returns a numeric string.
  90  */
  91 const char *
  92 _mesa_enum_to_string(int nr)
  93 {
  94    enum_elt *elt;
  95
  96    elt = bsearch(& nr, enum_string_table_offsets,
  97                  ARRAY_SIZE(enum_string_table_offsets),
  98                  sizeof(enum_string_table_offsets[0]),
  99                  (cfunc) compar_nr);
 100
 101    if (elt != NULL) {
 102       return &enum_string_table[elt->offset];
 103    }
 104    else {
 105       /* this is not re-entrant safe, no big deal here */
 106       _mesa_snprintf(token_tmp, sizeof(token_tmp) - 1, "0x%x", nr);
 107       token_tmp[sizeof(token_tmp) - 1] = '\\0';
 108       return token_tmp;
 109    }
 110 }
 111
 112 /**
 113  * Primitive names
 114  */
 115 static const char *prim_names[PRIM_MAX+3] = {
 116    "GL_POINTS",
 117    "GL_LINES",
 118    "GL_LINE_LOOP",
 119    "GL_LINE_STRIP",
 120    "GL_TRIANGLES",
 121    "GL_TRIANGLE_STRIP",
 122    "GL_TRIANGLE_FAN",
 123    "GL_QUADS",
 124    "GL_QUAD_STRIP",
 125    "GL_POLYGON",
 126    "GL_LINES_ADJACENCY",
 127    "GL_LINE_STRIP_ADJACENCY",
 128    "GL_TRIANGLES_ADJACENCY",
 129    "GL_TRIANGLE_STRIP_ADJACENCY",
 130    "GL_PATCHES",
 131    "outside begin/end",
 132    "unknown state"
 133 };
 134
 135
 136 /* Get the name of an enum given that it is a primitive type.  Avoids
 137  * GL_FALSE/GL_POINTS ambiguity and others.
 138  */
 139 const char *
 140 _mesa_lookup_prim_by_nr(GLuint nr)
 141 {
 142    if (nr < ARRAY_SIZE(prim_names))
 143       return prim_names[nr];
 144    else
 145       return "invalid mode";
 146 }
 147
 148
 149 """)
 150         return
 151
 152
 153     def printBody(self, xml):
 154         self.process_enums(xml)
 155
 156         sorted_enum_values = sorted(self.enum_table.keys())
 157         string_offsets = {}
 158         i = 0;
 159         print('#if defined(__GNUC__)')
 160         print('# define LONGSTRING __extension__')
 161         print('#else')
 162         print('# define LONGSTRING')
 163         print('#endif')
 164         print('')
 165         print('LONGSTRING static const char enum_string_table[] = {')
 166         # We express the very long concatenation of enum strings as an array
 167         # of characters rather than as a string literal to work-around MSVC's
 168         # 65535 character limit.
 169         for enum in sorted_enum_values:
 170             (name, pri) = self.enum_table[enum]
 171             print("  ", end=' ')
 172             for ch in name:
 173                 print("'%c'," % ch, end=' ')
 174             print("'\\0',")
 175
 176             string_offsets[ enum ] = i
 177             i += len(name) + 1
 178
 179         print('};')
 180         print('')
 181
 182
 183         print('static const enum_elt enum_string_table_offsets[%u] =' % (len(self.enum_table)))
 184         print('{')
 185         for enum in sorted_enum_values:
 186             (name, pri) = self.enum_table[enum]
 187             print('   { %5u, 0x%08X }, /* %s */' % (string_offsets[enum], enum, name))
 188         print('};')
 189         print('')
 190
 191         self.print_code()
 192         return
 193
 194     def add_enum_provider(self, name, priority):
 195         value = self.string_to_int[name]
 196
 197         # We don't want the weird GL_SKIP_COMPONENTS1_NV enums.
 198         if value < 0:
 199             return
 200         # We don't want the 64-bit GL_TIMEOUT_IGNORED "enums"
 201         if value > 0xffffffff:
 202             return
 203
 204         # We don't want bitfields in the enum-to-string table --
 205         # individual bits have so many names, it's pointless.  Note
 206         # that we check for power-of-two, since some getters have
 207         # "_BITS" in their name, but none have a power-of-two enum
 208         # number.
 209         if not (value & (value - 1)) and '_BIT' in name:
 210             return
 211
 212         # Also drop the GL_*_ATTRIB_BITS bitmasks.
 213         if value == 0xffffffff:
 214                 return
 215
 216         if value in self.enum_table:
 217             (n, p) = self.enum_table[value]
 218             if priority < p:
 219                 self.enum_table[value] = (name, priority)
 220         else:
 221             self.enum_table[value] = (name, priority)
 222
 223     def process_extension(self, extension):
 224         if extension.get('name').startswith('GL_ARB_'):
 225             extension_prio = 400
 226         elif extension.get('name').startswith('GL_EXT_'):
 227             extension_prio = 600
 228         else:
 229             extension_prio = 800
 230
 231         for enum in extension.findall('require/enum'):
 232             self.add_enum_provider(enum.get('name'), extension_prio)
 233
 234     def process_enums(self, xml):
 235         # First, process the XML entries that define the hex values
 236         # for all of the enum names.
 237         for enum in xml.findall('enums/enum'):
 238             name = enum.get('name')
 239             value = int(enum.get('value'), base=16)
 240
 241             # If the same name ever maps to multiple values, that can
 242             # confuse us.  GL_ACTIVE_PROGRAM_EXT is OK to lose because
 243             # we choose GL_ACTIVE PROGRAM instead.
 244             if name in self.string_to_int and name != "GL_ACTIVE_PROGRAM_EXT":
 245                 print("#error Renumbering {0} from {1} to {2}".format(name, self.string_to_int[name], value))
 246
 247             self.string_to_int[name] = value
 248
 249         # Now, process all of the API versions and extensions that
 250         # provide enums, so we can decide what name to call any hex
 251         # value.
 252         for feature in xml.findall('feature'):
 253             feature_name = feature.get('name')
 254
 255             # When an enum gets renamed in a newer version (generally
 256             # because of some generalization of the functionality),
 257             # prefer the newer name.  Also, prefer desktop GL names to
 258             # ES.
 259             m = re.match('GL_VERSION_([0-9])_([0-9])', feature_name)
 260             if m:
 261                 feature_prio = 100 - int(m.group(1) + m.group(2))
 262             else:
 263                 m = re.match('GL_ES_VERSION_([0-9])_([0-9])', feature_name)
 264                 if m:
 265                     feature_prio = 200 - int(m.group(1) + m.group(2))
 266                 else:
 267                     feature_prio = 200
 268
 269             for enum in feature.findall('require/enum'):
 270                 self.add_enum_provider(enum.get('name'), feature_prio)
 271
 272         for extension in xml.findall('extensions/extension'):
 273             self.process_extension(extension)
 274
 275
 276 def _parser():
 277     parser = argparse.ArgumentParser()
 278     parser.add_argument('-f', '--input_file',
 279                         required=True,
 280                         help="Choose an xml file to parse.")
 281     return parser.parse_args()
 282
 283
 284 def main():
 285     args = _parser()
 286     xml = ET.parse(args.input_file)
 287
 288     printer = PrintGlEnums()
 289     printer.Print(xml)
 290
 291
 292 if __name__ == '__main__':
 293     main()