static sre_int_t
sre_regex_compiler_add_char_class(sre_pool_t *pool, sre_instruction_t *pc,
sre_regex_range_t *range)
{
sre_char *p;
sre_uint_t i, n;
sre_regex_range_t *r;
n = 0;
for (r = range; r; r = r->next) {
n++;
}
p = sre_pnalloc(pool,
sizeof(sre_vm_ranges_t) + n * sizeof(sre_vm_range_t));
if (p == NULL) {
return SRE_ERROR;
}
pc->v.ranges = (sre_vm_ranges_t *) p;
p += sizeof(sre_vm_ranges_t);
pc->v.ranges->head = (sre_vm_range_t *) p;
pc->v.ranges->count = n;
for (i = 0, r = range; r; i++, r = r->next) {
pc->v.ranges->head[i].from = r->from;
pc->v.ranges->head[i].to = r->to;
}
return SRE_OK;
}
sre_vm_thompson_thread_list_t *
sre_vm_thompson_create_thread_list(sre_pool_t *pool, sre_uint_t size)
{
sre_vm_thompson_thread_list_t *l;
l = sre_pnalloc(pool, sizeof(sre_vm_thompson_thread_list_t)
+ (size - 1) * sizeof(sre_vm_thompson_thread_t));
if (l == NULL) {
return NULL;
}
l->count = 0;
return l;
}
static sre_vm_thompson_thread_list_t *
sre_vm_thompson_thread_list_create(sre_pool_t *pool, int size)
{
u_char *p;
sre_vm_thompson_thread_list_t *l;
p = sre_pnalloc(pool, sizeof(sre_vm_thompson_thread_list_t)
+ size * sizeof(sre_vm_thompson_thread_t));
if (p == NULL) {
return NULL;
}
l = (sre_vm_thompson_thread_list_t *) p;
p += sizeof(sre_vm_thompson_thread_list_t);
l->threads = (sre_vm_thompson_thread_t *) p;
l->count = 0;
return l;
}
SRE_NOAPI sre_capture_t *
sre_capture_create(sre_pool_t *pool, size_t ovecsize, unsigned clear,
sre_capture_t **freecap)
{
sre_char *p;
sre_capture_t *cap;
if (*freecap) {
dd("reusing cap %p", *freecap);
cap = *freecap;
*freecap = cap->next;
cap->next = NULL;
cap->ref = 1;
} else {
p = sre_pnalloc(pool, sizeof(sre_capture_t) + ovecsize);
if (p == NULL) {
return NULL;
}
cap = (sre_capture_t *) p;
cap->ovecsize = ovecsize;
cap->ref = 1;
cap->next = NULL;
cap->regex_id = 0;
p += sizeof(sre_capture_t);
cap->vector = (sre_int_t *) p;
}
if (clear) {
(void) memset(cap->vector, -1, ovecsize);
}
return cap;
}
sre_program_t *
sre_regex_compile(sre_pool_t *pool, sre_regex_t *re)
{
sre_uint_t i, n, multi_ncaps_size;
sre_char *p;
sre_program_t *prog;
sre_instruction_t *pc;
n = sre_program_len(re);
multi_ncaps_size = (re->nregexes - 1) * sizeof(sre_uint_t);
p = sre_pnalloc(pool,
sizeof(sre_program_t) + multi_ncaps_size
+ n * sizeof(sre_instruction_t));
if (p == NULL) {
return NULL;
}
prog = (sre_program_t *) p;
prog->nregexes = re->nregexes;
memcpy(prog->multi_ncaps, re->data.multi_ncaps,
re->nregexes * sizeof(sre_uint_t));
prog->start = (sre_instruction_t *) (p + sizeof(sre_program_t)
+ multi_ncaps_size);
sre_memzero(prog->start, n * sizeof(sre_instruction_t));
pc = sre_regex_emit_bytecode(pool, prog->start, re);
if (pc == NULL) {
return NULL;
}
if (pc - prog->start != n) {
dd("buffer error: %d != %d", (int) (pc - prog->start), (int) n);
return NULL;
}
prog->len = pc - prog->start;
prog->tag = 0;
prog->lookahead_asserts = 0;
prog->dup_threads = 0;
prog->uniq_threads = 0;
prog->nullable = 0;
prog->leading_bytes = NULL;
prog->leading_byte = -1;
prog->ovecsize = 0;
for (i = 0; i < prog->nregexes; i++) {
prog->ovecsize += prog->multi_ncaps[i] + 1;
}
prog->ovecsize *= 2 * sizeof(sre_uint_t);
if (sre_program_get_leading_bytes(pool, prog, &prog->leading_bytes)
== SRE_ERROR)
{
return NULL;
}
if (prog->leading_bytes && prog->leading_bytes->next == NULL) {
pc = prog->leading_bytes->data;
if (pc->opcode == SRE_OPCODE_CHAR) {
prog->leading_byte = pc->v.ch;
}
}
dd("nullable: %u", prog->nullable);
#if (DDEBUG)
{
sre_chain_t *cl;
for (cl = prog->leading_bytes; cl; cl = cl->next) {
pc = cl->data;
fprintf(stderr, "[");
sre_dump_instruction(stderr, pc, prog->start);
fprintf(stderr, "]");
}
if (prog->leading_bytes) {
fprintf(stderr, "\n");
}
}
#endif
return prog;
}
