PostgreSQL Source Code: src/backend/regex/regexport.c Source File (original) (raw)

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

28

30

31

32

33

34

35int

37{

39

40 assert(regex != NULL && regex->re_magic == REMAGIC);

41 cnfa = &((struct guts *) regex->re_guts)->search;

42

44}

45

46

47

48

49int

51{

53

54 assert(regex != NULL && regex->re_magic == REMAGIC);

55 cnfa = &((struct guts *) regex->re_guts)->search;

56

58}

59

60

61

62

63int

65{

67

68 assert(regex != NULL && regex->re_magic == REMAGIC);

69 cnfa = &((struct guts *) regex->re_guts)->search;

70

72}

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92static void

94 int *arcs_count,

96{

97 struct carc *ca;

98

99

100

101

102

103

105

107 {

109 {

110

111 int ndx = (*arcs_count)++;

112

113 if (ndx < arcs_len)

114 {

115 arcs[ndx].co = ca->co;

116 arcs[ndx].to = ca->to;

117 }

118 }

119 else

120 {

121

122

124

126 }

127 }

128}

129

130

131

132

133int

135{

137 int arcs_count;

138

139 assert(regex != NULL && regex->re_magic == REMAGIC);

140 cnfa = &((struct guts *) regex->re_guts)->search;

141

143 return 0;

144 arcs_count = 0;

146 return arcs_count;

147}

148

149

150

151

152

153

154void

157{

159 int arcs_count;

160

161 assert(regex != NULL && regex->re_magic == REMAGIC);

162 cnfa = &((struct guts *) regex->re_guts)->search;

163

164 if (st < 0 || st >= cnfa->nstates || arcs_len <= 0)

165 return;

166 arcs_count = 0;

168}

169

170

171

172

173int

175{

177

178 assert(regex != NULL && regex->re_magic == REMAGIC);

179 cm = &((struct guts *) regex->re_guts)->cmap;

180

181 return cm->max + 1;

182}

183

184

185

186

187

188

189

190int

192{

194

195 assert(regex != NULL && regex->re_magic == REMAGIC);

196 cnfa = &((struct guts *) regex->re_guts)->search;

197

199 return true;

200 else

201 return false;

202}

203

204

205

206

207int

209{

211

212 assert(regex != NULL && regex->re_magic == REMAGIC);

213 cnfa = &((struct guts *) regex->re_guts)->search;

214

216 return true;

217 else

218 return false;

219}

220

221

222

223

224

225

226

227

228

229int

231{

233

234 assert(regex != NULL && regex->re_magic == REMAGIC);

235 cm = &((struct guts *) regex->re_guts)->cmap;

236

237 if (co <= 0 || co > cm->max)

238 return -1;

239 if (cm->cd[co].flags & PSEUDO)

240 return -1;

241

242

243

244

245

246

247

248

250 return -1;

251

252

254}

255

256

257

258

259

260

261

262

263

264

265void

268{

271

272 assert(regex != NULL && regex->re_magic == REMAGIC);

273 cm = &((struct guts *) regex->re_guts)->cmap;

274

275 if (co <= 0 || co > cm->max || chars_len <= 0)

276 return;

278 return;

279

280

281

282

283

285 {

287 {

289 if (--chars_len == 0)

290 break;

291 }

292 }

293}

Assert(PointerIsAligned(start, uint64))

int pg_reg_getnumoutarcs(const regex_t *regex, int st)

int pg_reg_getnumcolors(const regex_t *regex)

int pg_reg_getnumstates(const regex_t *regex)

int pg_reg_getfinalstate(const regex_t *regex)

int pg_reg_getinitialstate(const regex_t *regex)

void pg_reg_getoutarcs(const regex_t *regex, int st, regex_arc_t *arcs, int arcs_len)

int pg_reg_colorisend(const regex_t *regex, int co)

static void traverse_lacons(struct cnfa *cnfa, int st, int *arcs_count, regex_arc_t *arcs, int arcs_len)

void pg_reg_getcharacters(const regex_t *regex, int co, pg_wchar *chars, int chars_len)

int pg_reg_getnumcharacters(const regex_t *regex, int co)

int pg_reg_colorisbegin(const regex_t *regex, int co)

void check_stack_depth(void)

static char chars[TZ_MAX_CHARS]