| 0,0 → 1,248 |
|---|
| #!/usr/bin/python2 |
| # -*- Mode: Python; py-indent-offset: 8 -*- |
| |
| # (C) Copyright Zack Rusin 2005 |
| # 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 |
| # on 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 NON-INFRINGEMENT. IN NO EVENT SHALL |
| # IBM AND/OR ITS SUPPLIERS 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. |
| # |
| # Authors: |
| # Zack Rusin <zack@kde.org> |
| |
| import license |
| import gl_XML |
| import sys, getopt |
| |
| class PrintGlEnums(gl_XML.gl_print_base): |
| |
| def __init__(self): |
| gl_XML.gl_print_base.__init__(self) |
| |
| self.name = "gl_enums.py (from Mesa)" |
| self.license = license.bsd_license_template % ( \ |
| """Copyright (C) 1999-2005 Brian Paul All Rights Reserved.""", "BRIAN PAUL") |
| self.enum_table = {} |
| |
| |
| def printRealHeader(self): |
| print '#include "main/glheader.h"' |
| print '#include "main/mfeatures.h"' |
| print '#include "main/enums.h"' |
| print '#include "main/imports.h"' |
| print '' |
| print 'typedef struct {' |
| print ' size_t offset;' |
| print ' int n;' |
| print '} enum_elt;' |
| print '' |
| return |
| |
| def print_code(self): |
| print """ |
| typedef int (*cfunc)(const void *, const void *); |
| |
| /** |
| * Compare a key name to an element in the \c all_enums array. |
| * |
| * \c bsearch always passes the key as the first parameter and the pointer |
| * to the array element as the second parameter. We can elimiate some |
| * extra work by taking advantage of that fact. |
| * |
| * \param a Pointer to the desired enum name. |
| * \param b Pointer to an element of the \c all_enums array. |
| */ |
| static int compar_name( const char *a, const enum_elt *b ) |
| { |
| return strcmp( a, & enum_string_table[ b->offset ] ); |
| } |
| |
| /** |
| * Compare a key enum value to an element in the \c all_enums array. |
| * |
| * \c bsearch always passes the key as the first parameter and the pointer |
| * to the array element as the second parameter. We can elimiate some |
| * extra work by taking advantage of that fact. |
| * |
| * \param a Pointer to the desired enum name. |
| * \param b Pointer to an index into the \c all_enums array. |
| */ |
| static int compar_nr( const int *a, const unsigned *b ) |
| { |
| return a[0] - all_enums[*b].n; |
| } |
| |
| |
| static char token_tmp[20]; |
| |
| const char *_mesa_lookup_enum_by_nr( int nr ) |
| { |
| unsigned * i; |
| |
| i = (unsigned *) _mesa_bsearch(& nr, reduced_enums, |
| Elements(reduced_enums), |
| sizeof(reduced_enums[0]), |
| (cfunc) compar_nr); |
| |
| if ( i != NULL ) { |
| return & enum_string_table[ all_enums[ *i ].offset ]; |
| } |
| else { |
| /* this is not re-entrant safe, no big deal here */ |
| _mesa_snprintf(token_tmp, sizeof(token_tmp) - 1, "0x%x", nr); |
| token_tmp[sizeof(token_tmp) - 1] = '\\0'; |
| return token_tmp; |
| } |
| } |
| |
| /* Get the name of an enum given that it is a primitive type. Avoids |
| * GL_FALSE/GL_POINTS ambiguity and others. |
| */ |
| const char *_mesa_lookup_prim_by_nr( int nr ) |
| { |
| switch (nr) { |
| case GL_POINTS: return "GL_POINTS"; |
| case GL_LINES: return "GL_LINES"; |
| case GL_LINE_STRIP: return "GL_LINE_STRIP"; |
| case GL_LINE_LOOP: return "GL_LINE_LOOP"; |
| case GL_TRIANGLES: return "GL_TRIANGLES"; |
| case GL_TRIANGLE_STRIP: return "GL_TRIANGLE_STRIP"; |
| case GL_TRIANGLE_FAN: return "GL_TRIANGLE_FAN"; |
| case GL_QUADS: return "GL_QUADS"; |
| case GL_QUAD_STRIP: return "GL_QUAD_STRIP"; |
| case GL_POLYGON: return "GL_POLYGON"; |
| case GL_POLYGON+1: return "OUTSIDE_BEGIN_END"; |
| default: return "<invalid>"; |
| } |
| } |
| |
| |
| |
| int _mesa_lookup_enum_by_name( const char *symbol ) |
| { |
| enum_elt * f = NULL; |
| |
| if ( symbol != NULL ) { |
| f = (enum_elt *) _mesa_bsearch(symbol, all_enums, |
| Elements(all_enums), |
| sizeof( enum_elt ), |
| (cfunc) compar_name); |
| } |
| |
| return (f != NULL) ? f->n : -1; |
| } |
| |
| """ |
| return |
| |
| |
| def printBody(self, api_list): |
| self.enum_table = {} |
| for api in api_list: |
| self.process_enums( api ) |
| |
| keys = self.enum_table.keys() |
| keys.sort() |
| |
| name_table = [] |
| enum_table = {} |
| |
| for enum in keys: |
| low_pri = 9 |
| for [name, pri] in self.enum_table[ enum ]: |
| name_table.append( [name, enum] ) |
| |
| if pri < low_pri: |
| low_pri = pri |
| enum_table[enum] = name |
| |
| |
| name_table.sort() |
| |
| string_offsets = {} |
| i = 0; |
| print 'LONGSTRING static const char enum_string_table[] = ' |
| for [name, enum] in name_table: |
| print ' "%s\\0"' % (name) |
| string_offsets[ name ] = i |
| i += len(name) + 1 |
| |
| print ' ;' |
| print '' |
| |
| |
| print 'static const enum_elt all_enums[%u] =' % (len(name_table)) |
| print '{' |
| for [name, enum] in name_table: |
| print ' { %5u, 0x%08X }, /* %s */' % (string_offsets[name], enum, name) |
| print '};' |
| print '' |
| |
| print 'static const unsigned reduced_enums[%u] =' % (len(keys)) |
| print '{' |
| for enum in keys: |
| name = enum_table[ enum ] |
| if [name, enum] not in name_table: |
| print ' /* Error! %s, 0x%04x */ 0,' % (name, enum) |
| else: |
| i = name_table.index( [name, enum] ) |
| |
| print ' %4u, /* %s */' % (i, name) |
| print '};' |
| |
| |
| self.print_code() |
| return |
| |
| |
| def process_enums(self, api): |
| for obj in api.enumIterateByName(): |
| if obj.value not in self.enum_table: |
| self.enum_table[ obj.value ] = [] |
| |
| |
| enum = self.enum_table[ obj.value ] |
| name = "GL_" + obj.name |
| priority = obj.priority() |
| already_in = False; |
| for n, p in enum: |
| if n == name: |
| already_in = True |
| if not already_in: |
| enum.append( [name, priority] ) |
| |
| |
| def show_usage(): |
| print "Usage: %s [-f input_file_name]" % sys.argv[0] |
| sys.exit(1) |
| |
| if __name__ == '__main__': |
| try: |
| (args, trail) = getopt.getopt(sys.argv[1:], "f:") |
| except Exception,e: |
| show_usage() |
| |
| api_list = [] |
| for (arg,val) in args: |
| if arg == "-f": |
| api = gl_XML.parse_GL_API( val ) |
| api_list.append(api); |
| |
| printer = PrintGlEnums() |
| printer.Print( api_list ) |