Lines Matching refs:self
83 def __init__(self):
88 self.name = "a"
98 self.license = "The license for this file is unspecified."
107 self.header_tag = None
115 self.undef_list = []
119 def Print(self, api):
120 self.printHeader()
121 self.printBody(api)
122 self.printFooter()
126 def printHeader(self):
130 % (self.name))
133 print((' * ' + self.license.replace('\n', '\n * ')).replace(' \n', '\n'))
136 if self.header_tag:
137 print('#if !defined( %s )' % (self.header_tag))
138 print('# define %s' % (self.header_tag))
140 self.printRealHeader();
144 def printFooter(self):
147 self.printRealFooter()
149 if self.undef_list:
151 for u in self.undef_list:
154 if self.header_tag:
156 print('#endif /* !defined( %s ) */' % (self.header_tag))
159 def printRealHeader(self):
167 def printRealFooter(self):
175 def printPure(self):
185 self.undef_list.append("PURE")
194 def printFastcall(self):
205 self.undef_list.append("FASTCALL")
214 def printVisibility(self, S, s):
225 self.undef_list.append(S)
234 def printNoinline(self):
245 self.undef_list.append("NOINLINE")
325 def __init__(self, element, context, category):
326 self.context = context
327 self.name = element.get( "name" )
328 self.category = real_category_name( category )
334 def __init__(self, element, context, category):
335 gl_item.__init__(self, element, context, category)
336 self.size = int( element.get( "size" ), 0 )
344 tn.name = "GL" + self.name
347 self.type_expr = te
351 def get_type_expression(self):
352 return self.type_expr
356 def __init__(self, element, context, category):
357 gl_item.__init__(self, element, context, category)
358 self.value = int( element.get( "value" ), 0 )
362 self.default_count = -1
367 raise RuntimeError('Invalid count value "%s" for enum "%s" in function "%s" when an integer was expected.' % (temp, self.name, n))
369 self.default_count = c
374 def priority(self):
386 if self.name.endswith( "_BIT" ):
391 if self.category.startswith( "GL_VERSION_" ):
393 elif self.category.startswith( "GL_ARB_" ):
395 elif self.category.startswith( "GL_EXT_" ):
405 def __init__(self, element, context):
406 self.name = element.get( "name" )
409 self.type_expr = typeexpr.type_expression( ts, context )
413 self.count_parameter_list = temp.split( ' ' )
415 self.count_parameter_list = []
425 self.count = count
426 self.counter = None
429 self.count = 0
430 self.counter = c
432 self.marshal_count = element.get("marshal_count")
433 self.count_scale = int(element.get( "count_scale", "1" ))
435 elements = (count * self.count_scale)
440 # print '/* stack size -> %s = %u (before)*/' % (self.name, self.type_expr.get_stack_size())
442 self.type_expr.set_elements( elements )
444 # print '/* stack size -> %s = %u (after) */' % (self.name, self.type_expr.get_stack_size())
446 self.is_client_only = is_attr_true( element, 'client_only' )
447 self.is_counter = is_attr_true( element, 'counter' )
448 self.is_output = is_attr_true( element, 'output' )
453 self.width = element.get('img_width')
454 self.height = element.get('img_height')
455 self.depth = element.get('img_depth')
456 self.extent = element.get('img_extent')
458 self.img_xoff = element.get('img_xoff')
459 self.img_yoff = element.get('img_yoff')
460 self.img_zoff = element.get('img_zoff')
461 self.img_woff = element.get('img_woff')
463 self.img_format = element.get('img_format')
464 self.img_type = element.get('img_type')
465 self.img_target = element.get('img_target')
467 self.img_pad_dimensions = is_attr_true( element, 'img_pad_dimensions' )
468 self.img_null_flag = is_attr_true( element, 'img_null_flag' )
469 self.img_send_null = is_attr_true( element, 'img_send_null' )
471 self.is_padding = is_attr_true( element, 'padding' )
475 def compatible(self, other):
479 def is_array(self):
480 return self.is_pointer()
483 def is_pointer(self):
484 return self.type_expr.is_pointer()
487 def is_image(self):
488 if self.width:
494 def is_variable_length(self):
495 return len(self.count_parameter_list) or self.counter or self.marshal_count
498 def is_64_bit(self):
499 count = self.type_expr.get_element_count()
501 if (self.size() / count) == 8:
504 if self.size() == 8:
510 def string(self):
511 return self.type_expr.original_string + " " + self.name
514 def type_string(self):
515 return self.type_expr.original_string
518 def get_base_type_string(self):
519 return self.type_expr.get_base_name()
522 def get_dimensions(self):
523 if not self.width:
527 w = self.width
532 if self.height:
534 h = self.height
536 if self.depth:
538 d = self.depth
540 if self.extent:
542 e = self.extent
547 def get_stack_size(self):
548 return self.type_expr.get_stack_size()
551 def size(self):
552 if self.is_image():
555 return self.type_expr.get_element_size()
558 def get_element_count(self):
559 c = self.type_expr.get_element_count()
566 def size_string(self, use_parens = 1, marshal = 0):
569 count = self.get_element_count()
573 base_size_str += "sizeof(%s)" % ( self.get_base_type_string() )
575 if self.counter or self.count_parameter_list or (self.marshal_count and marshal):
578 if self.marshal_count and marshal:
579 list = [ self.marshal_count ]
580 elif self.counter and self.count_parameter_list:
581 list.append( self.counter )
582 elif self.counter:
583 list = [ self.counter ]
585 if self.size() > 1:
593 elif self.is_image():
599 def format_string(self):
600 if self.type_expr.original_string == "GLenum":
603 return self.type_expr.format_string()
607 def __init__(self, element, context):
608 self.context = context
609 self.name = None
611 self.entry_points = []
612 self.return_type = "void"
613 self.parameters = []
614 self.offset = -1
615 self.initialized = 0
616 self.images = []
617 self.exec_flavor = 'mesa'
618 self.desktop = True
619 self.deprecated = None
620 self.has_no_error_variant = False
622 # self.api_map[api] is a decimal value indicating the earliest
626 # function, self.api_map == { 'es1':
628 self.api_map = {}
630 self.assign_offset = False
632 self.static_entry_points = []
643 self.entry_point_parameters = {}
645 self.process_element( element )
650 def process_element(self, element):
662 self.static_entry_points.append(name)
664 self.entry_points.append( name )
671 if api not in self.api_map or \
672 version_decimal < self.api_map[api]:
673 self.api_map[api] = version_decimal
677 self.exec_flavor = exec_flavor
681 self.deprecated = Decimal(deprecated)
684 self.desktop = False
686 if self.has_no_error_variant or is_attr_true(element, 'no_error'):
687 self.has_no_error_variant = True
689 self.has_no_error_variant = False
700 self.offset = static_data.offsets[name]
702 self.offset = static_data.offsets[name]
703 self.assign_offset = True
705 if self.exec_flavor != "skip":
707 self.assign_offset = self.exec_flavor != "skip" or name in static_data.unused_functions
709 if not self.name:
710 self.name = true_name
711 elif self.name != true_name:
712 raise RuntimeError("Function true name redefined. Was %s, now %s." % (self.name, true_name))
716 # with data is seen, self.initialized will be 0. On that
718 # entry-point with data is seen, self.initialized will be 1.
728 param = self.context.factory.create_parameter(child, self.context)
732 if self.initialized:
733 if self.return_type != return_type:
734 raise RuntimeError( "Return type changed in %s. Was %s, now %s." % (name, self.return_type, return_type))
736 if len(parameters) != len(self.parameters):
737 raise RuntimeError( "Parameter count mismatch in %s. Was %d, now %d." % (name, len(self.parameters), len(parameters)))
741 p2 = self.parameters[j]
746 if true_name == name or not self.initialized:
747 self.return_type = return_type
748 self.parameters = parameters
750 for param in self.parameters:
752 self.images.append( param )
755 self.initialized = 1
756 self.entry_point_parameters[name] = parameters
758 self.entry_point_parameters[name] = []
762 def filter_entry_points(self, entry_point_list):
764 if not self.initialized:
765 raise RuntimeError('%s is not initialized yet' % self.name)
768 for ent in self.entry_points:
770 if ent in self.static_entry_points:
771 self.static_entry_points.remove(ent)
772 self.entry_point_parameters.pop(ent)
777 raise RuntimeError('%s has no entry point after filtering' % self.name)
779 self.entry_points = entry_points
780 if self.name not in entry_points:
782 self.name = entry_points[0]
783 self.parameters = self.entry_point_parameters[entry_points[0]]
785 def get_images(self):
787 return self.images
790 def parameterIterator(self, name = None):
792 return iter(self.entry_point_parameters[name]);
794 return iter(self.parameters);
797 def get_parameter_string(self, entrypoint = None):
799 params = self.entry_point_parameters[ entrypoint ]
801 params = self.parameters
805 def get_called_parameter_string(self):
809 for p in self.parameterIterator():
818 def is_abi(self):
819 return (self.offset >= 0 and not self.assign_offset)
821 def is_static_entry_point(self, name):
822 return name in self.static_entry_points
824 def dispatch_name(self):
825 if self.name in self.static_entry_points:
826 return self.name
828 return "_dispatch_stub_%u" % (self.offset)
830 def static_name(self, name):
831 if name in self.static_entry_points:
834 return "_dispatch_stub_%u" % (self.offset)
839 def create_function(self, element, context):
842 def create_type(self, element, context, category):
845 def create_enum(self, element, context, category):
848 def create_parameter(self, element, context):
851 def create_api(self):
852 return gl_api(self)
856 def __init__(self, factory):
857 self.functions_by_name = OrderedDict()
858 self.enums_by_name = {}
859 self.types_by_name = {}
861 self.category_dict = {}
862 self.categories = [{}, {}, {}, {}]
864 self.factory = factory
866 self.next_offset = 0
871 def parse_file(self, file_name):
873 self.process_element(file_name, doc)
876 def process_element(self, file_name, doc):
879 self.process_OpenGLAPI(file_name, element)
883 def process_OpenGLAPI(self, file_name, element):
886 self.process_category( child )
888 self.process_OpenGLAPI( file_name, child )
892 self.parse_file(href)
897 def process_category(self, cat):
902 self.categories[cat_type][key] = [cat_name, cat_number]
909 self.category_dict[ temp_name ] = [cat_name, cat_number]
911 if func_name in self.functions_by_name:
912 func = self.functions_by_name[ func_name ]
915 func = self.factory.create_function( child, self )
916 self.functions_by_name[ func_name ] = func
918 if func.offset >= self.next_offset:
919 self.next_offset = func.offset + 1
923 enum = self.factory.create_enum( child, self, cat_name )
924 self.enums_by_name[ enum.name ] = enum
926 t = self.factory.create_type( child, self, cat_name )
927 self.types_by_name[ "GL" + t.name ] = t
932 def functionIterateByCategory(self, cat = None):
942 for func in self.functionIterateAll():
943 [cat_name, cat_number] = self.category_dict[func.name]
967 def functionIterateByOffset(self):
969 for func in self.functions_by_name.values():
975 for func in self.functions_by_name.values():
988 def functionIterateAll(self):
989 return self.functions_by_name.values()
992 def enumIterateByName(self):
993 keys = sorted(self.enums_by_name.keys())
997 list.append( self.enums_by_name[ enum ] )
1002 def categoryIterate(self):
1012 keys = sorted(self.categories[cat_type].keys())
1015 list.append(self.categories[cat_type][key])
1020 def get_category_for_name( self, name ):
1021 if name in self.category_dict:
1022 return self.category_dict[name]
1027 def typeIterate(self):
1028 return self.types_by_name.values()
1031 def find_type( self, type_name ):
1032 if type_name in self.types_by_name:
1033 return self.types_by_name[ type_name ].type_expr