Mercurial > projects > dstep

comparison scripts/dstepgen.rb @ 7:9e67a1122e85

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Fixed a bug that caused some types to be empty
author Jacob Carlborg <doob@me.com>
date Thu, 09 Jul 2009 21:17:39 +0200
parents c0cfd40362ee
children 07194b026fa4
comparison
equal deleted inserted replaced
6:c0cfd40362ee 7:9e67a1122e85
317 # def informal_protocols (header) 317 # def informal_protocols (header)
318 # methods(header, /^@(interface)\s+(\w+)\s*:?\s*(\w*)\s*(\([^)]+\))?/, @protocols, false) 318 # methods(header, /^@(interface)\s+(\w+)\s*:?\s*(\w*)\s*(\([^)]+\))?/, @protocols, false)
319 # end 319 # end
320 320
321 def classes (header) 321 def classes (header)
322 methods(header, /^@(interface)\s+(\w+)\s*:?\s*(\w*)\s*(\<([\w,\s]+)>)?$/, @classes, false) 322 methods(header, /^@(interface)\s+(\w+)\s*:?\s*(\w*)\s*(\<([\w,\s]+)>)?(\s*\{|$)/, @classes, false)
323 end 323 end
324 324
325 def protocols (header) 325 def protocols (header)
326 methods(header, /^@(protocol)\s+(\w+)\s*:?\s*(\w*)\s*(\<([\w,\s]+)>)?(\([^)]+\))?/, @protocols, true) 326 methods(header, /^@(protocol)\s+(\w+)\s*:?\s*(\w*)\s*(\<([\w,\s]+)>)?(\([^)]+\))?/, @protocols, true)
327 end 327 end
339 prop_re = /^@property\s*(\([^)]+\))?\s*([^;]+);$/ 339 prop_re = /^@property\s*(\([^)]+\))?\s*([^;]+);$/
340 current_interface = current_category = nil 340 current_interface = current_category = nil
341 i = 0 341 i = 0
342 parent = nil 342 parent = nil
343 protocols = nil 343 protocols = nil
344 cat = nil 344 cat = nil
345 345
346 @cpp_result.each_line do |line| 346 @cpp_result.each_line do |line|
347 size = line.size 347 size = line.size
348 line.strip! 348 line.strip!
349 349
486 i += size 486 i += size
487 end 487 end
488 end 488 end
489 489
490 def structs (header) 490 def structs (header)
491 re = /typedef\s+struct\s*\w*\s*((\w+)|\{([^{}]*(\{[^}]+\})?)*\}\s*([^\s]+))\s*(__attribute__\(.+\))?\s*,?(.+)?;/ 491 re = /typedef\s+struct\s*\w*\s*((\w+)|\{([^{}]*(\{[^}]+\})?)*\}\s*([^\s]+))\s*(__attribute__\(.+\))?\s*(;|,(.+)?;)/
492 i = 0 492 i = 0
493 body = nil 493 body = nil
494 494
495 @cpp_result.scan(re).each do |m| 495 @cpp_result.scan(re).each do |m|
496 struct = { :name => m[4], :members => [] } 496 struct = { :name => m[4], :members => [] }
1173 handle_framework(framework, sub_framework, parent_framework) 1173 handle_framework(framework, sub_framework, parent_framework)
1174 #@import_directives << "#import <#{framework.name}/#{framework.name}.h>\n" 1174 #@import_directives << "#import <#{framework.name}/#{framework.name}.h>\n"
1175 @frameworks << framework 1175 @frameworks << framework
1176 end 1176 end
1177 1177
1178 def collect_header_types (header, enable_64bit) 1178 def collect_cftypes (header, enable_64bit)
1179 types = [] 1179 types = []
1180 1180
1181 header.cftypes.each do |cftype| 1181 header.cftypes.each do |cftype|
1182 types << cftype[:type] 1182 types << cftype[:type]
1183 end 1183 end
1184
1185 resolved_types = resolve_types_helper(types, enable_64bit) if types.length > 0
1186
1187 header.cftypes.each_with_index do |cftype, i|
1188 cftype[enable_64bit ? :type64 : :type] = resolved_types[i]
1189 end
1190 end
1191
1192 def collect_constants (header, enable_64bit)
1193 types = []
1184 1194
1185 header.constants.each do |constant| 1195 header.constants.each do |constant|
1186 types << constant.stripped_return_type 1196 types << constant.stripped_return_type
1187 end 1197 end
1188 1198
1199 resolved_types = resolve_types_helper(types, enable_64bit) if types.length > 0
1200
1201 header.constants.each_with_index do |constant, i|
1202 constant.resolved_type = resolved_types[i] unless enable_64bit
1203 constant.resolved_type64 = resolved_types[i] if enable_64bit
1204 end
1205 end
1206
1207 def collect_structs (header, enable_64bit)
1208 types = []
1209
1189 header.structs.each do |struct| 1210 header.structs.each do |struct|
1190 types << struct[:name] 1211 types << struct[:name]
1191 1212
1192 struct[:members].each do |member| 1213 struct[:members].each do |member|
1193 types << member[:declaredType] 1214 types << member[:declaredType]
1194 end 1215 end
1195 end 1216 end
1196 1217
1197 header.typedefs.each do |typedef| 1218 resolved_types = resolve_types_helper(types, enable_64bit) if types.length > 0
1198 types << typedef.stripped_return_type 1219
1199 end 1220 i = 0
1200
1201 header.functions.each do |function|
1202 types << function.stripped_return_type
1203
1204 function.args.each do |arg|
1205 types << arg.stripped_return_type
1206 end
1207 end
1208
1209 header.function_pointers.each do |fp, value|
1210 types << value.return_type
1211
1212 value.args.each do |arg|
1213 types << arg.type
1214 end unless value.args.nil?
1215 end
1216
1217 types
1218 end
1219
1220 def collect_classes_types (enable_64bit)
1221 types = []
1222
1223 @classes.each do |clazz, value|
1224 value.methods.each do |method|
1225 types << method.stripped_return_type
1226
1227 method.args.each do |arg|
1228 types << arg.stripped_return_type
1229 end
1230 end
1231 end
1232
1233 types
1234 end
1235
1236 def collect_protocols_types (enable_64bit)
1237 types = []
1238
1239 @protocols.each do |protocol, value|
1240 value.methods.each do |method|
1241 types << method.stripped_return_type
1242
1243 method.args.each do |arg|
1244 types << arg.stripped_return_type
1245 end
1246 end
1247 end
1248
1249 types
1250 end
1251
1252 # def collect_informal_protocols_types (enable_64bit)
1253 # types = []
1254 #
1255 # @informal_protocols.each do |name, methods|
1256 # methods.each do |method|
1257 # types << method.stripped_return_type
1258 #
1259 # method.args.each do |arg|
1260 # types << arg.stripped_return_type
1261 # end
1262 # end
1263 # end
1264 #
1265 # types
1266 # end
1267
1268 def collect_categories_types (enable_64bit)
1269 types = []
1270
1271 @categories.each do |category, value|
1272 value.methods.each do |method|
1273 types << method.stripped_return_type
1274
1275 method.args.each do |arg|
1276 types << arg.stripped_return_type
1277 end
1278 end
1279 end
1280
1281 types
1282 end
1283
1284 def resolve_header_types (header, enable_64bit, resolved_types, x)
1285 i = x
1286
1287 header.cftypes.each do |cftype|
1288 cftype[enable_64bit ? :type64 : :type] = resolved_types[i]
1289 i += 1
1290 end
1291
1292 header.constants.each do |constant|
1293 constant.resolved_type = resolved_types[i] unless enable_64bit
1294 constant.resolved_type64 = resolved_types[i] if enable_64bit
1295 i += 1
1296 end
1297 1221
1298 header.structs.each do |struct| 1222 header.structs.each do |struct|
1299 struct[enable_64bit ? :type64 : :type] = resolved_types[i] 1223 struct[enable_64bit ? :type64 : :type] = resolved_types[i]
1300 i += 1 1224 i += 1
1301 1225
1302 struct[:members].each do |member| 1226 struct[:members].each do |member|
1303 member[enable_64bit ? :type64 : :type] = resolved_types[i] 1227 member[enable_64bit ? :type64 : :type] = resolved_types[i]
1304 i += 1 1228 i += 1
1305 end 1229 end
1306 end 1230 end
1307 1231 end
1232
1233 def collect_typedefs (header, enable_64bit)
1234 types = []
1235
1308 header.typedefs.each do |typedef| 1236 header.typedefs.each do |typedef|
1237 types << typedef.stripped_return_type
1238 end
1239
1240 resolved_types = resolve_types_helper(types, enable_64bit) if types.length > 0
1241
1242 header.typedefs.each_with_index do |typedef, i|
1309 typedef.resolved_type = resolved_types[i] unless enable_64bit 1243 typedef.resolved_type = resolved_types[i] unless enable_64bit
1310 typedef.resolved_type64 = resolved_types[i] if enable_64bit 1244 typedef.resolved_type64 = resolved_types[i] if enable_64bit
1311 i += 1 1245 end
1312 end 1246 end
1247
1248 def collect_functions (header, enable_64bit)
1249 types = []
1250
1251 header.functions.each do |function|
1252 types << function.stripped_return_type
1253
1254 function.args.each do |arg|
1255 types << arg.stripped_return_type
1256 end
1257 end
1258
1259 resolved_types = resolve_types_helper(types, enable_64bit) if types.length > 0
1260 i = 0
1313 1261
1314 header.functions.each do |function| 1262 header.functions.each do |function|
1315 function.resolved_type = resolved_types[i] unless enable_64bit 1263 function.resolved_type = resolved_types[i] unless enable_64bit
1316 function.resolved_type64 = resolved_types[i] if enable_64bit 1264 function.resolved_type64 = resolved_types[i] if enable_64bit
1317 i += 1 1265 i += 1
1320 arg.resolved_type = resolved_types[i] unless enable_64bit 1268 arg.resolved_type = resolved_types[i] unless enable_64bit
1321 arg.resolved_type64 = resolved_types[i] if enable_64bit 1269 arg.resolved_type64 = resolved_types[i] if enable_64bit
1322 i += 1 1270 i += 1
1323 end 1271 end
1324 end 1272 end
1273 end
1274
1275 def collect_functions_pointers (header, enable_64bit)
1276 types = []
1277
1278 header.function_pointers.each do |fp, value|
1279 types << value.return_type
1280
1281 value.args.each do |arg|
1282 types << arg.type
1283 end unless value.args.nil?
1284 end
1285
1286 resolved_types = resolve_types_helper(types, enable_64bit) if types.length > 0
1287 i = 0
1325 1288
1326 header.function_pointers.each do |fp, value| 1289 header.function_pointers.each do |fp, value|
1327 value.resolved_type = resolved_types[i] unless enable_64bit 1290 value.resolved_type = resolved_types[i] unless enable_64bit
1328 value.resolved_type64 = resolved_types[i] if enable_64bit 1291 value.resolved_type64 = resolved_types[i] if enable_64bit
1329 i += 1 1292 i += 1
1332 arg.resolved_type = resolved_types[i] unless enable_64bit 1295 arg.resolved_type = resolved_types[i] unless enable_64bit
1333 arg.resolved_type64 = resolved_types[i] if enable_64bit 1296 arg.resolved_type64 = resolved_types[i] if enable_64bit
1334 i += 1 1297 i += 1
1335 end unless value.args.nil? 1298 end unless value.args.nil?
1336 end 1299 end
1337 1300 end
1338 i 1301
1339 end 1302 def collect_header_types (header, enable_64bit)
1340 1303 collect_cftypes(header, enable_64bit)
1341 def resolve_classes_types (enable_64bit, resolved_types, x) 1304 collect_constants(header, enable_64bit)
1342 i = x 1305 collect_structs(header, enable_64bit)
1306 collect_typedefs(header, enable_64bit)
1307 collect_functions(header, enable_64bit)
1308 collect_functions_pointers(header, enable_64bit)
1309 end
1310
1311 def collect_classes_types (enable_64bit)
1312 types = []
1343 1313
1344 @classes.each do |clazz, value| 1314 @classes.each do |clazz, value|
1345 value.methods.each do |method| 1315 value.methods.each do |method|
1316 types << method.stripped_return_type
1317
1318 method.args.each do |arg|
1319 types << arg.stripped_return_type
1320 end
1321 end
1322 end
1323
1324 resolved_types = resolve_types_helper(types, enable_64bit) if types.length > 0
1325 i = 0
1326
1327 @classes.each do |clazz, value|
1328 value.methods.each do |method|
1346 method.resolved_type = resolved_types[i] unless enable_64bit 1329 method.resolved_type = resolved_types[i] unless enable_64bit
1347 method.resolved_type64 = resolved_types[i] if enable_64bit 1330 method.resolved_type64 = resolved_types[i] if enable_64bit
1348 i += 1 1331 i += 1
1349 1332
1350 method.args.each do |arg| 1333 method.args.each do |arg|
1352 arg.resolved_type64 = resolved_types[i] if enable_64bit 1335 arg.resolved_type64 = resolved_types[i] if enable_64bit
1353 i += 1 1336 i += 1
1354 end 1337 end
1355 end 1338 end
1356 end 1339 end
1357 1340 end
1358 i 1341
1359 end 1342 def collect_protocols_types (enable_64bit)
1360 1343 types = []
1361 def resolve_protocols_types (enable_64bit, resolved_types, x) 1344
1362 i = x 1345 @protocols.each do |protocol, value|
1346 value.methods.each do |method|
1347 types << method.stripped_return_type
1348
1349 method.args.each do |arg|
1350 types << arg.stripped_return_type
1351 end
1352 end
1353 end
1354
1355 resolved_types = resolve_types_helper(types, enable_64bit) if types.length > 0
1356 i = 0
1363 1357
1364 @protocols.each do |protocol, value| 1358 @protocols.each do |protocol, value|
1365 value.methods.each do |method| 1359 value.methods.each do |method|
1366 method.resolved_type = resolved_types[i] unless enable_64bit 1360 method.resolved_type = resolved_types[i] unless enable_64bit
1367 method.resolved_type64 = resolved_types[i] if enable_64bit 1361 method.resolved_type64 = resolved_types[i] if enable_64bit
1372 arg.resolved_type64 = resolved_types[i] if enable_64bit 1366 arg.resolved_type64 = resolved_types[i] if enable_64bit
1373 i += 1 1367 i += 1
1374 end 1368 end
1375 end 1369 end
1376 end 1370 end
1377 1371 end
1378 i 1372
1379 end 1373 def collect_categories_types (enable_64bit)
1380 1374 types = []
1381 # def resolve_informal_protocols_types (enable_64bit, resolved_types, x) 1375
1382 # i = x 1376 @categories.each do |category, value|
1383 # 1377 value.methods.each do |method|
1384 # @informal_protocols.each do |name, methods| 1378 types << method.stripped_return_type
1385 # methods.each do |method| 1379
1386 # method.resolved_type = resolved_types[i] unless enable_64bit 1380 method.args.each do |arg|
1387 # method.resolved_type64 = resolved_types[i] if enable_64bit 1381 types << arg.stripped_return_type
1388 # i += 1 1382 end
1389 # 1383 end
1390 # method.args.each do |arg| 1384 end
1391 # arg.resolved_type = resolved_types[i] unless enable_64bit 1385
1392 # arg.resolved_type64 = resolved_types[i] if enable_64bit 1386 resolved_types = resolve_types_helper(types, enable_64bit) if types.length > 0
1393 # i += 1 1387 i = 0
1394 # end
1395 # end
1396 # end
1397 #
1398 # i
1399 # end
1400
1401 def resolve_categories_types (enable_64bit, resolved_types, x)
1402 i = x
1403 1388
1404 @categories.each do |category, value| 1389 @categories.each do |category, value|
1405 value.methods.each do |method| 1390 value.methods.each do |method|
1406 method.resolved_type = resolved_types[i] unless enable_64bit 1391 method.resolved_type = resolved_types[i] unless enable_64bit
1407 method.resolved_type64 = resolved_types[i] if enable_64bit 1392 method.resolved_type64 = resolved_types[i] if enable_64bit
1412 arg.resolved_type64 = resolved_types[i] if enable_64bit 1397 arg.resolved_type64 = resolved_types[i] if enable_64bit
1413 i += 1 1398 i += 1
1414 end 1399 end
1415 end 1400 end
1416 end 1401 end
1417
1418 i
1419 end 1402 end
1420 1403
1421 def get_framework_name (framework) 1404 def get_framework_name (framework)
1422 i = framework.rindex(".framework") 1405 i = framework.rindex(".framework")
1423 return framework if i.nil? 1406 return framework if i.nil?
1424 x = framework.rindex("/", i) 1407 x = framework.rindex("/", i)
1425 framework[x + 1 ... i] 1408 framework[x + 1 ... i]
1426 end 1409 end
1427 1410
1428 def resolve_types (enable_64bit = false) 1411 def resolve_types (enable_64bit = false)
1412
1413 @frameworks.each do |framework|
1414 framework.headers.each do |header|
1415 collect_header_types(header, enable_64bit)
1416 end
1417 end
1418
1419 @headers.each do |header|
1420 collect_header_types(header, enable_64bit)
1421 end
1422
1423 collect_classes_types(enable_64bit)
1424 collect_protocols_types(enable_64bit)
1425 collect_categories_types(enable_64bit)
1426 end
1427
1428 def resolve_types_helper (types, enable_64bit)
1429 code = "#include <stdio.h>\n" 1429 code = "#include <stdio.h>\n"
1430 code << @import_directives 1430 code << @import_directives
1431 types = []
1432 1431
1433 @frameworks.each do |framework| 1432 @frameworks.each do |framework|
1434 framework.headers.each do |header| 1433 framework.headers.each do |header|
1435 exclude = false 1434 exclude = false
1436 1435
1464 1463
1465 File.foreach(@inject_path) do |line| 1464 File.foreach(@inject_path) do |line|
1466 code << line 1465 code << line
1467 end if !@inject_path.nil? && File.exist?(@inject_path) 1466 end if !@inject_path.nil? && File.exist?(@inject_path)
1468 1467
1469 code << "\n\n" 1468 code << "\n\n"
1470
1471 @headers.each do |header|
1472 types << collect_header_types(header, enable_64bit)
1473 end
1474
1475 types << collect_classes_types(enable_64bit)
1476 types << collect_protocols_types(enable_64bit)
1477 #types << collect_informal_protocols_types(enable_64bit)
1478 types << collect_categories_types(enable_64bit)
1479
1480 code << "int main ()\n{\n" 1469 code << "int main ()\n{\n"
1481 types.flatten! 1470 types.flatten!
1482 1471
1483 types.each do |type| 1472 types.each do |type|
1484 code << ' printf("%s\n", ' + "@encode(__typeof__(#{type})));\n" unless type.nil? || type.length == 0 1473 code << ' printf("%s\n", ' + "@encode(__typeof__(#{type})));\n" unless type.nil? || type.length == 0
1490 1479
1491 compile_and_execute(code, enable_64bit).split("\n").each do |line| 1480 compile_and_execute(code, enable_64bit).split("\n").each do |line|
1492 resolved_types << line 1481 resolved_types << line
1493 end 1482 end
1494 1483
1495 i = 0 1484 resolved_types
1496 1485
1497 @frameworks.each do |framework| 1486 # i = 0
1498 framework.headers.each do |header| 1487 #
1499 i = resolve_header_types(header, enable_64bit, resolved_types, i) 1488 # @frameworks.each do |framework|
1500 end 1489 # framework.headers.each do |header|
1501 end 1490 # i = resolve_header_types(header, enable_64bit, resolved_types, i)
1502 1491 # end
1503 @headers.each do |header| 1492 # end
1504 i = resolve_header_types(header, enable_64bit, resolved_types, i) 1493 #
1505 end 1494 # @headers.each do |header|
1506 1495 # i = resolve_header_types(header, enable_64bit, resolved_types, i)
1507 i = resolve_classes_types(enable_64bit, resolved_types, i) 1496 # end
1508 i = resolve_protocols_types(enable_64bit, resolved_types, i) 1497 #
1509 #i = resolve_informal_protocols_types(enable_64bit, resolved_types, i) 1498 # i = resolve_classes_types(enable_64bit, resolved_types, i)
1510 i = resolve_categories_types(enable_64bit, resolved_types, i) 1499 # i = resolve_protocols_types(enable_64bit, resolved_types, i)
1500 # #i = resolve_informal_protocols_types(enable_64bit, resolved_types, i)
1501 # i = resolve_categories_types(enable_64bit, resolved_types, i)
1511 end 1502 end
1512 1503
1513 def generate_header (xml, header) 1504 def generate_header (xml, header)
1514 xml.file :name => header.name do 1505 xml.file :name => header.name do
1515 header.imports.each do |import| 1506 header.imports.each do |import|