1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

use {int_t};
use locale::{locale_t};

pub fn isalnum(arg1: int_t) -> int_t {
    extern { fn isalnum(arg1: int_t) -> int_t; }
    unsafe { isalnum(arg1) }
}

pub fn isalnum_l(arg1: int_t, arg2: locale_t) -> int_t {
    extern { fn isalnum_l(arg1: int_t, arg2: locale_t) -> int_t; }
    unsafe { isalnum_l(arg1, arg2) }
}

pub fn isalpha(arg1: int_t) -> int_t {
    extern { fn isalpha(arg1: int_t) -> int_t; }
    unsafe { isalpha(arg1) }
}

pub fn isalpha_l(arg1: int_t, arg2: locale_t) -> int_t {
    extern { fn isalpha_l(arg1: int_t, arg2: locale_t) -> int_t; }
    unsafe { isalpha_l(arg1, arg2) }
}

pub fn isascii(c: int_t) -> int_t {
    extern { fn isascii(c: int_t) -> int_t; }
    unsafe { isascii(c) }
}

pub fn isblank(c: int_t) -> int_t {
    extern { fn isblank(c: int_t) -> int_t; }
    unsafe { isblank(c) }
}

pub fn isblank_l(arg1: int_t, arg2: locale_t) -> int_t {
    extern { fn isblank_l(arg1: int_t, arg2: locale_t) -> int_t; }
    unsafe { isblank_l(arg1, arg2) }
}

pub fn iscntrl(c: int_t) -> int_t {
    extern { fn iscntrl(c: int_t) -> int_t; }
    unsafe { iscntrl(c) }
}

pub fn iscntrl_l(arg1: int_t, arg2: locale_t) -> int_t {
    extern { fn iscntrl_l(arg1: int_t, arg2: locale_t) -> int_t; }
    unsafe { iscntrl_l(arg1, arg2) }
}

pub fn isdigit(c: int_t) -> int_t {
    extern { fn isdigit(c: int_t) -> int_t; }
    unsafe { isdigit(c) }
}

pub fn isdigit_l(arg1: int_t, arg2: locale_t) -> int_t {
    extern { fn isdigit_l(arg1: int_t, arg2: locale_t) -> int_t; }
    unsafe { isdigit_l(arg1, arg2) }
}

pub fn isgraph(c: int_t) -> int_t {
    extern { fn isgraph(c: int_t) -> int_t; }
    unsafe { isgraph(c) }
}

pub fn isgraph_l(arg1: int_t, arg2: locale_t) -> int_t {
    extern { fn isgraph_l(arg1: int_t, arg2: locale_t) -> int_t; }
    unsafe { isgraph_l(arg1, arg2) }
}

pub fn islower(c: int_t) -> int_t {
    extern { fn islower(c: int_t) -> int_t; }
    unsafe { islower(c) }
}

pub fn islower_l(arg1: int_t, arg2: locale_t) -> int_t {
    extern { fn islower_l(arg1: int_t, arg2: locale_t) -> int_t; }
    unsafe { islower_l(arg1, arg2) }
}

pub fn isprint(c: int_t) -> int_t {
    extern { fn isprint(c: int_t) -> int_t; }
    unsafe { isprint(c) }
}

pub fn isprint_l(arg1: int_t, arg2: locale_t) -> int_t {
    extern { fn isprint_l(arg1: int_t, arg2: locale_t) -> int_t; }
    unsafe { isprint_l(arg1, arg2) }
}

pub fn ispunct(c: int_t) -> int_t {
    extern { fn ispunct(c: int_t) -> int_t; }
    unsafe { ispunct(c) }
}

pub fn ispunct_l(arg1: int_t, arg2: locale_t) -> int_t {
    extern { fn ispunct_l(arg1: int_t, arg2: locale_t) -> int_t; }
    unsafe { ispunct_l(arg1, arg2) }
}

pub fn isspace(c: int_t) -> int_t {
    extern { fn isspace(c: int_t) -> int_t; }
    unsafe { isspace(c) }
}

pub fn isspace_l(arg1: int_t, arg2: locale_t) -> int_t {
    extern { fn isspace_l(arg1: int_t, arg2: locale_t) -> int_t; }
    unsafe { isspace_l(arg1, arg2) }
}

pub fn isupper(c: int_t) -> int_t {
    extern { fn isupper(c: int_t) -> int_t; }
    unsafe { isupper(c) }
}

pub fn isupper_l(arg1: int_t, arg2: locale_t) -> int_t {
    extern { fn isupper_l(arg1: int_t, arg2: locale_t) -> int_t; }
    unsafe { isupper_l(arg1, arg2) }
}

pub fn isxdigit(c: int_t) -> int_t {
    extern { fn isxdigit(c: int_t) -> int_t; }
    unsafe { isxdigit(c) }
}

pub fn isxdigit_l(arg1: int_t, arg2: locale_t) -> int_t {
    extern { fn isxdigit_l(arg1: int_t, arg2: locale_t) -> int_t; }
    unsafe { isxdigit_l(arg1, arg2) }
}

pub fn toascii(c: int_t) -> int_t {
    extern { fn toascii(c: int_t) -> int_t; }
    unsafe { toascii(c) }
}

pub fn tolower(c: int_t) -> int_t {
    extern { fn tolower(c: int_t) -> int_t; }
    unsafe { tolower(c) }
}

pub fn tolower_l(arg1: int_t, arg2: locale_t) -> int_t {
    extern { fn tolower_l(arg1: int_t, arg2: locale_t) -> int_t; }
    unsafe { tolower_l(arg1, arg2) }
}

pub fn toupper(c: int_t) -> int_t {
    extern { fn toupper(c: int_t) -> int_t; }
    unsafe { toupper(c) }
}

pub fn toupper_l(arg1: int_t, arg2: locale_t) -> int_t {
    extern { fn toupper_l(arg1: int_t, arg2: locale_t) -> int_t; }
    unsafe { toupper_l(arg1, arg2) }
}