aboutsummaryrefslogtreecommitdiffstats
path: root/main/xcb-proto/python3.patch
blob: 9930c12b920d884cc6a520b0dd2ed00d89de024e (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
From ea7a3ac6c658164690e0febb55f4467cb9e0bcac Mon Sep 17 00:00:00 2001
From: Thomas Klausner <wiz@NetBSD.org>
Date: Thu, 19 May 2016 17:30:04 +0200
Subject: Make whitespace use consistent.

At least python-3.5.x complains about this forcefully.

Signed-off-by: Thomas Klausner <wiz@NetBSD.org>
Signed-off-by: Uli Schlachter <psychon@znc.in>

diff --git a/xcbgen/align.py b/xcbgen/align.py
index 5e31838..d4c12ee 100644
--- a/xcbgen/align.py
+++ b/xcbgen/align.py
@@ -16,12 +16,12 @@ class Alignment(object):
         return self.align == other.align and self.offset == other.offset
 
     def __str__(self):
-	return "(align=%d, offset=%d)" % (self.align, self.offset)
+        return "(align=%d, offset=%d)" % (self.align, self.offset)
 
     @staticmethod
     def for_primitive_type(size):
-	# compute the required start_alignment based on the size of the type
-	if size % 8 == 0:
+        # compute the required start_alignment based on the size of the type
+        if size % 8 == 0:
             # do 8-byte primitives require 8-byte alignment in X11?
             return Alignment(8,0)
         elif size % 4 == 0:
@@ -33,7 +33,7 @@ class Alignment(object):
 
 
     def align_after_fixed_size(self, size):
-	new_offset = (self.offset + size) % self.align
+        new_offset = (self.offset + size) % self.align
         return Alignment(self.align, new_offset)
 
 
@@ -41,7 +41,7 @@ class Alignment(object):
         '''
         Assuming the given external_align, checks whether
         self is fulfilled for all cases.
-	Returns True if yes, False otherwise.
+        Returns True if yes, False otherwise.
         '''
         if self.align == 1 and self.offset == 0:
             # alignment 1 with offset 0 is always fulfilled
@@ -55,9 +55,9 @@ class Alignment(object):
             # the external align guarantees less alignment -> not guaranteed
             return False
 
-	if external_align.align % self.align != 0:
+        if external_align.align % self.align != 0:
             # the external align cannot be divided by our align
-	    # -> not guaranteed
+            # -> not guaranteed
             # (this can only happen if there are alignments that are not
             # a power of 2, which is highly discouraged. But better be
             # safe and check for it)
@@ -72,7 +72,7 @@ class Alignment(object):
 
     def combine_with(self, other):
         # returns the alignment that is guaranteed when
-	# both, self or other, can happen
+        # both, self or other, can happen
         new_align = gcd(self.align, other.align)
         new_offset_candidate1 = self.offset % new_align
         new_offset_candidate2 = other.offset % new_align
@@ -83,8 +83,8 @@ class Alignment(object):
             new_align = gcd(new_align, offset_diff)
             new_offset_candidate1 = self.offset % new_align
             new_offset_candidate2 = other.offset % new_align
-	    assert new_offset_candidate1 == new_offset_candidate2
-	    new_offset = new_offset_candidate1
+            assert new_offset_candidate1 == new_offset_candidate2
+            new_offset = new_offset_candidate1
         # return the result
         return Alignment(new_align, new_offset)
 
@@ -92,44 +92,44 @@ class Alignment(object):
 class AlignmentLog(object):
 
     def __init__(self):
-	self.ok_list = []
-	self.fail_list = []
-	self.verbosity = 1
+        self.ok_list = []
+        self.fail_list = []
+        self.verbosity = 1
 
     def __str__(self):
-	result = ""
+        result = ""
 
-	# output the OK-list
-	for (align_before, field_name, type_obj, callstack, align_after) in self.ok_list:
-	    stacksize = len(callstack)
+        # output the OK-list
+        for (align_before, field_name, type_obj, callstack, align_after) in self.ok_list:
+            stacksize = len(callstack)
             indent = '  ' * stacksize
-	    if self.ok_callstack_is_relevant(callstack):
+            if self.ok_callstack_is_relevant(callstack):
                 if field_name is None or field_name == "":
-	            result += ("    %sok: %s:\n\t%sbefore: %s, after: %s\n"
-		        % (indent, str(type_obj), indent, str(align_before), str(align_after)))
-	        else:
-		    result += ("    %sok: field \"%s\" in %s:\n\t%sbefore: %s, after: %s\n"
-		        % (indent, str(field_name), str(type_obj),
-		           indent, str(align_before), str(align_after)))
+                    result += ("    %sok: %s:\n\t%sbefore: %s, after: %s\n"
+                        % (indent, str(type_obj), indent, str(align_before), str(align_after)))
+                else:
+                    result += ("    %sok: field \"%s\" in %s:\n\t%sbefore: %s, after: %s\n"
+                        % (indent, str(field_name), str(type_obj),
+                           indent, str(align_before), str(align_after)))
                 if self.verbosity >= 1:
-		    result += self.callstack_to_str(indent, callstack)
+                    result += self.callstack_to_str(indent, callstack)
 
-	# output the fail-list
-	for (align_before, field_name, type_obj, callstack, reason) in self.fail_list:
-	    stacksize = len(callstack)
+        # output the fail-list
+        for (align_before, field_name, type_obj, callstack, reason) in self.fail_list:
+            stacksize = len(callstack)
             indent = '  ' * stacksize
-	    if field_name is None or field_name == "":
-	        result += ("    %sfail: align %s is incompatible with\n\t%s%s\n\t%sReason: %s\n"
-		    % (indent, str(align_before), indent, str(type_obj), indent, reason))
-	    else:
-		result += ("    %sfail: align %s is incompatible with\n\t%sfield \"%s\" in %s\n\t%sReason: %s\n"
-		    % (indent, str(align_before), indent, str(field_name), str(type_obj), indent, reason))
+            if field_name is None or field_name == "":
+                result += ("    %sfail: align %s is incompatible with\n\t%s%s\n\t%sReason: %s\n"
+                    % (indent, str(align_before), indent, str(type_obj), indent, reason))
+            else:
+                result += ("    %sfail: align %s is incompatible with\n\t%sfield \"%s\" in %s\n\t%sReason: %s\n"
+                    % (indent, str(align_before), indent, str(field_name), str(type_obj), indent, reason))
 
             if self.verbosity >= 1:
-	        result += self.callstack_to_str(indent, callstack)
+                result += self.callstack_to_str(indent, callstack)
 
 
-	return result
+        return result
 
 
     def callstack_to_str(self, indent, callstack):
@@ -137,41 +137,41 @@ class AlignmentLog(object):
         for stack_elem in callstack:
             result += "\t  %s%s\n" % (indent, str(stack_elem))
         result += "\t%s]\n" % indent
-	return result
+        return result
 
 
     def ok_callstack_is_relevant(self, ok_callstack):
         # determine whether an ok callstack is relevant for logging
-	if self.verbosity >= 2:
-	    return True
+        if self.verbosity >= 2:
+            return True
 
         # empty callstacks are always relevant
-	if len(ok_callstack) == 0:
+        if len(ok_callstack) == 0:
             return True
 
-	# check whether the ok_callstack is a subset or equal to a fail_callstack
+        # check whether the ok_callstack is a subset or equal to a fail_callstack
         for (align_before, field_name, type_obj, fail_callstack, reason) in self.fail_list:
             if len(ok_callstack) <= len(fail_callstack):
                 zipped = zip(ok_callstack, fail_callstack[:len(ok_callstack)])
-		is_subset = all([i == j for i, j in zipped])
-		if is_subset:
+                is_subset = all([i == j for i, j in zipped])
+                if is_subset:
                     return True
 
         return False
 
 
     def ok(self, align_before, field_name, type_obj, callstack, align_after):
-	self.ok_list.append((align_before, field_name, type_obj, callstack, align_after))
+        self.ok_list.append((align_before, field_name, type_obj, callstack, align_after))
 
     def fail(self, align_before, field_name, type_obj, callstack, reason):
-	self.fail_list.append((align_before, field_name, type_obj, callstack, reason))
+        self.fail_list.append((align_before, field_name, type_obj, callstack, reason))
 
     def append(self, other):
-	self.ok_list.extend(other.ok_list)
-	self.fail_list.extend(other.fail_list)
+        self.ok_list.extend(other.ok_list)
+        self.fail_list.extend(other.fail_list)
 
     def ok_count(self):
-	return len(self.ok_list)
+        return len(self.ok_list)
 
 
 
-- 
cgit v0.10.2

From bea5e1c85bdc0950913790364e18228f20395a3d Mon Sep 17 00:00:00 2001
From: Thomas Klausner <wiz@NetBSD.org>
Date: Thu, 19 May 2016 17:30:05 +0200
Subject: print() is a function and needs parentheses.

Fixes build with python-3.x.

Signed-off-by: Thomas Klausner <wiz@NetBSD.org>
Signed-off-by: Uli Schlachter <psychon@znc.in>

diff --git a/xcbgen/xtypes.py b/xcbgen/xtypes.py
index c3b5758..b83b119 100644
--- a/xcbgen/xtypes.py
+++ b/xcbgen/xtypes.py
@@ -501,7 +501,7 @@ class ComplexType(Type):
                 int(required_start_align_element.get('align', "4"), 0),
                 int(required_start_align_element.get('offset', "0"), 0))
             if verbose_align_log:
-                print "Explicit start-align for %s: %s\n" % (self, self.required_start_align)
+                print ("Explicit start-align for %s: %s\n" % (self, self.required_start_align))
 
     def resolve(self, module):
         if self.resolved:
@@ -592,7 +592,7 @@ class ComplexType(Type):
                 if verbose_align_log:
                     print ("calc_required_start_align: %s has start-align %s"
                         % (str(self), str(self.required_start_align)))
-                    print "Details:\n" + str(log)
+                    print ("Details:\n" + str(log))
                 if self.required_start_align.offset != 0:
                     print (("WARNING: %s\n\thas start-align with non-zero offset: %s"
                         + "\n\tsuggest to add explicit definition with:"
@@ -619,12 +619,12 @@ class ComplexType(Type):
             for offset in range(0,align):
                 align_candidate = Alignment(align, offset)
                 if verbose_align_log:
-                    print "trying %s for %s" % (str(align_candidate), str(self))
+                    print ("trying %s for %s" % (str(align_candidate), str(self)))
                 my_log = AlignmentLog()
                 if self.is_possible_start_align(align_candidate, callstack, my_log):
                     log.append(my_log)
                     if verbose_align_log:
-                        print "found start-align %s for %s" % (str(align_candidate), str(self))
+                        print ("found start-align %s for %s" % (str(align_candidate), str(self)))
                     return align_candidate
                 else:
                     my_ok_count = my_log.ok_count()
@@ -641,7 +641,7 @@ class ComplexType(Type):
         # none of the candidates applies
         # this type has illegal internal aligns for all possible start_aligns
         if verbose_align_log:
-            print "didn't find start-align for %s" % str(self)
+            print ("didn't find start-align for %s" % str(self))
         log.append(best_log)
         return None
 
@@ -900,7 +900,7 @@ class SwitchType(ComplexType):
     # aux function for unchecked_get_alignment_after
     def get_align_for_selected_case_field(self, case_field, start_align, callstack, log):
         if verbose_align_log:
-            print "get_align_for_selected_case_field: %s, case_field = %s" % (str(self), str(case_field))
+            print ("get_align_for_selected_case_field: %s, case_field = %s" % (str(self), str(case_field)))
         total_align = start_align
         for field in self.bitcases:
             my_callstack = callstack[:]
-- 
cgit v0.10.2