FilesExpand file tree

 master

/

python.c

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

116 lines (99 loc) · 3.11 KB

 master

/

python.c

Copy path

Top

File metadata and controls

• Code
• Blame

116 lines (99 loc) · 3.11 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

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

/* Minimal main program -- everything is loaded from the library */

#include "Python.h"

#include "internal/pystate.h"

#include <locale.h>

#ifdef __FreeBSD__

#include <fenv.h>

#endif

#ifdef MS_WINDOWS

int

wmain(int argc, wchar_t **argv)

{

return Py_Main(argc, argv);

}

#else

int

main(int argc, char **argv)

{

wchar_t **argv_copy;

/* We need a second copy, as Python might modify the first one. */

wchar_t **argv_copy2;

int i, status;

char *oldloc;

_PyInitError err = _PyRuntime_Initialize();

if (_Py_INIT_FAILED(err)) {

fprintf(stderr, "Fatal Python error: %s\n", err.msg);

fflush(stderr);

exit(1);

}

/* Force malloc() allocator to bootstrap Python */

#ifdef Py_DEBUG

(void)_PyMem_SetupAllocators("malloc_debug");

# else

(void)_PyMem_SetupAllocators("malloc");

# endif

argv_copy = (wchar_t **)PyMem_RawMalloc(sizeof(wchar_t*) * (argc+1));

argv_copy2 = (wchar_t **)PyMem_RawMalloc(sizeof(wchar_t*) * (argc+1));

if (!argv_copy || !argv_copy2) {

fprintf(stderr, "out of memory\n");

return 1;

}

/* 754 requires that FP exceptions run in "no stop" mode by default,

* and until C vendors implement C99's ways to control FP exceptions,

* Python requires non-stop mode. Alas, some platforms enable FP

* exceptions by default. Here we disable them.

*/

#ifdef __FreeBSD__

fedisableexcept(FE_OVERFLOW);

#endif

oldloc = _PyMem_RawStrdup(setlocale(LC_ALL, NULL));

if (!oldloc) {

fprintf(stderr, "out of memory\n");

return 1;

}

/* Reconfigure the locale to the default for this process */

_Py_SetLocaleFromEnv(LC_ALL);

/* The legacy C locale assumes ASCII as the default text encoding, which

* causes problems not only for the CPython runtime, but also other

* components like GNU readline.

*

* Accordingly, when the CLI detects it, it attempts to coerce it to a

* more capable UTF-8 based alternative.

*

* See the documentation of the PYTHONCOERCECLOCALE setting for more

* details.

*/

if (_Py_LegacyLocaleDetected()) {

_Py_CoerceLegacyLocale();

}

/* Convert from char to wchar_t based on the locale settings */

for (i = 0; i < argc; i++) {

argv_copy[i] = Py_DecodeLocale(argv[i], NULL);

if (!argv_copy[i]) {

PyMem_RawFree(oldloc);

fprintf(stderr, "Fatal Python error: "

"unable to decode the command line argument #%i\n",

i + 1);

return 1;

}

argv_copy2[i] = argv_copy[i];

}

argv_copy2[argc] = argv_copy[argc] = NULL;

setlocale(LC_ALL, oldloc);

PyMem_RawFree(oldloc);

status = Py_Main(argc, argv_copy);

/* Force again malloc() allocator to release memory blocks allocated

before Py_Main() */

#ifdef Py_DEBUG

(void)_PyMem_SetupAllocators("malloc_debug");

# else

(void)_PyMem_SetupAllocators("malloc");

# endif

for (i = 0; i < argc; i++) {

PyMem_RawFree(argv_copy2[i]);

}

PyMem_RawFree(argv_copy);

PyMem_RawFree(argv_copy2);

return status;

}

#endif