Author: Carl Friedrich Bolz <cfb...@gmx.de>
Branch: statistics-maps
Changeset: r82171:dae74bd53702
Date: 2016-02-12 12:34 +0100
http://bitbucket.org/pypy/pypy/changeset/dae74bd53702/
Log: merge default
diff too long, truncating to 2000 out of 9916 lines
diff --git a/.hgignore b/.hgignore
--- a/.hgignore
+++ b/.hgignore
@@ -75,6 +75,7 @@
^lib_pypy/__pycache__$
^lib_pypy/ctypes_config_cache/_.+_cache\.py$
^lib_pypy/ctypes_config_cache/_.+_.+_\.py$
+^lib_pypy/_libmpdec/.+.o$
^rpython/translator/cli/query-descriptions$
^pypy/doc/discussion/.+\.html$
^include/.+\.h$
diff --git a/dotviewer/drawgraph.py b/dotviewer/drawgraph.py
--- a/dotviewer/drawgraph.py
+++ b/dotviewer/drawgraph.py
@@ -14,12 +14,661 @@
FONT = os.path.join(this_dir, 'font', 'DroidSans.ttf')
FIXEDFONT = os.path.join(this_dir, 'font', 'DroidSansMono.ttf')
COLOR = {
- 'black': (0,0,0),
- 'white': (255,255,255),
- 'red': (255,0,0),
- 'green': (0,255,0),
- 'blue': (0,0,255),
- 'yellow': (255,255,0),
+ 'aliceblue': (240, 248, 255),
+ 'antiquewhite': (250, 235, 215),
+ 'antiquewhite1': (255, 239, 219),
+ 'antiquewhite2': (238, 223, 204),
+ 'antiquewhite3': (205, 192, 176),
+ 'antiquewhite4': (139, 131, 120),
+ 'aquamarine': (127, 255, 212),
+ 'aquamarine1': (127, 255, 212),
+ 'aquamarine2': (118, 238, 198),
+ 'aquamarine3': (102, 205, 170),
+ 'aquamarine4': (69, 139, 116),
+ 'azure': (240, 255, 255),
+ 'azure1': (240, 255, 255),
+ 'azure2': (224, 238, 238),
+ 'azure3': (193, 205, 205),
+ 'azure4': (131, 139, 139),
+ 'beige': (245, 245, 220),
+ 'bisque': (255, 228, 196),
+ 'bisque1': (255, 228, 196),
+ 'bisque2': (238, 213, 183),
+ 'bisque3': (205, 183, 158),
+ 'bisque4': (139, 125, 107),
+ 'black': (0, 0, 0),
+ 'blanchedalmond': (255, 235, 205),
+ 'blue': (0, 0, 255),
+ 'blue1': (0, 0, 255),
+ 'blue2': (0, 0, 238),
+ 'blue3': (0, 0, 205),
+ 'blue4': (0, 0, 139),
+ 'blueviolet': (138, 43, 226),
+ 'brown': (165, 42, 42),
+ 'brown1': (255, 64, 64),
+ 'brown2': (238, 59, 59),
+ 'brown3': (205, 51, 51),
+ 'brown4': (139, 35, 35),
+ 'burlywood': (222, 184, 135),
+ 'burlywood1': (255, 211, 155),
+ 'burlywood2': (238, 197, 145),
+ 'burlywood3': (205, 170, 125),
+ 'burlywood4': (139, 115, 85),
+ 'cadetblue': (95, 158, 160),
+ 'cadetblue1': (152, 245, 255),
+ 'cadetblue2': (142, 229, 238),
+ 'cadetblue3': (122, 197, 205),
+ 'cadetblue4': (83, 134, 139),
+ 'chartreuse': (127, 255, 0),
+ 'chartreuse1': (127, 255, 0),
+ 'chartreuse2': (118, 238, 0),
+ 'chartreuse3': (102, 205, 0),
+ 'chartreuse4': (69, 139, 0),
+ 'chocolate': (210, 105, 30),
+ 'chocolate1': (255, 127, 36),
+ 'chocolate2': (238, 118, 33),
+ 'chocolate3': (205, 102, 29),
+ 'chocolate4': (139, 69, 19),
+ 'coral': (255, 127, 80),
+ 'coral1': (255, 114, 86),
+ 'coral2': (238, 106, 80),
+ 'coral3': (205, 91, 69),
+ 'coral4': (139, 62, 47),
+ 'cornflowerblue': (100, 149, 237),
+ 'cornsilk': (255, 248, 220),
+ 'cornsilk1': (255, 248, 220),
+ 'cornsilk2': (238, 232, 205),
+ 'cornsilk3': (205, 200, 177),
+ 'cornsilk4': (139, 136, 120),
+ 'crimson': (220, 20, 60),
+ 'cyan': (0, 255, 255),
+ 'cyan1': (0, 255, 255),
+ 'cyan2': (0, 238, 238),
+ 'cyan3': (0, 205, 205),
+ 'cyan4': (0, 139, 139),
+ 'darkgoldenrod': (184, 134, 11),
+ 'darkgoldenrod1': (255, 185, 15),
+ 'darkgoldenrod2': (238, 173, 14),
+ 'darkgoldenrod3': (205, 149, 12),
+ 'darkgoldenrod4': (139, 101, 8),
+ 'darkgreen': (0, 100, 0),
+ 'darkkhaki': (189, 183, 107),
+ 'darkolivegreen': (85, 107, 47),
+ 'darkolivegreen1': (202, 255, 112),
+ 'darkolivegreen2': (188, 238, 104),
+ 'darkolivegreen3': (162, 205, 90),
+ 'darkolivegreen4': (110, 139, 61),
+ 'darkorange': (255, 140, 0),
+ 'darkorange1': (255, 127, 0),
+ 'darkorange2': (238, 118, 0),
+ 'darkorange3': (205, 102, 0),
+ 'darkorange4': (139, 69, 0),
+ 'darkorchid': (153, 50, 204),
+ 'darkorchid1': (191, 62, 255),
+ 'darkorchid2': (178, 58, 238),
+ 'darkorchid3': (154, 50, 205),
+ 'darkorchid4': (104, 34, 139),
+ 'darksalmon': (233, 150, 122),
+ 'darkseagreen': (143, 188, 143),
+ 'darkseagreen1': (193, 255, 193),
+ 'darkseagreen2': (180, 238, 180),
+ 'darkseagreen3': (155, 205, 155),
+ 'darkseagreen4': (105, 139, 105),
+ 'darkslateblue': (72, 61, 139),
+ 'darkslategray': (47, 79, 79),
+ 'darkslategray1': (151, 255, 255),
+ 'darkslategray2': (141, 238, 238),
+ 'darkslategray3': (121, 205, 205),
+ 'darkslategray4': (82, 139, 139),
+ 'darkslategrey': (47, 79, 79),
+ 'darkturquoise': (0, 206, 209),
+ 'darkviolet': (148, 0, 211),
+ 'deeppink': (255, 20, 147),
+ 'deeppink1': (255, 20, 147),
+ 'deeppink2': (238, 18, 137),
+ 'deeppink3': (205, 16, 118),
+ 'deeppink4': (139, 10, 80),
+ 'deepskyblue': (0, 191, 255),
+ 'deepskyblue1': (0, 191, 255),
+ 'deepskyblue2': (0, 178, 238),
+ 'deepskyblue3': (0, 154, 205),
+ 'deepskyblue4': (0, 104, 139),
+ 'dimgray': (105, 105, 105),
+ 'dimgrey': (105, 105, 105),
+ 'dodgerblue': (30, 144, 255),
+ 'dodgerblue1': (30, 144, 255),
+ 'dodgerblue2': (28, 134, 238),
+ 'dodgerblue3': (24, 116, 205),
+ 'dodgerblue4': (16, 78, 139),
+ 'firebrick': (178, 34, 34),
+ 'firebrick1': (255, 48, 48),
+ 'firebrick2': (238, 44, 44),
+ 'firebrick3': (205, 38, 38),
+ 'firebrick4': (139, 26, 26),
+ 'floralwhite': (255, 250, 240),
+ 'forestgreen': (34, 139, 34),
+ 'gainsboro': (220, 220, 220),
+ 'ghostwhite': (248, 248, 255),
+ 'gold': (255, 215, 0),
+ 'gold1': (255, 215, 0),
+ 'gold2': (238, 201, 0),
+ 'gold3': (205, 173, 0),
+ 'gold4': (139, 117, 0),
+ 'goldenrod': (218, 165, 32),
+ 'goldenrod1': (255, 193, 37),
+ 'goldenrod2': (238, 180, 34),
+ 'goldenrod3': (205, 155, 29),
+ 'goldenrod4': (139, 105, 20),
+ 'gray': (192, 192, 192),
+ 'gray0': (0, 0, 0),
+ 'gray1': (3, 3, 3),
+ 'gray10': (26, 26, 26),
+ 'gray100': (255, 255, 255),
+ 'gray11': (28, 28, 28),
+ 'gray12': (31, 31, 31),
+ 'gray13': (33, 33, 33),
+ 'gray14': (36, 36, 36),
+ 'gray15': (38, 38, 38),
+ 'gray16': (41, 41, 41),
+ 'gray17': (43, 43, 43),
+ 'gray18': (46, 46, 46),
+ 'gray19': (48, 48, 48),
+ 'gray2': (5, 5, 5),
+ 'gray20': (51, 51, 51),
+ 'gray21': (54, 54, 54),
+ 'gray22': (56, 56, 56),
+ 'gray23': (59, 59, 59),
+ 'gray24': (61, 61, 61),
+ 'gray25': (64, 64, 64),
+ 'gray26': (66, 66, 66),
+ 'gray27': (69, 69, 69),
+ 'gray28': (71, 71, 71),
+ 'gray29': (74, 74, 74),
+ 'gray3': (8, 8, 8),
+ 'gray30': (77, 77, 77),
+ 'gray31': (79, 79, 79),
+ 'gray32': (82, 82, 82),
+ 'gray33': (84, 84, 84),
+ 'gray34': (87, 87, 87),
+ 'gray35': (89, 89, 89),
+ 'gray36': (92, 92, 92),
+ 'gray37': (94, 94, 94),
+ 'gray38': (97, 97, 97),
+ 'gray39': (99, 99, 99),
+ 'gray4': (10, 10, 10),
+ 'gray40': (102, 102, 102),
+ 'gray41': (105, 105, 105),
+ 'gray42': (107, 107, 107),
+ 'gray43': (110, 110, 110),
+ 'gray44': (112, 112, 112),
+ 'gray45': (115, 115, 115),
+ 'gray46': (117, 117, 117),
+ 'gray47': (120, 120, 120),
+ 'gray48': (122, 122, 122),
+ 'gray49': (125, 125, 125),
+ 'gray5': (13, 13, 13),
+ 'gray50': (127, 127, 127),
+ 'gray51': (130, 130, 130),
+ 'gray52': (133, 133, 133),
+ 'gray53': (135, 135, 135),
+ 'gray54': (138, 138, 138),
+ 'gray55': (140, 140, 140),
+ 'gray56': (143, 143, 143),
+ 'gray57': (145, 145, 145),
+ 'gray58': (148, 148, 148),
+ 'gray59': (150, 150, 150),
+ 'gray6': (15, 15, 15),
+ 'gray60': (153, 153, 153),
+ 'gray61': (156, 156, 156),
+ 'gray62': (158, 158, 158),
+ 'gray63': (161, 161, 161),
+ 'gray64': (163, 163, 163),
+ 'gray65': (166, 166, 166),
+ 'gray66': (168, 168, 168),
+ 'gray67': (171, 171, 171),
+ 'gray68': (173, 173, 173),
+ 'gray69': (176, 176, 176),
+ 'gray7': (18, 18, 18),
+ 'gray70': (179, 179, 179),
+ 'gray71': (181, 181, 181),
+ 'gray72': (184, 184, 184),
+ 'gray73': (186, 186, 186),
+ 'gray74': (189, 189, 189),
+ 'gray75': (191, 191, 191),
+ 'gray76': (194, 194, 194),
+ 'gray77': (196, 196, 196),
+ 'gray78': (199, 199, 199),
+ 'gray79': (201, 201, 201),
+ 'gray8': (20, 20, 20),
+ 'gray80': (204, 204, 204),
+ 'gray81': (207, 207, 207),
+ 'gray82': (209, 209, 209),
+ 'gray83': (212, 212, 212),
+ 'gray84': (214, 214, 214),
+ 'gray85': (217, 217, 217),
+ 'gray86': (219, 219, 219),
+ 'gray87': (222, 222, 222),
+ 'gray88': (224, 224, 224),
+ 'gray89': (227, 227, 227),
+ 'gray9': (23, 23, 23),
+ 'gray90': (229, 229, 229),
+ 'gray91': (232, 232, 232),
+ 'gray92': (235, 235, 235),
+ 'gray93': (237, 237, 237),
+ 'gray94': (240, 240, 240),
+ 'gray95': (242, 242, 242),
+ 'gray96': (245, 245, 245),
+ 'gray97': (247, 247, 247),
+ 'gray98': (250, 250, 250),
+ 'gray99': (252, 252, 252),
+ 'green': (0, 255, 0),
+ 'green1': (0, 255, 0),
+ 'green2': (0, 238, 0),
+ 'green3': (0, 205, 0),
+ 'green4': (0, 139, 0),
+ 'greenyellow': (173, 255, 47),
+ 'grey': (192, 192, 192),
+ 'grey0': (0, 0, 0),
+ 'grey1': (3, 3, 3),
+ 'grey10': (26, 26, 26),
+ 'grey100': (255, 255, 255),
+ 'grey11': (28, 28, 28),
+ 'grey12': (31, 31, 31),
+ 'grey13': (33, 33, 33),
+ 'grey14': (36, 36, 36),
+ 'grey15': (38, 38, 38),
+ 'grey16': (41, 41, 41),
+ 'grey17': (43, 43, 43),
+ 'grey18': (46, 46, 46),
+ 'grey19': (48, 48, 48),
+ 'grey2': (5, 5, 5),
+ 'grey20': (51, 51, 51),
+ 'grey21': (54, 54, 54),
+ 'grey22': (56, 56, 56),
+ 'grey23': (59, 59, 59),
+ 'grey24': (61, 61, 61),
+ 'grey25': (64, 64, 64),
+ 'grey26': (66, 66, 66),
+ 'grey27': (69, 69, 69),
+ 'grey28': (71, 71, 71),
+ 'grey29': (74, 74, 74),
+ 'grey3': (8, 8, 8),
+ 'grey30': (77, 77, 77),
+ 'grey31': (79, 79, 79),
+ 'grey32': (82, 82, 82),
+ 'grey33': (84, 84, 84),
+ 'grey34': (87, 87, 87),
+ 'grey35': (89, 89, 89),
+ 'grey36': (92, 92, 92),
+ 'grey37': (94, 94, 94),
+ 'grey38': (97, 97, 97),
+ 'grey39': (99, 99, 99),
+ 'grey4': (10, 10, 10),
+ 'grey40': (102, 102, 102),
+ 'grey41': (105, 105, 105),
+ 'grey42': (107, 107, 107),
+ 'grey43': (110, 110, 110),
+ 'grey44': (112, 112, 112),
+ 'grey45': (115, 115, 115),
+ 'grey46': (117, 117, 117),
+ 'grey47': (120, 120, 120),
+ 'grey48': (122, 122, 122),
+ 'grey49': (125, 125, 125),
+ 'grey5': (13, 13, 13),
+ 'grey50': (127, 127, 127),
+ 'grey51': (130, 130, 130),
+ 'grey52': (133, 133, 133),
+ 'grey53': (135, 135, 135),
+ 'grey54': (138, 138, 138),
+ 'grey55': (140, 140, 140),
+ 'grey56': (143, 143, 143),
+ 'grey57': (145, 145, 145),
+ 'grey58': (148, 148, 148),
+ 'grey59': (150, 150, 150),
+ 'grey6': (15, 15, 15),
+ 'grey60': (153, 153, 153),
+ 'grey61': (156, 156, 156),
+ 'grey62': (158, 158, 158),
+ 'grey63': (161, 161, 161),
+ 'grey64': (163, 163, 163),
+ 'grey65': (166, 166, 166),
+ 'grey66': (168, 168, 168),
+ 'grey67': (171, 171, 171),
+ 'grey68': (173, 173, 173),
+ 'grey69': (176, 176, 176),
+ 'grey7': (18, 18, 18),
+ 'grey70': (179, 179, 179),
+ 'grey71': (181, 181, 181),
+ 'grey72': (184, 184, 184),
+ 'grey73': (186, 186, 186),
+ 'grey74': (189, 189, 189),
+ 'grey75': (191, 191, 191),
+ 'grey76': (194, 194, 194),
+ 'grey77': (196, 196, 196),
+ 'grey78': (199, 199, 199),
+ 'grey79': (201, 201, 201),
+ 'grey8': (20, 20, 20),
+ 'grey80': (204, 204, 204),
+ 'grey81': (207, 207, 207),
+ 'grey82': (209, 209, 209),
+ 'grey83': (212, 212, 212),
+ 'grey84': (214, 214, 214),
+ 'grey85': (217, 217, 217),
+ 'grey86': (219, 219, 219),
+ 'grey87': (222, 222, 222),
+ 'grey88': (224, 224, 224),
+ 'grey89': (227, 227, 227),
+ 'grey9': (23, 23, 23),
+ 'grey90': (229, 229, 229),
+ 'grey91': (232, 232, 232),
+ 'grey92': (235, 235, 235),
+ 'grey93': (237, 237, 237),
+ 'grey94': (240, 240, 240),
+ 'grey95': (242, 242, 242),
+ 'grey96': (245, 245, 245),
+ 'grey97': (247, 247, 247),
+ 'grey98': (250, 250, 250),
+ 'grey99': (252, 252, 252),
+ 'honeydew': (240, 255, 240),
+ 'honeydew1': (240, 255, 240),
+ 'honeydew2': (224, 238, 224),
+ 'honeydew3': (193, 205, 193),
+ 'honeydew4': (131, 139, 131),
+ 'hotpink': (255, 105, 180),
+ 'hotpink1': (255, 110, 180),
+ 'hotpink2': (238, 106, 167),
+ 'hotpink3': (205, 96, 144),
+ 'hotpink4': (139, 58, 98),
+ 'indianred': (205, 92, 92),
+ 'indianred1': (255, 106, 106),
+ 'indianred2': (238, 99, 99),
+ 'indianred3': (205, 85, 85),
+ 'indianred4': (139, 58, 58),
+ 'indigo': (75, 0, 130),
+ 'invis': (255, 255, 254),
+ 'ivory': (255, 255, 240),
+ 'ivory1': (255, 255, 240),
+ 'ivory2': (238, 238, 224),
+ 'ivory3': (205, 205, 193),
+ 'ivory4': (139, 139, 131),
+ 'khaki': (240, 230, 140),
+ 'khaki1': (255, 246, 143),
+ 'khaki2': (238, 230, 133),
+ 'khaki3': (205, 198, 115),
+ 'khaki4': (139, 134, 78),
+ 'lavender': (230, 230, 250),
+ 'lavenderblush': (255, 240, 245),
+ 'lavenderblush1': (255, 240, 245),
+ 'lavenderblush2': (238, 224, 229),
+ 'lavenderblush3': (205, 193, 197),
+ 'lavenderblush4': (139, 131, 134),
+ 'lawngreen': (124, 252, 0),
+ 'lemonchiffon': (255, 250, 205),
+ 'lemonchiffon1': (255, 250, 205),
+ 'lemonchiffon2': (238, 233, 191),
+ 'lemonchiffon3': (205, 201, 165),
+ 'lemonchiffon4': (139, 137, 112),
+ 'lightblue': (173, 216, 230),
+ 'lightblue1': (191, 239, 255),
+ 'lightblue2': (178, 223, 238),
+ 'lightblue3': (154, 192, 205),
+ 'lightblue4': (104, 131, 139),
+ 'lightcoral': (240, 128, 128),
+ 'lightcyan': (224, 255, 255),
+ 'lightcyan1': (224, 255, 255),
+ 'lightcyan2': (209, 238, 238),
+ 'lightcyan3': (180, 205, 205),
+ 'lightcyan4': (122, 139, 139),
+ 'lightgoldenrod': (238, 221, 130),
+ 'lightgoldenrod1': (255, 236, 139),
+ 'lightgoldenrod2': (238, 220, 130),
+ 'lightgoldenrod3': (205, 190, 112),
+ 'lightgoldenrod4': (139, 129, 76),
+ 'lightgoldenrodyellow': (250, 250, 210),
+ 'lightgray': (211, 211, 211),
+ 'lightgrey': (211, 211, 211),
+ 'lightpink': (255, 182, 193),
+ 'lightpink1': (255, 174, 185),
+ 'lightpink2': (238, 162, 173),
+ 'lightpink3': (205, 140, 149),
+ 'lightpink4': (139, 95, 101),
+ 'lightsalmon': (255, 160, 122),
+ 'lightsalmon1': (255, 160, 122),
+ 'lightsalmon2': (238, 149, 114),
+ 'lightsalmon3': (205, 129, 98),
+ 'lightsalmon4': (139, 87, 66),
+ 'lightseagreen': (32, 178, 170),
+ 'lightskyblue': (135, 206, 250),
+ 'lightskyblue1': (176, 226, 255),
+ 'lightskyblue2': (164, 211, 238),
+ 'lightskyblue3': (141, 182, 205),
+ 'lightskyblue4': (96, 123, 139),
+ 'lightslateblue': (132, 112, 255),
+ 'lightslategray': (119, 136, 153),
+ 'lightslategrey': (119, 136, 153),
+ 'lightsteelblue': (176, 196, 222),
+ 'lightsteelblue1': (202, 225, 255),
+ 'lightsteelblue2': (188, 210, 238),
+ 'lightsteelblue3': (162, 181, 205),
+ 'lightsteelblue4': (110, 123, 139),
+ 'lightyellow': (255, 255, 224),
+ 'lightyellow1': (255, 255, 224),
+ 'lightyellow2': (238, 238, 209),
+ 'lightyellow3': (205, 205, 180),
+ 'lightyellow4': (139, 139, 122),
+ 'limegreen': (50, 205, 50),
+ 'linen': (250, 240, 230),
+ 'magenta': (255, 0, 255),
+ 'magenta1': (255, 0, 255),
+ 'magenta2': (238, 0, 238),
+ 'magenta3': (205, 0, 205),
+ 'magenta4': (139, 0, 139),
+ 'maroon': (176, 48, 96),
+ 'maroon1': (255, 52, 179),
+ 'maroon2': (238, 48, 167),
+ 'maroon3': (205, 41, 144),
+ 'maroon4': (139, 28, 98),
+ 'mediumaquamarine': (102, 205, 170),
+ 'mediumblue': (0, 0, 205),
+ 'mediumorchid': (186, 85, 211),
+ 'mediumorchid1': (224, 102, 255),
+ 'mediumorchid2': (209, 95, 238),
+ 'mediumorchid3': (180, 82, 205),
+ 'mediumorchid4': (122, 55, 139),
+ 'mediumpurple': (147, 112, 219),
+ 'mediumpurple1': (171, 130, 255),
+ 'mediumpurple2': (159, 121, 238),
+ 'mediumpurple3': (137, 104, 205),
+ 'mediumpurple4': (93, 71, 139),
+ 'mediumseagreen': (60, 179, 113),
+ 'mediumslateblue': (123, 104, 238),
+ 'mediumspringgreen': (0, 250, 154),
+ 'mediumturquoise': (72, 209, 204),
+ 'mediumvioletred': (199, 21, 133),
+ 'midnightblue': (25, 25, 112),
+ 'mintcream': (245, 255, 250),
+ 'mistyrose': (255, 228, 225),
+ 'mistyrose1': (255, 228, 225),
+ 'mistyrose2': (238, 213, 210),
+ 'mistyrose3': (205, 183, 181),
+ 'mistyrose4': (139, 125, 123),
+ 'moccasin': (255, 228, 181),
+ 'navajowhite': (255, 222, 173),
+ 'navajowhite1': (255, 222, 173),
+ 'navajowhite2': (238, 207, 161),
+ 'navajowhite3': (205, 179, 139),
+ 'navajowhite4': (139, 121, 94),
+ 'navy': (0, 0, 128),
+ 'navyblue': (0, 0, 128),
+ 'none': (255, 255, 254),
+ 'oldlace': (253, 245, 230),
+ 'olivedrab': (107, 142, 35),
+ 'olivedrab1': (192, 255, 62),
+ 'olivedrab2': (179, 238, 58),
+ 'olivedrab3': (154, 205, 50),
+ 'olivedrab4': (105, 139, 34),
+ 'orange': (255, 165, 0),
+ 'orange1': (255, 165, 0),
+ 'orange2': (238, 154, 0),
+ 'orange3': (205, 133, 0),
+ 'orange4': (139, 90, 0),
+ 'orangered': (255, 69, 0),
+ 'orangered1': (255, 69, 0),
+ 'orangered2': (238, 64, 0),
+ 'orangered3': (205, 55, 0),
+ 'orangered4': (139, 37, 0),
+ 'orchid': (218, 112, 214),
+ 'orchid1': (255, 131, 250),
+ 'orchid2': (238, 122, 233),
+ 'orchid3': (205, 105, 201),
+ 'orchid4': (139, 71, 137),
+ 'palegoldenrod': (238, 232, 170),
+ 'palegreen': (152, 251, 152),
+ 'palegreen1': (154, 255, 154),
+ 'palegreen2': (144, 238, 144),
+ 'palegreen3': (124, 205, 124),
+ 'palegreen4': (84, 139, 84),
+ 'paleturquoise': (175, 238, 238),
+ 'paleturquoise1': (187, 255, 255),
+ 'paleturquoise2': (174, 238, 238),
+ 'paleturquoise3': (150, 205, 205),
+ 'paleturquoise4': (102, 139, 139),
+ 'palevioletred': (219, 112, 147),
+ 'palevioletred1': (255, 130, 171),
+ 'palevioletred2': (238, 121, 159),
+ 'palevioletred3': (205, 104, 137),
+ 'palevioletred4': (139, 71, 93),
+ 'papayawhip': (255, 239, 213),
+ 'peachpuff': (255, 218, 185),
+ 'peachpuff1': (255, 218, 185),
+ 'peachpuff2': (238, 203, 173),
+ 'peachpuff3': (205, 175, 149),
+ 'peachpuff4': (139, 119, 101),
+ 'peru': (205, 133, 63),
+ 'pink': (255, 192, 203),
+ 'pink1': (255, 181, 197),
+ 'pink2': (238, 169, 184),
+ 'pink3': (205, 145, 158),
+ 'pink4': (139, 99, 108),
+ 'plum': (221, 160, 221),
+ 'plum1': (255, 187, 255),
+ 'plum2': (238, 174, 238),
+ 'plum3': (205, 150, 205),
+ 'plum4': (139, 102, 139),
+ 'powderblue': (176, 224, 230),
+ 'purple': (160, 32, 240),
+ 'purple1': (155, 48, 255),
+ 'purple2': (145, 44, 238),
+ 'purple3': (125, 38, 205),
+ 'purple4': (85, 26, 139),
+ 'red': (255, 0, 0),
+ 'red1': (255, 0, 0),
+ 'red2': (238, 0, 0),
+ 'red3': (205, 0, 0),
+ 'red4': (139, 0, 0),
+ 'rosybrown': (188, 143, 143),
+ 'rosybrown1': (255, 193, 193),
+ 'rosybrown2': (238, 180, 180),
+ 'rosybrown3': (205, 155, 155),
+ 'rosybrown4': (139, 105, 105),
+ 'royalblue': (65, 105, 225),
+ 'royalblue1': (72, 118, 255),
+ 'royalblue2': (67, 110, 238),
+ 'royalblue3': (58, 95, 205),
+ 'royalblue4': (39, 64, 139),
+ 'saddlebrown': (139, 69, 19),
+ 'salmon': (250, 128, 114),
+ 'salmon1': (255, 140, 105),
+ 'salmon2': (238, 130, 98),
+ 'salmon3': (205, 112, 84),
+ 'salmon4': (139, 76, 57),
+ 'sandybrown': (244, 164, 96),
+ 'seagreen': (46, 139, 87),
+ 'seagreen1': (84, 255, 159),
+ 'seagreen2': (78, 238, 148),
+ 'seagreen3': (67, 205, 128),
+ 'seagreen4': (46, 139, 87),
+ 'seashell': (255, 245, 238),
+ 'seashell1': (255, 245, 238),
+ 'seashell2': (238, 229, 222),
+ 'seashell3': (205, 197, 191),
+ 'seashell4': (139, 134, 130),
+ 'sienna': (160, 82, 45),
+ 'sienna1': (255, 130, 71),
+ 'sienna2': (238, 121, 66),
+ 'sienna3': (205, 104, 57),
+ 'sienna4': (139, 71, 38),
+ 'skyblue': (135, 206, 235),
+ 'skyblue1': (135, 206, 255),
+ 'skyblue2': (126, 192, 238),
+ 'skyblue3': (108, 166, 205),
+ 'skyblue4': (74, 112, 139),
+ 'slateblue': (106, 90, 205),
+ 'slateblue1': (131, 111, 255),
+ 'slateblue2': (122, 103, 238),
+ 'slateblue3': (105, 89, 205),
+ 'slateblue4': (71, 60, 139),
+ 'slategray': (112, 128, 144),
+ 'slategray1': (198, 226, 255),
+ 'slategray2': (185, 211, 238),
+ 'slategray3': (159, 182, 205),
+ 'slategray4': (108, 123, 139),
+ 'slategrey': (112, 128, 144),
+ 'snow': (255, 250, 250),
+ 'snow1': (255, 250, 250),
+ 'snow2': (238, 233, 233),
+ 'snow3': (205, 201, 201),
+ 'snow4': (139, 137, 137),
+ 'springgreen': (0, 255, 127),
+ 'springgreen1': (0, 255, 127),
+ 'springgreen2': (0, 238, 118),
+ 'springgreen3': (0, 205, 102),
+ 'springgreen4': (0, 139, 69),
+ 'steelblue': (70, 130, 180),
+ 'steelblue1': (99, 184, 255),
+ 'steelblue2': (92, 172, 238),
+ 'steelblue3': (79, 148, 205),
+ 'steelblue4': (54, 100, 139),
+ 'tan': (210, 180, 140),
+ 'tan1': (255, 165, 79),
+ 'tan2': (238, 154, 73),
+ 'tan3': (205, 133, 63),
+ 'tan4': (139, 90, 43),
+ 'thistle': (216, 191, 216),
+ 'thistle1': (255, 225, 255),
+ 'thistle2': (238, 210, 238),
+ 'thistle3': (205, 181, 205),
+ 'thistle4': (139, 123, 139),
+ 'tomato': (255, 99, 71),
+ 'tomato1': (255, 99, 71),
+ 'tomato2': (238, 92, 66),
+ 'tomato3': (205, 79, 57),
+ 'tomato4': (139, 54, 38),
+ 'transparent': (255, 255, 254),
+ 'turquoise': (64, 224, 208),
+ 'turquoise1': (0, 245, 255),
+ 'turquoise2': (0, 229, 238),
+ 'turquoise3': (0, 197, 205),
+ 'turquoise4': (0, 134, 139),
+ 'violet': (238, 130, 238),
+ 'violetred': (208, 32, 144),
+ 'violetred1': (255, 62, 150),
+ 'violetred2': (238, 58, 140),
+ 'violetred3': (205, 50, 120),
+ 'violetred4': (139, 34, 82),
+ 'wheat': (245, 222, 179),
+ 'wheat1': (255, 231, 186),
+ 'wheat2': (238, 216, 174),
+ 'wheat3': (205, 186, 150),
+ 'wheat4': (139, 126, 102),
+ 'white': (255, 255, 255),
+ 'whitesmoke': (245, 245, 245),
+ 'yellow': (255, 255, 0),
+ 'yellow1': (255, 255, 0),
+ 'yellow2': (238, 238, 0),
+ 'yellow3': (205, 205, 0),
+ 'yellow4': (139, 139, 0),
+ 'yellowgreen': (154, 205, 50),
}
re_nonword=re.compile(r'([^0-9a-zA-Z_.]+)')
re_linewidth=re.compile(r'setlinewidth\((\d+(\.\d*)?|\.\d+)\)')
diff --git a/lib_pypy/cffi.egg-info/PKG-INFO b/lib_pypy/cffi.egg-info/PKG-INFO
--- a/lib_pypy/cffi.egg-info/PKG-INFO
+++ b/lib_pypy/cffi.egg-info/PKG-INFO
@@ -1,6 +1,6 @@
Metadata-Version: 1.1
Name: cffi
-Version: 1.5.0
+Version: 1.5.1
Summary: Foreign Function Interface for Python calling C code.
Home-page: http://cffi.readthedocs.org
Author: Armin Rigo, Maciej Fijalkowski
diff --git a/lib_pypy/cffi/__init__.py b/lib_pypy/cffi/__init__.py
--- a/lib_pypy/cffi/__init__.py
+++ b/lib_pypy/cffi/__init__.py
@@ -4,8 +4,8 @@
from .api import FFI, CDefError, FFIError
from .ffiplatform import VerificationError, VerificationMissing
-__version__ = "1.5.0"
-__version_info__ = (1, 5, 0)
+__version__ = "1.5.1"
+__version_info__ = (1, 5, 1)
# The verifier module file names are based on the CRC32 of a string that
# contains the following version number. It may be older than __version__
diff --git a/lib_pypy/cffi/_cffi_include.h b/lib_pypy/cffi/_cffi_include.h
--- a/lib_pypy/cffi/_cffi_include.h
+++ b/lib_pypy/cffi/_cffi_include.h
@@ -231,6 +231,12 @@
((got_nonpos) == (expected <= 0) && \
(got) == (unsigned long long)expected)
+#ifdef MS_WIN32
+# define _cffi_stdcall __stdcall
+#else
+# define _cffi_stdcall /* nothing */
+#endif
+
#ifdef __cplusplus
}
#endif
diff --git a/lib_pypy/cffi/_embedding.h b/lib_pypy/cffi/_embedding.h
new file mode 100644
--- /dev/null
+++ b/lib_pypy/cffi/_embedding.h
@@ -0,0 +1,517 @@
+
+/***** Support code for embedding *****/
+
+#if defined(_MSC_VER)
+# define CFFI_DLLEXPORT __declspec(dllexport)
+#elif defined(__GNUC__)
+# define CFFI_DLLEXPORT __attribute__((visibility("default")))
+#else
+# define CFFI_DLLEXPORT /* nothing */
+#endif
+
+
+/* There are two global variables of type _cffi_call_python_fnptr:
+
+ * _cffi_call_python, which we declare just below, is the one called
+ by ``extern "Python"`` implementations.
+
+ * _cffi_call_python_org, which on CPython is actually part of the
+ _cffi_exports[] array, is the function pointer copied from
+ _cffi_backend.
+
+ After initialization is complete, both are equal. However, the
+ first one remains equal to &_cffi_start_and_call_python until the
+ very end of initialization, when we are (or should be) sure that
+ concurrent threads also see a completely initialized world, and
+ only then is it changed.
+*/
+#undef _cffi_call_python
+typedef void (*_cffi_call_python_fnptr)(struct _cffi_externpy_s *, char *);
+static void _cffi_start_and_call_python(struct _cffi_externpy_s *, char *);
+static _cffi_call_python_fnptr _cffi_call_python =
&_cffi_start_and_call_python;
+
+
+#ifndef _MSC_VER
+ /* --- Assuming a GCC not infinitely old --- */
+# define cffi_compare_and_swap(l,o,n) __sync_bool_compare_and_swap(l,o,n)
+# define cffi_write_barrier() __sync_synchronize()
+# if !defined(__amd64__) && !defined(__x86_64__) && \
+ !defined(__i386__) && !defined(__i386)
+# define cffi_read_barrier() __sync_synchronize()
+# else
+# define cffi_read_barrier() (void)0
+# endif
+#else
+ /* --- Windows threads version --- */
+# include <Windows.h>
+# define cffi_compare_and_swap(l,o,n) \
+ (InterlockedCompareExchangePointer(l,n,o) ==
(o))
+# define cffi_write_barrier()
InterlockedCompareExchange(&_cffi_dummy,0,0)
+# define cffi_read_barrier() (void)0
+static volatile LONG _cffi_dummy;
+#endif
+
+#ifdef WITH_THREAD
+# ifndef _MSC_VER
+# include <pthread.h>
+ static pthread_mutex_t _cffi_embed_startup_lock;
+# else
+ static CRITICAL_SECTION _cffi_embed_startup_lock;
+# endif
+ static char _cffi_embed_startup_lock_ready = 0;
+#endif
+
+static void _cffi_acquire_reentrant_mutex(void)
+{
+ static void *volatile lock = NULL;
+
+ while (!cffi_compare_and_swap(&lock, NULL, (void *)1)) {
+ /* should ideally do a spin loop instruction here, but
+ hard to do it portably and doesn't really matter I
+ think: pthread_mutex_init() should be very fast, and
+ this is only run at start-up anyway. */
+ }
+
+#ifdef WITH_THREAD
+ if (!_cffi_embed_startup_lock_ready) {
+# ifndef _MSC_VER
+ pthread_mutexattr_t attr;
+ pthread_mutexattr_init(&attr);
+ pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
+ pthread_mutex_init(&_cffi_embed_startup_lock, &attr);
+# else
+ InitializeCriticalSection(&_cffi_embed_startup_lock);
+# endif
+ _cffi_embed_startup_lock_ready = 1;
+ }
+#endif
+
+ while (!cffi_compare_and_swap(&lock, (void *)1, NULL))
+ ;
+
+#ifndef _MSC_VER
+ pthread_mutex_lock(&_cffi_embed_startup_lock);
+#else
+ EnterCriticalSection(&_cffi_embed_startup_lock);
+#endif
+}
+
+static void _cffi_release_reentrant_mutex(void)
+{
+#ifndef _MSC_VER
+ pthread_mutex_unlock(&_cffi_embed_startup_lock);
+#else
+ LeaveCriticalSection(&_cffi_embed_startup_lock);
+#endif
+}
+
+
+/********** CPython-specific section **********/
+#ifndef PYPY_VERSION
+
+
+#define _cffi_call_python_org _cffi_exports[_CFFI_CPIDX]
+
+PyMODINIT_FUNC _CFFI_PYTHON_STARTUP_FUNC(void); /* forward */
+
+static void _cffi_py_initialize(void)
+{
+ /* XXX use initsigs=0, which "skips initialization registration of
+ signal handlers, which might be useful when Python is
+ embedded" according to the Python docs. But review and think
+ if it should be a user-controllable setting.
+
+ XXX we should also give a way to write errors to a buffer
+ instead of to stderr.
+
+ XXX if importing 'site' fails, CPython (any version) calls
+ exit(). Should we try to work around this behavior here?
+ */
+ Py_InitializeEx(0);
+}
+
+static int _cffi_initialize_python(void)
+{
+ /* This initializes Python, imports _cffi_backend, and then the
+ present .dll/.so is set up as a CPython C extension module.
+ */
+ int result;
+ PyGILState_STATE state;
+ PyObject *pycode=NULL, *global_dict=NULL, *x;
+
+#if PY_MAJOR_VERSION >= 3
+ /* see comments in _cffi_carefully_make_gil() about the
+ Python2/Python3 difference
+ */
+#else
+ /* Acquire the GIL. We have no threadstate here. If Python is
+ already initialized, it is possible that there is already one
+ existing for this thread, but it is not made current now.
+ */
+ PyEval_AcquireLock();
+
+ _cffi_py_initialize();
+
+ /* The Py_InitializeEx() sometimes made a threadstate for us, but
+ not always. Indeed Py_InitializeEx() could be called and do
+ nothing. So do we have a threadstate, or not? We don't know,
+ but we can replace it with NULL in all cases.
+ */
+ (void)PyThreadState_Swap(NULL);
+
+ /* Now we can release the GIL and re-acquire immediately using the
+ logic of PyGILState(), which handles making or installing the
+ correct threadstate.
+ */
+ PyEval_ReleaseLock();
+#endif
+ state = PyGILState_Ensure();
+
+ /* Call the initxxx() function from the present module. It will
+ create and initialize us as a CPython extension module, instead
+ of letting the startup Python code do it---it might reimport
+ the same .dll/.so and get maybe confused on some platforms.
+ It might also have troubles locating the .dll/.so again for all
+ I know.
+ */
+ (void)_CFFI_PYTHON_STARTUP_FUNC();
+ if (PyErr_Occurred())
+ goto error;
+
+ /* Now run the Python code provided to ffi.embedding_init_code().
+ */
+ pycode = Py_CompileString(_CFFI_PYTHON_STARTUP_CODE,
+ "<init code for '" _CFFI_MODULE_NAME "'>",
+ Py_file_input);
+ if (pycode == NULL)
+ goto error;
+ global_dict = PyDict_New();
+ if (global_dict == NULL)
+ goto error;
+ if (PyDict_SetItemString(global_dict, "__builtins__",
+ PyThreadState_GET()->interp->builtins) < 0)
+ goto error;
+ x = PyEval_EvalCode(
+#if PY_MAJOR_VERSION < 3
+ (PyCodeObject *)
+#endif
+ pycode, global_dict, global_dict);
+ if (x == NULL)
+ goto error;
+ Py_DECREF(x);
+
+ /* Done! Now if we've been called from
+ _cffi_start_and_call_python() in an ``extern "Python"``, we can
+ only hope that the Python code did correctly set up the
+ corresponding @ffi.def_extern() function. Otherwise, the
+ general logic of ``extern "Python"`` functions (inside the
+ _cffi_backend module) will find that the reference is still
+ missing and print an error.
+ */
+ result = 0;
+ done:
+ Py_XDECREF(pycode);
+ Py_XDECREF(global_dict);
+ PyGILState_Release(state);
+ return result;
+
+ error:;
+ {
+ /* Print as much information as potentially useful.
+ Debugging load-time failures with embedding is not fun
+ */
+ PyObject *exception, *v, *tb, *f, *modules, *mod;
+ PyErr_Fetch(&exception, &v, &tb);
+ if (exception != NULL) {
+ PyErr_NormalizeException(&exception, &v, &tb);
+ PyErr_Display(exception, v, tb);
+ }
+ Py_XDECREF(exception);
+ Py_XDECREF(v);
+ Py_XDECREF(tb);
+
+ f = PySys_GetObject((char *)"stderr");
+ if (f != NULL && f != Py_None) {
+ PyFile_WriteString("\nFrom: " _CFFI_MODULE_NAME
+ "\ncompiled with cffi version: 1.5.1"
+ "\n_cffi_backend module: ", f);
+ modules = PyImport_GetModuleDict();
+ mod = PyDict_GetItemString(modules, "_cffi_backend");
+ if (mod == NULL) {
+ PyFile_WriteString("not loaded", f);
+ }
+ else {
+ v = PyObject_GetAttrString(mod, "__file__");
+ PyFile_WriteObject(v, f, 0);
+ Py_XDECREF(v);
+ }
+ PyFile_WriteString("\nsys.path: ", f);
+ PyFile_WriteObject(PySys_GetObject((char *)"path"), f, 0);
+ PyFile_WriteString("\n\n", f);
+ }
+ }
+ result = -1;
+ goto done;
+}
+
+PyAPI_DATA(char *) _PyParser_TokenNames[]; /* from CPython */
+
+static int _cffi_carefully_make_gil(void)
+{
+ /* This does the basic initialization of Python. It can be called
+ completely concurrently from unrelated threads. It assumes
+ that we don't hold the GIL before (if it exists), and we don't
+ hold it afterwards.
+
+ What it really does is completely different in Python 2 and
+ Python 3.
+
+ Python 2
+ ========
+
+ Initialize the GIL, without initializing the rest of Python,
+ by calling PyEval_InitThreads().
+
+ PyEval_InitThreads() must not be called concurrently at all.
+ So we use a global variable as a simple spin lock. This global
+ variable must be from 'libpythonX.Y.so', not from this
+ cffi-based extension module, because it must be shared from
+ different cffi-based extension modules. We choose
+ _PyParser_TokenNames[0] as a completely arbitrary pointer value
+ that is never written to. The default is to point to the
+ string "ENDMARKER". We change it temporarily to point to the
+ next character in that string. (Yes, I know it's REALLY
+ obscure.)
+
+ Python 3
+ ========
+
+ In Python 3, PyEval_InitThreads() cannot be called before
+ Py_InitializeEx() any more. So this function calls
+ Py_InitializeEx() first. It uses the same obscure logic to
+ make sure we never call it concurrently.
+
+ Arguably, this is less good on the spinlock, because
+ Py_InitializeEx() takes much longer to run than
+ PyEval_InitThreads(). But I didn't find a way around it.
+ */
+
+#ifdef WITH_THREAD
+ char *volatile *lock = (char *volatile *)_PyParser_TokenNames;
+ char *old_value;
+
+ while (1) { /* spin loop */
+ old_value = *lock;
+ if (old_value[0] == 'E') {
+ assert(old_value[1] == 'N');
+ if (cffi_compare_and_swap(lock, old_value, old_value + 1))
+ break;
+ }
+ else {
+ assert(old_value[0] == 'N');
+ /* should ideally do a spin loop instruction here, but
+ hard to do it portably and doesn't really matter I
+ think: PyEval_InitThreads() should be very fast, and
+ this is only run at start-up anyway. */
+ }
+ }
+#endif
+
+#if PY_MAJOR_VERSION >= 3
+ /* Python 3: call Py_InitializeEx() */
+ {
+ PyGILState_STATE state = PyGILState_UNLOCKED;
+ if (!Py_IsInitialized())
+ _cffi_py_initialize();
+ else
+ state = PyGILState_Ensure();
+
+ PyEval_InitThreads();
+ PyGILState_Release(state);
+ }
+#else
+ /* Python 2: call PyEval_InitThreads() */
+# ifdef WITH_THREAD
+ if (!PyEval_ThreadsInitialized()) {
+ PyEval_InitThreads(); /* makes the GIL */
+ PyEval_ReleaseLock(); /* then release it */
+ }
+ /* else: there is already a GIL, but we still needed to do the
+ spinlock dance to make sure that we see it as fully ready */
+# endif
+#endif
+
+#ifdef WITH_THREAD
+ /* release the lock */
+ while (!cffi_compare_and_swap(lock, old_value + 1, old_value))
+ ;
+#endif
+
+ return 0;
+}
+
+/********** end CPython-specific section **********/
+
+
+#else
+
+
+/********** PyPy-specific section **********/
+
+PyMODINIT_FUNC _CFFI_PYTHON_STARTUP_FUNC(const void *[]); /* forward */
+
+static struct _cffi_pypy_init_s {
+ const char *name;
+ void (*func)(const void *[]);
+ const char *code;
+} _cffi_pypy_init = {
+ _CFFI_MODULE_NAME,
+ _CFFI_PYTHON_STARTUP_FUNC,
+ _CFFI_PYTHON_STARTUP_CODE,
+};
+
+extern int pypy_carefully_make_gil(const char *);
+extern int pypy_init_embedded_cffi_module(int, struct _cffi_pypy_init_s *);
+
+static int _cffi_carefully_make_gil(void)
+{
+ return pypy_carefully_make_gil(_CFFI_MODULE_NAME);
+}
+
+static int _cffi_initialize_python(void)
+{
+ return pypy_init_embedded_cffi_module(0xB011, &_cffi_pypy_init);
+}
+
+/********** end PyPy-specific section **********/
+
+
+#endif
+
+
+#ifdef __GNUC__
+__attribute__((noinline))
+#endif
+static _cffi_call_python_fnptr _cffi_start_python(void)
+{
+ /* Delicate logic to initialize Python. This function can be
+ called multiple times concurrently, e.g. when the process calls
+ its first ``extern "Python"`` functions in multiple threads at
+ once. It can also be called recursively, in which case we must
+ ignore it. We also have to consider what occurs if several
+ different cffi-based extensions reach this code in parallel
+ threads---it is a different copy of the code, then, and we
+ can't have any shared global variable unless it comes from
+ 'libpythonX.Y.so'.
+
+ Idea:
+
+ * _cffi_carefully_make_gil(): "carefully" call
+ PyEval_InitThreads() (possibly with Py_InitializeEx() first).
+
+ * then we use a (local) custom lock to make sure that a call to this
+ cffi-based extension will wait if another call to the *same*
+ extension is running the initialization in another thread.
+ It is reentrant, so that a recursive call will not block, but
+ only one from a different thread.
+
+ * then we grab the GIL and (Python 2) we call Py_InitializeEx().
+ At this point, concurrent calls to Py_InitializeEx() are not
+ possible: we have the GIL.
+
+ * do the rest of the specific initialization, which may
+ temporarily release the GIL but not the custom lock.
+ Only release the custom lock when we are done.
+ */
+ static char called = 0;
+
+ if (_cffi_carefully_make_gil() != 0)
+ return NULL;
+
+ _cffi_acquire_reentrant_mutex();
+
+ /* Here the GIL exists, but we don't have it. We're only protected
+ from concurrency by the reentrant mutex. */
+
+ /* This file only initializes the embedded module once, the first
+ time this is called, even if there are subinterpreters. */
+ if (!called) {
+ called = 1; /* invoke _cffi_initialize_python() only once,
+ but don't set '_cffi_call_python' right now,
+ otherwise concurrent threads won't call
+ this function at all (we need them to wait) */
+ if (_cffi_initialize_python() == 0) {
+ /* now initialization is finished. Switch to the fast-path. */
+
+ /* We would like nobody to see the new value of
+ '_cffi_call_python' without also seeing the rest of the
+ data initialized. However, this is not possible. But
+ the new value of '_cffi_call_python' is the function
+ 'cffi_call_python()' from _cffi_backend. So: */
+ cffi_write_barrier();
+ /* ^^^ we put a write barrier here, and a corresponding
+ read barrier at the start of cffi_call_python(). This
+ ensures that after that read barrier, we see everything
+ done here before the write barrier.
+ */
+
+ assert(_cffi_call_python_org != NULL);
+ _cffi_call_python = (_cffi_call_python_fnptr)_cffi_call_python_org;
+ }
+ else {
+ /* initialization failed. Reset this to NULL, even if it was
+ already set to some other value. Future calls to
+ _cffi_start_python() are still forced to occur, and will
+ always return NULL from now on. */
+ _cffi_call_python_org = NULL;
+ }
+ }
+
+ _cffi_release_reentrant_mutex();
+
+ return (_cffi_call_python_fnptr)_cffi_call_python_org;
+}
+
+static
+void _cffi_start_and_call_python(struct _cffi_externpy_s *externpy, char *args)
+{
+ _cffi_call_python_fnptr fnptr;
+ int current_err = errno;
+#ifdef _MSC_VER
+ int current_lasterr = GetLastError();
+#endif
+ fnptr = _cffi_start_python();
+ if (fnptr == NULL) {
+ fprintf(stderr, "function %s() called, but initialization code "
+ "failed. Returning 0.\n", externpy->name);
+ memset(args, 0, externpy->size_of_result);
+ }
+#ifdef _MSC_VER
+ SetLastError(current_lasterr);
+#endif
+ errno = current_err;
+
+ if (fnptr != NULL)
+ fnptr(externpy, args);
+}
+
+
+/* The cffi_start_python() function makes sure Python is initialized
+ and our cffi module is set up. It can be called manually from the
+ user C code. The same effect is obtained automatically from any
+ dll-exported ``extern "Python"`` function. This function returns
+ -1 if initialization failed, 0 if all is OK. */
+_CFFI_UNUSED_FN
+static int cffi_start_python(void)
+{
+ if (_cffi_call_python == &_cffi_start_and_call_python) {
+ if (_cffi_start_python() == NULL)
+ return -1;
+ }
+ cffi_read_barrier();
+ return 0;
+}
+
+#undef cffi_compare_and_swap
+#undef cffi_write_barrier
+#undef cffi_read_barrier
diff --git a/lib_pypy/cffi/api.py b/lib_pypy/cffi/api.py
--- a/lib_pypy/cffi/api.py
+++ b/lib_pypy/cffi/api.py
@@ -1,4 +1,4 @@
-import sys, types
+import sys, sysconfig, types
from .lock import allocate_lock
try:
@@ -544,28 +544,32 @@
def _apply_embedding_fix(self, kwds):
# must include an argument like "-lpython2.7" for the compiler
+ def ensure(key, value):
+ lst = kwds.setdefault(key, [])
+ if value not in lst:
+ lst.append(value)
+ #
if '__pypy__' in sys.builtin_module_names:
if hasattr(sys, 'prefix'):
import os
- libdir = os.path.join(sys.prefix, 'bin')
- dirs = kwds.setdefault('library_dirs', [])
- if libdir not in dirs:
- dirs.append(libdir)
+ ensure('library_dirs', os.path.join(sys.prefix, 'bin'))
pythonlib = "pypy-c"
else:
if sys.platform == "win32":
template = "python%d%d"
- if sys.flags.debug:
- template = template + '_d'
+ if hasattr(sys, 'gettotalrefcount'):
+ template += '_d'
else:
template = "python%d.%d"
+ if sysconfig.get_config_var('DEBUG_EXT'):
+ template += sysconfig.get_config_var('DEBUG_EXT')
pythonlib = (template %
(sys.hexversion >> 24, (sys.hexversion >> 16) & 0xff))
if hasattr(sys, 'abiflags'):
pythonlib += sys.abiflags
- libraries = kwds.setdefault('libraries', [])
- if pythonlib not in libraries:
- libraries.append(pythonlib)
+ ensure('libraries', pythonlib)
+ if sys.platform == "win32":
+ ensure('extra_link_args', '/MANIFEST')
def set_source(self, module_name, source, source_extension='.c', **kwds):
if hasattr(self, '_assigned_source'):
@@ -631,7 +635,7 @@
compiled DLL. Use '*' to force distutils' choice, suitable for
regular CPython C API modules. Use a file name ending in '.*'
to ask for the system's default extension for dynamic libraries
- (.so/.dll).
+ (.so/.dll/.dylib).
The default is '*' when building a non-embedded C API extension,
and (module_name + '.*') when building an embedded library.
@@ -695,6 +699,10 @@
#
self._embedding = pysource
+ def def_extern(self, *args, **kwds):
+ raise ValueError("ffi.def_extern() is only available on API-mode FFI "
+ "objects")
+
def _load_backend_lib(backend, name, flags):
if name is None:
diff --git a/lib_pypy/cffi/cparser.py b/lib_pypy/cffi/cparser.py
--- a/lib_pypy/cffi/cparser.py
+++ b/lib_pypy/cffi/cparser.py
@@ -220,7 +220,7 @@
self._included_declarations = set()
self._anonymous_counter = 0
self._structnode2type = weakref.WeakKeyDictionary()
- self._options = None
+ self._options = {}
self._int_constants = {}
self._recomplete = []
self._uses_new_feature = None
@@ -374,7 +374,7 @@
def _declare_function(self, tp, quals, decl):
tp = self._get_type_pointer(tp, quals)
- if self._options['dllexport']:
+ if self._options.get('dllexport'):
tag = 'dllexport_python '
elif self._inside_extern_python:
tag = 'extern_python '
@@ -450,7 +450,7 @@
prevobj, prevquals = self._declarations[name]
if prevobj is obj and prevquals == quals:
return
- if not self._options['override']:
+ if not self._options.get('override'):
raise api.FFIError(
"multiple declarations of %s (for interactive usage, "
"try cdef(xx, override=True))" % (name,))
@@ -729,7 +729,7 @@
if isinstance(tp, model.StructType) and tp.partial:
raise NotImplementedError("%s: using both bitfields and '...;'"
% (tp,))
- tp.packed = self._options['packed']
+ tp.packed = self._options.get('packed')
if tp.completed: # must be re-completed: it is not opaque any more
tp.completed = 0
self._recomplete.append(tp)
diff --git a/lib_pypy/cffi/ffiplatform.py b/lib_pypy/cffi/ffiplatform.py
--- a/lib_pypy/cffi/ffiplatform.py
+++ b/lib_pypy/cffi/ffiplatform.py
@@ -21,14 +21,12 @@
allsources.append(os.path.normpath(src))
return Extension(name=modname, sources=allsources, **kwds)
-def compile(tmpdir, ext, compiler_verbose=0, target_extension=None,
- embedding=False):
+def compile(tmpdir, ext, compiler_verbose=0):
"""Compile a C extension module using distutils."""
saved_environ = os.environ.copy()
try:
- outputfilename = _build(tmpdir, ext, compiler_verbose,
- target_extension, embedding)
+ outputfilename = _build(tmpdir, ext, compiler_verbose)
outputfilename = os.path.abspath(outputfilename)
finally:
# workaround for a distutils bugs where some env vars can
@@ -38,32 +36,7 @@
os.environ[key] = value
return outputfilename
-def _save_val(name):
- import distutils.sysconfig
- config_vars = distutils.sysconfig.get_config_vars()
- return config_vars.get(name, Ellipsis)
-
-def _restore_val(name, value):
- import distutils.sysconfig
- config_vars = distutils.sysconfig.get_config_vars()
- config_vars[name] = value
- if value is Ellipsis:
- del config_vars[name]
-
-def _win32_hack_for_embedding():
- from distutils.msvc9compiler import MSVCCompiler
- if not hasattr(MSVCCompiler, '_remove_visual_c_ref_CFFI_BAK'):
- MSVCCompiler._remove_visual_c_ref_CFFI_BAK = \
- MSVCCompiler._remove_visual_c_ref
- MSVCCompiler._remove_visual_c_ref = lambda self,manifest_file:
manifest_file
-
-def _win32_unhack_for_embedding():
- from distutils.msvc9compiler import MSVCCompiler
- MSVCCompiler._remove_visual_c_ref = \
- MSVCCompiler._remove_visual_c_ref_CFFI_BAK
-
-def _build(tmpdir, ext, compiler_verbose=0, target_extension=None,
- embedding=False):
+def _build(tmpdir, ext, compiler_verbose=0):
# XXX compact but horrible :-(
from distutils.core import Distribution
import distutils.errors, distutils.log
@@ -76,25 +49,14 @@
options['build_temp'] = ('ffiplatform', tmpdir)
#
try:
- if sys.platform == 'win32' and embedding:
- _win32_hack_for_embedding()
old_level = distutils.log.set_threshold(0) or 0
- old_SO = _save_val('SO')
- old_EXT_SUFFIX = _save_val('EXT_SUFFIX')
try:
- if target_extension is not None:
- _restore_val('SO', target_extension)
- _restore_val('EXT_SUFFIX', target_extension)
distutils.log.set_verbosity(compiler_verbose)
dist.run_command('build_ext')
cmd_obj = dist.get_command_obj('build_ext')
[soname] = cmd_obj.get_outputs()
finally:
distutils.log.set_threshold(old_level)
- _restore_val('SO', old_SO)
- _restore_val('EXT_SUFFIX', old_EXT_SUFFIX)
- if sys.platform == 'win32' and embedding:
- _win32_unhack_for_embedding()
except (distutils.errors.CompileError,
distutils.errors.LinkError) as e:
raise VerificationError('%s: %s' % (e.__class__.__name__, e))
diff --git a/lib_pypy/cffi/recompiler.py b/lib_pypy/cffi/recompiler.py
--- a/lib_pypy/cffi/recompiler.py
+++ b/lib_pypy/cffi/recompiler.py
@@ -1170,6 +1170,8 @@
repr_arguments = ', '.join(arguments)
repr_arguments = repr_arguments or 'void'
name_and_arguments = '%s(%s)' % (name, repr_arguments)
+ if tp.abi == "__stdcall":
+ name_and_arguments = '_cffi_stdcall ' + name_and_arguments
#
def may_need_128_bits(tp):
return (isinstance(tp, model.PrimitiveType) and
@@ -1357,6 +1359,58 @@
parts[-1] += extension
return os.path.join(outputdir, *parts), parts
+
+# Aaargh. Distutils is not tested at all for the purpose of compiling
+# DLLs that are not extension modules. Here are some hacks to work
+# around that, in the _patch_for_*() functions...
+
+def _patch_meth(patchlist, cls, name, new_meth):
+ old = getattr(cls, name)
+ patchlist.append((cls, name, old))
+ setattr(cls, name, new_meth)
+ return old
+
+def _unpatch_meths(patchlist):
+ for cls, name, old_meth in reversed(patchlist):
+ setattr(cls, name, old_meth)
+
+def _patch_for_embedding(patchlist):
+ if sys.platform == 'win32':
+ # we must not remove the manifest when building for embedding!
+ from distutils.msvc9compiler import MSVCCompiler
+ _patch_meth(patchlist, MSVCCompiler, '_remove_visual_c_ref',
+ lambda self, manifest_file: manifest_file)
+
+ if sys.platform == 'darwin':
+ # we must not make a '-bundle', but a '-dynamiclib' instead
+ from distutils.ccompiler import CCompiler
+ def my_link_shared_object(self, *args, **kwds):
+ if '-bundle' in self.linker_so:
+ self.linker_so = list(self.linker_so)
+ i = self.linker_so.index('-bundle')
+ self.linker_so[i] = '-dynamiclib'
+ return old_link_shared_object(self, *args, **kwds)
+ old_link_shared_object = _patch_meth(patchlist, CCompiler,
+ 'link_shared_object',
+ my_link_shared_object)
+
+def _patch_for_target(patchlist, target):
+ from distutils.command.build_ext import build_ext
+ # if 'target' is different from '*', we need to patch some internal
+ # method to just return this 'target' value, instead of having it
+ # built from module_name
+ if target.endswith('.*'):
+ target = target[:-2]
+ if sys.platform == 'win32':
+ target += '.dll'
+ elif sys.platform == 'darwin':
+ target += '.dylib'
+ else:
+ target += '.so'
+ _patch_meth(patchlist, build_ext, 'get_ext_filename',
+ lambda self, ext_name: target)
+
+
def recompile(ffi, module_name, preamble, tmpdir='.', call_c_compiler=True,
c_file=None, source_extension='.c', extradir=None,
compiler_verbose=1, target=None, **kwds):
@@ -1382,36 +1436,22 @@
target = '%s.*' % module_name
else:
target = '*'
- if target == '*':
- target_module_name = module_name
- target_extension = None # use default
- else:
- if target.endswith('.*'):
- target = target[:-2]
- if sys.platform == 'win32':
- target += '.dll'
- else:
- target += '.so'
- # split along the first '.' (not the last one, otherwise the
- # preceeding dots are interpreted as splitting package names)
- index = target.find('.')
- if index < 0:
- raise ValueError("target argument %r should be a file name "
- "containing a '.'" % (target,))
- target_module_name = target[:index]
- target_extension = target[index:]
#
- ext = ffiplatform.get_extension(ext_c_file, target_module_name, **kwds)
+ ext = ffiplatform.get_extension(ext_c_file, module_name, **kwds)
updated = make_c_source(ffi, module_name, preamble, c_file)
if call_c_compiler:
+ patchlist = []
cwd = os.getcwd()
try:
+ if embedding:
+ _patch_for_embedding(patchlist)
+ if target != '*':
+ _patch_for_target(patchlist, target)
os.chdir(tmpdir)
- outputfilename = ffiplatform.compile('.', ext,
compiler_verbose,
- target_extension,
- embedding=embedding)
+ outputfilename = ffiplatform.compile('.', ext,
compiler_verbose)
finally:
os.chdir(cwd)
+ _unpatch_meths(patchlist)
return outputfilename
else:
return ext, updated
diff --git a/pypy/doc/faq.rst b/pypy/doc/faq.rst
--- a/pypy/doc/faq.rst
+++ b/pypy/doc/faq.rst
@@ -54,7 +54,8 @@
It is quite common nowadays that xyz is available on PyPI_ and
installable with ``pip install xyz``. The simplest solution is to `use
virtualenv (as documented here)`_. Then enter (activate) the virtualenv
-and type: ``pip install xyz``.
+and type: ``pip install xyz``. If you don't know or don't want virtualenv,
+you can also install ``pip`` globally by saying ``pypy -m ensurepip``.
If you get errors from the C compiler, the module is a CPython C
Extension module using unsupported features. `See below.`_
diff --git a/pypy/doc/whatsnew-head.rst b/pypy/doc/whatsnew-head.rst
--- a/pypy/doc/whatsnew-head.rst
+++ b/pypy/doc/whatsnew-head.rst
@@ -123,3 +123,28 @@
.. branch: fix-cpython-ssl-tests-2.7
Fix SSL tests by importing cpython's patch
+
+.. branch: remove-getfield-pure
+
+Remove pure variants of ``getfield_gc_*`` operations from the JIT. Relevant
+optimizations instead consult the field descriptor to determine the purity of
+the operation. Additionally, pure ``getfield`` operations are now handled
+entirely by `rpython/jit/metainterp/optimizeopt/heap.py` rather than
+`rpython/jit/metainterp/optimizeopt/pure.py`, which can result in better
codegen
+for traces containing a large number of pure getfield operations.
+
+.. branch: exctrans
+
+Try to ensure that no new functions get annotated during the 'source_c' phase.
+Refactor sandboxing to operate at a higher level.
+
+.. branch: cpyext-bootstrap
+
+.. branch: vmprof-newstack
+
+Refactor vmprof to work cross-operating-system.
+
+.. branch: seperate-strucmember_h
+
+Seperate structmember.h from Python.h Also enhance creating api functions
+to specify which header file they appear in (previously only pypy_decl.h)
diff --git a/pypy/module/_cffi_backend/__init__.py
b/pypy/module/_cffi_backend/__init__.py
--- a/pypy/module/_cffi_backend/__init__.py
+++ b/pypy/module/_cffi_backend/__init__.py
@@ -3,7 +3,7 @@
from rpython.rlib import rdynload, clibffi, entrypoint
from rpython.rtyper.lltypesystem import rffi
-VERSION = "1.5.0"
+VERSION = "1.5.1"
FFI_DEFAULT_ABI = clibffi.FFI_DEFAULT_ABI
try:
@@ -69,6 +69,7 @@
def startup(self, space):
from pypy.module._cffi_backend import embedding
embedding.glob.space = space
+ embedding.glob.patched_sys = False
def get_dict_rtld_constants():
diff --git a/pypy/module/_cffi_backend/embedding.py
b/pypy/module/_cffi_backend/embedding.py
--- a/pypy/module/_cffi_backend/embedding.py
+++ b/pypy/module/_cffi_backend/embedding.py
@@ -45,6 +45,26 @@
pass
glob = Global()
+def patch_sys(space):
+ # Annoying: CPython would just use the C-level std{in,out,err} as
+ # configured by the main application, for example in binary mode
+ # on Windows or with buffering turned off. We can't easily do the
+ # same. Instead, go for the safest bet (but possibly bad for
+ # performance) and open sys.std{in,out,err} unbuffered. On
+ # Windows I guess binary mode is a better default choice.
+ #
+ # XXX if needed, we could add support for a flag passed to
+ # pypy_init_embedded_cffi_module().
+ if not glob.patched_sys:
+ space.appexec([], """():
+ import os
+ sys.stdin = sys.__stdin__ = os.fdopen(0, 'rb', 0)
+ sys.stdout = sys.__stdout__ = os.fdopen(1, 'wb', 0)
+ sys.stderr = sys.__stderr__ = os.fdopen(2, 'wb', 0)
+ """)
+ glob.patched_sys = True
+
+
def pypy_init_embedded_cffi_module(version, init_struct):
# called from __init__.py
name = "?"
@@ -56,6 +76,7 @@
must_leave = False
try:
must_leave = space.threadlocals.try_enter_thread(space)
+ patch_sys(space)
load_embedded_cffi_module(space, version, init_struct)
res = 0
except OperationError, operr:
@@ -85,14 +106,86 @@
# ____________________________________________________________
+if os.name == 'nt':
-eci = ExternalCompilationInfo(separate_module_sources=[
-r"""
-/* XXX Windows missing */
-#include <stdio.h>
+ do_includes = r"""
+#define _WIN32_WINNT 0x0501
+#include <windows.h>
+
+#define CFFI_INIT_HOME_PATH_MAX _MAX_PATH
+static void _cffi_init(void);
+static void _cffi_init_error(const char *msg, const char *extra);
+
+static int _cffi_init_home(char *output_home_path)
+{
+ HMODULE hModule = 0;
+ DWORD res;
+
+ GetModuleHandleEx(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS |
+ GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT,
+ (LPCTSTR)&_cffi_init, &hModule);
+
+ if (hModule == 0 ) {
+ _cffi_init_error("GetModuleHandleEx() failed", "");
+ return -1;
+ }
+ res = GetModuleFileName(hModule, output_home_path,
CFFI_INIT_HOME_PATH_MAX);
+ if (res >= CFFI_INIT_HOME_PATH_MAX) {
+ return -1;
+ }
+ return 0;
+}
+
+static void _cffi_init_once(void)
+{
+ static LONG volatile lock = 0;
+ static int _init_called = 0;
+
+ while (InterlockedCompareExchange(&lock, 1, 0) != 0) {
+ SwitchToThread(); /* spin loop */
+ }
+ if (!_init_called) {
+ _cffi_init();
+ _init_called = 1;
+ }
+ InterlockedCompareExchange(&lock, 0, 1);
+}
+"""
+
+else:
+
+ do_includes = r"""
#include <dlfcn.h>
#include <pthread.h>
+#define CFFI_INIT_HOME_PATH_MAX PATH_MAX
+static void _cffi_init(void);
+static void _cffi_init_error(const char *msg, const char *extra);
+
+static int _cffi_init_home(char *output_home_path)
+{
+ Dl_info info;
+ dlerror(); /* reset */
+ if (dladdr(&_cffi_init, &info) == 0) {
+ _cffi_init_error("dladdr() failed: ", dlerror());
+ return -1;
+ }
+ if (realpath(info.dli_fname, output_home_path) == NULL) {
+ perror("realpath() failed");
+ _cffi_init_error("realpath() failed", "");
+ return -1;
+ }
+ return 0;
+}
+
+static void _cffi_init_once(void)
+{
+ static pthread_once_t once_control = PTHREAD_ONCE_INIT;
+ pthread_once(&once_control, _cffi_init);
+}
+"""
+
+do_startup = do_includes + r"""
RPY_EXPORTED void rpython_startup_code(void);
RPY_EXPORTED int pypy_setup_home(char *, int);
@@ -108,17 +201,13 @@
static void _cffi_init(void)
{
- Dl_info info;
- char *home;
+ char home[CFFI_INIT_HOME_PATH_MAX + 1];
rpython_startup_code();
RPyGilAllocate();
- if (dladdr(&_cffi_init, &info) == 0) {
- _cffi_init_error("dladdr() failed: ", dlerror());
+ if (_cffi_init_home(home) != 0)
return;
- }
- home = realpath(info.dli_fname, NULL);
if (pypy_setup_home(home, 1) != 0) {
_cffi_init_error("pypy_setup_home() failed", "");
return;
@@ -134,13 +223,12 @@
It assumes that we don't hold the GIL before (if it exists), and we
don't hold it afterwards.
*/
- static pthread_once_t once_control = PTHREAD_ONCE_INIT;
-
_cffi_module_name = name; /* not really thread-safe, but better than
nothing */
- pthread_once(&once_control, _cffi_init);
+ _cffi_init_once();
return (int)_cffi_ready - 1;
}
-"""])
+"""
+eci = ExternalCompilationInfo(separate_module_sources=[do_startup])
declare_c_function = rffi.llexternal_use_eci(eci)
diff --git a/pypy/module/_cffi_backend/test/_backend_test_c.py
b/pypy/module/_cffi_backend/test/_backend_test_c.py
--- a/pypy/module/_cffi_backend/test/_backend_test_c.py
+++ b/pypy/module/_cffi_backend/test/_backend_test_c.py
@@ -1,7 +1,7 @@
# ____________________________________________________________
import sys
-assert __version__ == "1.5.0", ("This test_c.py file is for testing a version"
+assert __version__ == "1.5.1", ("This test_c.py file is for testing a version"
" of cffi that differs from the one that we"
" get from 'import _cffi_backend'")
if sys.version_info < (3,):
diff --git a/pypy/module/_cffi_backend/test/test_ztranslation.py
b/pypy/module/_cffi_backend/test/test_ztranslation.py
--- a/pypy/module/_cffi_backend/test/test_ztranslation.py
+++ b/pypy/module/_cffi_backend/test/test_ztranslation.py
@@ -4,15 +4,18 @@
# side-effect: FORMAT_LONGDOUBLE must be built before test_checkmodule()
from pypy.module._cffi_backend import misc
-from pypy.module._cffi_backend import cffi1_module
+from pypy.module._cffi_backend import embedding
def test_checkmodule():
# prepare_file_argument() is not working without translating the _file
# module too
def dummy_prepare_file_argument(space, fileobj):
- # call load_cffi1_module() too, from a random place like here
- cffi1_module.load_cffi1_module(space, "foo", "foo", 42)
+ # call pypy_init_embedded_cffi_module() from a random place like here
+ # --- this calls load_cffi1_module(), too
+ embedding.pypy_init_embedded_cffi_module(
+ rffi.cast(rffi.INT, embedding.EMBED_VERSION_MIN),
+ 42)
return lltype.nullptr(rffi.CCHARP.TO)
old = ctypeptr.prepare_file_argument
try:
diff --git a/pypy/module/_socket/test/test_sock_app.py
b/pypy/module/_socket/test/test_sock_app.py
--- a/pypy/module/_socket/test/test_sock_app.py
+++ b/pypy/module/_socket/test/test_sock_app.py
@@ -102,7 +102,7 @@
fd = space.appexec([w_socket, space.wrap(orig_fd.fileno()),
space.wrap(socket.AF_INET), space.wrap(socket.SOCK_STREAM),
space.wrap(0)],
- """(_socket, fd, family, type, proto):
+ """(_socket, fd, family, type, proto):
return _socket.fromfd(fd, family, type, proto)""")
assert space.unwrap(space.call_method(fd, 'fileno'))
@@ -326,7 +326,7 @@
def test_ntoa_exception(self):
import _socket
- raises(_socket.error, _socket.inet_ntoa, "ab")
+ raises(_socket.error, _socket.inet_ntoa, b"ab")
def test_aton_exceptions(self):
import _socket
@@ -418,7 +418,7 @@
# it if there is no connection.
try:
s.connect(("www.python.org", 80))
- except _socket.gaierror, ex:
+ except _socket.gaierror as ex:
skip("GAIError - probably no connection: %s" % str(ex.args))
name = s.getpeername() # Will raise socket.error if not connected
assert name[1] == 80
@@ -465,7 +465,7 @@
sizes = {socket.htonl: 32, socket.ntohl: 32,
socket.htons: 16, socket.ntohs: 16}
for func, size in sizes.items():
- mask = (1L<<size) - 1
+ mask = (1 << size) - 1
for i in (0, 1, 0xffff, ~0xffff, 2, 0x01234567, 0x76543210):
assert i & mask == func(func(i&mask)) & mask
@@ -493,7 +493,7 @@
socket.htons: 16, socket.ntohs: 16}
for func, size in sizes.items():
try:
- func(1L << size)
+ func(1 << size)
except OverflowError:
pass
else:
@@ -574,7 +574,7 @@
# connection.
try:
s.connect(("www.python.org", 80))
- except _socket.gaierror, ex:
+ except _socket.gaierror as ex:
skip("GAIError - probably no connection: %s" % str(ex.args))
exc = raises(TypeError, s.send, None)
assert str(exc.value) == "must be string or buffer, not None"
@@ -608,12 +608,12 @@
s, addr = serversock.accept()
assert not addr
- s.send('X')
+ s.send(b'X')
data = clientsock.recv(100)
- assert data == 'X'
- clientsock.send('Y')
+ assert data == b'X'
+ clientsock.send(b'Y')
data = s.recv(100)
- assert data == 'Y'
+ assert data == b'Y'
clientsock.close()
s.close()
@@ -640,12 +640,12 @@
def test_connect_to_kernel_netlink_routing_socket(self):
import _socket, os
s = _socket.socket(_socket.AF_NETLINK, _socket.SOCK_DGRAM,
_socket.NETLINK_ROUTE)
- assert s.getsockname() == (0L, 0L)
+ assert s.getsockname() == (0, 0)
s.bind((0, 0))
a, b = s.getsockname()
assert a == os.getpid()
assert b == 0
-
+
class AppTestPacket:
def setup_class(cls):
@@ -711,20 +711,20 @@
t, addr = self.serv.accept()
cli.settimeout(1.0)
# test recv() timeout
- t.send('*')
+ t.send(b'*')
buf = cli.recv(100)
- assert buf == '*'
+ assert buf == b'*'
raises(timeout, cli.recv, 100)
# test that send() works
- count = cli.send('!')
+ count = cli.send(b'!')
assert count == 1
buf = t.recv(1)
- assert buf == '!'
+ assert buf == b'!'
# test that sendall() works
- count = cli.sendall('?')
+ count = cli.sendall(b'?')
assert count is None
buf = t.recv(1)
- assert buf == '?'
+ assert buf == b'?'
# speed up filling the buffers
t.setsockopt(SOL_SOCKET, SO_RCVBUF, 4096)
cli.setsockopt(SOL_SOCKET, SO_SNDBUF, 4096)
@@ -732,14 +732,14 @@
count = 0
try:
while 1:
- count += cli.send('foobar' * 70)
+ count += cli.send(b'foobar' * 70)
except timeout:
pass
t.recv(count)
# test sendall() timeout
try:
while 1:
- cli.sendall('foobar' * 70)
+ cli.sendall(b'foobar' * 70)
except timeout:
pass
# done
@@ -749,13 +749,13 @@
def test_recv_into(self):
import socket
import array
- MSG = 'dupa was here\n'
+ MSG = b'dupa was here\n'
cli = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
cli.connect(self.serv.getsockname())
conn, addr = self.serv.accept()
buf = buffer(MSG)
conn.send(buf)
- buf = array.array('c', ' ' * 1024)
+ buf = array.array('b', b' ' * 1024)
nbytes = cli.recv_into(buf)
assert nbytes == len(MSG)
msg = buf.tostring()[:len(MSG)]
@@ -771,13 +771,13 @@
def test_recvfrom_into(self):
import socket
import array
- MSG = 'dupa was here\n'
+ MSG = b'dupa was here\n'
cli = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
cli.connect(self.serv.getsockname())
conn, addr = self.serv.accept()
buf = buffer(MSG)
conn.send(buf)
- buf = array.array('c', ' ' * 1024)
+ buf = array.array('b', b' ' * 1024)
nbytes, addr = cli.recvfrom_into(buf)
assert nbytes == len(MSG)
msg = buf.tostring()[:len(MSG)]
diff --git a/pypy/module/_vmprof/__init__.py b/pypy/module/_vmprof/__init__.py
--- a/pypy/module/_vmprof/__init__.py
+++ b/pypy/module/_vmprof/__init__.py
@@ -11,6 +11,7 @@
interpleveldefs = {
'enable': 'interp_vmprof.enable',
'disable': 'interp_vmprof.disable',
+ 'write_all_code_objects': 'interp_vmprof.write_all_code_objects',
'VMProfError': 'space.fromcache(interp_vmprof.Cache).w_VMProfError',
}
diff --git a/pypy/module/_vmprof/interp_vmprof.py
b/pypy/module/_vmprof/interp_vmprof.py
--- a/pypy/module/_vmprof/interp_vmprof.py
+++ b/pypy/module/_vmprof/interp_vmprof.py
@@ -59,11 +59,21 @@
'interval' is a float representing the sampling interval, in seconds.
_______________________________________________
pypy-commit mailing list
pypy-commit@python.org
https://mail.python.org/mailman/listinfo/pypy-commit
