#ifndef re2c_re_h
#define re2c_re_h

#include <stdio.h>
#include "tools/re2c/token.h"
#include "tools/re2c/ins.h"

typedef struct extop {
    char    op;
    int	    minsize;
    int	    maxsize;
} ExtOp;

typedef struct CharPtn {
    unsigned int	card;
    struct CharPtn	*fix;
    struct CharPtn	*nxt;
} CharPtn;

typedef struct CharSet {
    CharPtn	*fix;
    CharPtn	*freeHead, **freeTail;
    CharPtn	*rep[nChars];
    CharPtn	ptn[nChars];
} CharSet;

typedef struct Range {
    struct Range	*next;
    unsigned int	lb, ub;		/* [lb,ub) */
} Range;

static void
Range_init(Range *r, unsigned int l, unsigned int u)
{
    r->next = NULL;
    r->lb = l;
    r->ub = u;
}

static Range *
Range_new(unsigned int l, unsigned int u)
{
    Range *r = malloc(sizeof(Range));
    r->next = NULL;
    r->lb = l;
    r->ub = u;
    return r;
}

static void
Range_copy(Range *ro, const Range *r)
{
    ro->next = NULL;
    ro->lb = r->lb;
    ro->ub = r->ub;
}

static Range *
Range_new_copy(Range *r)
{
    Range *ro = malloc(sizeof(Range));
    ro->next = NULL;
    ro->lb = r->lb;
    ro->ub = r->ub;
    return ro;
}

void Range_out(FILE *, const Range *);

typedef enum {
	NULLOP = 1,
	MATCHOP,
	RULEOP,
	ALTOP,
	CATOP,
	CLOSEOP,
	CLOSEVOP
} RegExpType;

typedef struct RegExp {
    RegExpType	type;
    unsigned int	size;
    union {
	/* for MatchOp */
	Range	*match;
	/* for RuleOp */
	struct {
	    struct RegExp	*exp;
	    struct RegExp	*ctx;
	    Ins		*ins;
	    unsigned int	accept;
	    Token	*code;
	    unsigned int	line;
	} RuleOp;
	/* for AltOp and CatOp*/
	struct {
	    struct RegExp	*exp1, *exp2;
	} AltCatOp;
	/* for CloseOp */
	struct RegExp	*exp;
	/* for CloseVOp*/
	struct {
	    struct RegExp	*exp;
	    int		min;
	    int		max;
	} CloseVOp;
    } d;
} RegExp;

static RegExp *
RegExp_isA(RegExp *r, RegExpType t)
{
    return r->type == t ? r : NULL;
}

void RegExp_split(RegExp*, CharSet*);
void RegExp_calcSize(RegExp*, Char*);
unsigned int RegExp_fixedLength(RegExp*);
void RegExp_compile(RegExp*, Char*, Ins*);
void RegExp_display(RegExp*, FILE *);

static RegExp *
RegExp_new_NullOp(void)
{
    RegExp *r = malloc(sizeof(RegExp));
    r->type = NULLOP;
    return r;
}

static RegExp *
RegExp_new_MatchOp(Range *m)
{
    RegExp *r = malloc(sizeof(RegExp));
    r->type = MATCHOP;
    r->d.match = m;
    return r;
}

RegExp *RegExp_new_RuleOp(RegExp*, RegExp*, Token*, unsigned int);

static RegExp *
RegExp_new_AltOp(RegExp *e1, RegExp *e2)
{
    RegExp *r = malloc(sizeof(RegExp));
    r->type = ALTOP;
    r->d.AltCatOp.exp1 = e1;
    r->d.AltCatOp.exp2 = e2;
    return r;
}

static RegExp *
RegExp_new_CatOp(RegExp *e1, RegExp *e2)
{
    RegExp *r = malloc(sizeof(RegExp));
    r->type = CATOP;
    r->d.AltCatOp.exp1 = e1;
    r->d.AltCatOp.exp2 = e2;
    return r;
}

static RegExp *
RegExp_new_CloseOp(RegExp *e)
{
    RegExp *r = malloc(sizeof(RegExp));
    r->type = CLOSEOP;
    r->d.exp = e;
    return r;
}

static RegExp *
RegExp_new_CloseVOp(RegExp *e, int lb, int ub)
{
    RegExp *r = malloc(sizeof(RegExp));
    r->type = CLOSEVOP;
    r->d.CloseVOp.exp = e;
    r->d.CloseVOp.min = lb;
    r->d.CloseVOp.max = ub;
    return r;
}

extern void genCode(FILE *, RegExp*);
extern RegExp *mkDiff(RegExp*, RegExp*);
extern RegExp *mkDot(void);
extern RegExp *strToRE(SubStr);
extern RegExp *strToCaseInsensitiveRE(SubStr);
extern RegExp *ranToRE(SubStr);
extern RegExp *invToRE(SubStr);

extern RegExp *mkAlt(RegExp*, RegExp*);

#endif