xenserver: Consistently use spaces instead of tabs in init script.
[openvswitch] / build-aux / check-structs
1 #! /usr/bin/python
2
3 import os.path
4 import sys
5 import re
6
7 macros = {}
8
9 anyWarnings = False
10
11 types = {}
12 types['char'] = {"size": 1, "alignment": 1}
13 types['uint8_t'] = {"size": 1, "alignment": 1}
14 types['uint16_t'] = {"size": 2, "alignment": 2}
15 types['uint32_t'] = {"size": 4, "alignment": 4}
16 types['uint64_t'] = {"size": 8, "alignment": 8}
17 types['ovs_be16'] = {"size": 2, "alignment": 2}
18 types['ovs_be32'] = {"size": 4, "alignment": 4}
19 types['ovs_be64'] = {"size": 8, "alignment": 8}
20 types['ovs_32aligned_be64'] = {"size": 8, "alignment": 4}
21
22 token = None
23 line = ""
24 idRe = "[a-zA-Z_][a-zA-Z_0-9]*"
25 tokenRe = "#?" + idRe + "|[0-9]+|."
26 inComment = False
27 inDirective = False
28 def getToken():
29     global token
30     global line
31     global inComment
32     global inDirective
33     while True:
34         line = line.lstrip()
35         if line != "":
36             if line.startswith("/*"):
37                 inComment = True
38                 line = line[2:]
39             elif inComment:
40                 commentEnd = line.find("*/")
41                 if commentEnd < 0:
42                     line = ""
43                 else:
44                     inComment = False
45                     line = line[commentEnd + 2:]
46             else:
47                 match = re.match(tokenRe, line)
48                 token = match.group(0)
49                 line = line[len(token):]
50                 if token.startswith('#'):
51                     inDirective = True
52                 elif token in macros and not inDirective:
53                     line = macros[token] + line
54                     continue
55                 return True
56         elif inDirective:
57             token = "$"
58             inDirective = False
59             return True
60         else:
61             global lineNumber
62             line = inputFile.readline()
63             lineNumber += 1
64             while line.endswith("\\\n"):
65                 line = line[:-2] + inputFile.readline()
66                 lineNumber += 1
67             if line == "":
68                 if token == None:
69                     fatal("unexpected end of input")
70                 token = None
71                 return False
72     
73 def fatal(msg):
74     sys.stderr.write("%s:%d: error at \"%s\": %s\n" % (fileName, lineNumber, token, msg))
75     sys.exit(1)
76     
77 def warn(msg):
78     global anyWarnings
79     anyWarnings = True
80     sys.stderr.write("%s:%d: warning: %s\n" % (fileName, lineNumber, msg))
81
82 def skipDirective():
83     getToken()
84     while token != '$':
85         getToken()
86
87 def isId(s):
88     return re.match(idRe + "$", s) != None
89
90 def forceId():
91     if not isId(token):
92         fatal("identifier expected")
93
94 def forceInteger():
95     if not re.match('[0-9]+$', token):
96         fatal("integer expected")
97
98 def match(t):
99     if token == t:
100         getToken()
101         return True
102     else:
103         return False
104
105 def forceMatch(t):
106     if not match(t):
107         fatal("%s expected" % t)
108
109 def parseTaggedName():
110     assert token in ('struct', 'union')
111     name = token
112     getToken()
113     forceId()
114     name = "%s %s" % (name, token)
115     getToken()
116     return name
117
118 def parseTypeName():
119     if token in ('struct', 'union'):
120         name = parseTaggedName()
121     elif isId(token):
122         name = token
123         getToken()
124     else:
125         fatal("type name expected")
126
127     if name in types:
128         return name
129     else:
130         fatal("unknown type \"%s\"" % name)
131
132 def parseStruct():
133     isStruct = token == 'struct'
134     structName = parseTaggedName()
135     if token == ";":
136         return
137
138     ofs = size = 0
139     alignment = 4               # ARM has minimum 32-bit alignment
140     forceMatch('{')
141     while not match('}'):
142         typeName = parseTypeName()
143         typeSize = types[typeName]['size']
144         typeAlignment = types[typeName]['alignment']
145
146         forceId()
147         memberName = token
148         getToken()
149
150         if match('['):
151             if token == ']':
152                 count = 0
153             else:
154                 forceInteger()
155                 count = int(token)
156                 getToken()
157             forceMatch(']')
158         else:
159             count = 1
160
161         nBytes = typeSize * count
162         if isStruct:
163             if ofs % typeAlignment:
164                 shortage = typeAlignment - (ofs % typeAlignment)
165                 warn("%s member %s is %d bytes short of %d-byte alignment"
166                      % (structName, memberName, shortage, typeAlignment))
167                 size += shortage
168                 ofs += shortage
169             size += nBytes
170             ofs += nBytes
171         else:
172             if nBytes > size:
173                 size = nBytes
174         if typeAlignment > alignment:
175             alignment = typeAlignment
176
177         forceMatch(';')
178     if size % alignment:
179         shortage = alignment - (size % alignment)
180         if (structName == "struct ofp_packet_in" and
181             shortage == 2 and
182             memberName == 'data' and
183             count == 0):
184             # This is intentional
185             pass
186         else:
187             warn("%s needs %d bytes of tail padding" % (structName, shortage))
188         size += shortage
189     types[structName] = {"size": size, "alignment": alignment}
190
191 def checkStructs():
192     if len(sys.argv) < 2:
193         sys.stderr.write("at least one non-option argument required; "
194                          "use --help for help")
195         sys.exit(1)
196
197     if '--help' in sys.argv:
198         argv0 = os.path.basename(sys.argv[0])
199         print '''\
200 %(argv0)s, for checking struct and struct member alignment
201 usage: %(argv0)s HEADER [HEADER]...
202
203 This program reads the header files specified on the command line and
204 verifies that all struct members are aligned on natural boundaries
205 without any need for the compiler to add additional padding.  It also
206 verifies that each struct's size is a multiple of 32 bits (because
207 some ABIs for ARM require all structs to be a multiple of 32 bits), or
208 64 bits if the struct has any 64-bit members, again without the
209 compiler adding additional padding.  Finally, it checks struct size
210 assertions using OFP_ASSERT.
211
212 Header files are read in the order specified.  #include directives are
213 not processed, so specify them in dependency order.
214
215 This program is specialized for reading include/openflow/openflow.h
216 and include/openflow/nicira-ext.h.  It will not work on arbitrary
217 header files without extensions.''' % {"argv0": argv0}
218         sys.exit(0)
219
220     global fileName
221     for fileName in sys.argv[1:]:
222         global inputFile
223         global lineNumber
224         inputFile = open(fileName)
225         lineNumber = 0
226         while getToken():
227             if token in ("#ifdef", "#ifndef", "#include",
228                          "#endif", "#elif", "#else"):
229                 skipDirective()
230             elif token == "#define":
231                 getToken()
232                 name = token
233                 if line.startswith('('):
234                     skipDirective()
235                 else:
236                     definition = ""
237                     getToken()
238                     while token != '$':
239                         definition += token
240                         getToken()
241                     macros[name] = definition
242             elif token == "enum":
243                 while token != ';':
244                     getToken()
245             elif token in ('struct', 'union'):
246                 parseStruct()
247             elif match('OFP_ASSERT') or match('BOOST_STATIC_ASSERT'):
248                 forceMatch('(')
249                 forceMatch('sizeof')
250                 forceMatch('(')
251                 typeName = parseTypeName()
252                 forceMatch(')')
253                 forceMatch('=')
254                 forceMatch('=')
255                 forceInteger()
256                 size = int(token)
257                 getToken()
258                 forceMatch(')')
259                 if types[typeName]['size'] != size:
260                     warn("%s is %d bytes long but declared as %d" % (
261                             typeName, types[typeName]['size'], size))
262             else:
263                 fatal("parse error")
264         inputFile.close()
265     if anyWarnings:
266         sys.exit(1)
267
268 if __name__ == '__main__':
269     checkStructs()