FILTER* interpolateFilter(FILTER* filter1,FILTER* filter2, float ratio, interpolation_t* inter)
{
if(!filter1 && !filter2)
return 0;
int filter_type;
if (!filter1)
filter_type = filter2->type;
else
if (!filter2)
filter_type = filter1->type;
else
if(filter2->type != filter1->type)
syntaxerror("can't interpolate between %s and %s filters yet", filtername[filter1->type], filtername[filter2->type]);
else
filter_type = filter1->type;
switch (filter_type)
{
case FILTERTYPE_BLUR:
return interpolateBlur(filter1, filter2, ratio, inter);
case FILTERTYPE_BEVEL:
return interpolateBevel(filter1, filter2, ratio, inter);
case FILTERTYPE_DROPSHADOW:
return interpolateDropshadow(filter1, filter2, ratio, inter);
case FILTERTYPE_GRADIENTGLOW:
return interpolateGradientGlow(filter1, filter2, ratio, inter);
default:
syntaxerror("Filtertype %s not supported yet.\n", filtername[filter1->type]);
}
return 0;
}
void initialize_file(char*filename)
{
if(state) {
syntaxerror("invalid call to initialize_file during parsing of another file");
}
new_state();
state->package = internal_filename_package = strdup(filename);
global->token2info = dict_lookup(global->file2token2info,
current_filename // use long version
);
if(!global->token2info) {
global->token2info = dict_new2(&ptr_type);
dict_put(global->file2token2info, current_filename, global->token2info);
}
if(as3_pass==1) {
state->method = rfx_calloc(sizeof(methodstate_t));
dict_put(global->token2info, (void*)(ptroff_t)as3_tokencount, state->method);
state->method->late_binding = 1; // init scripts use getglobalscope, so we need a getlocal0/pushscope
state->method->allvars = dict_new();
} else {
state->method = dict_lookup(global->token2info, (void*)(ptroff_t)as3_tokencount);
state->method->variable_count = 0;
if(!state->method)
syntaxerror("internal error: skewed tokencount");
function_initvars(state->method, 0, 0, 0, 1);
global->init = 0;
}
}
struct instruction *parse_instruction(void)
{
struct expr *expr;
struct instruction *res;
switch (lookahead[0]->type)
{
case WHILE: return parse_while();
case DO: return parse_do();
case IDENTIFIER: case LPAREN:
expr = parse_expression();
switch(lookahead[0]->type)
{
case ASSIGN: return parse_assignment_instr(expr);
case EOL:
if (expr->exprtype != funcalltype)
{
if (expr->exprtype == binopexprtype
&& expr->val.binopexpr.op == EQ)
{
error(expr->pos, "unexpected =, did you mean <- ?");
exit(1);
}
else
syntaxerror("expected instruction, not expression");
}
eat(EOL);
res = funcallinstr(expr->val.funcall.fun_ident,
expr->val.funcall.args, expr->pos);
free(expr);
return res;
default:
next();
syntaxerror("unexpected %s", tok->val);
return parse_instruction();
}
case RETURN:
eat(RETURN);
if (lookahead[0]->type == EOL)
{
eat(EOL);
return return_stmt(NULL);
}
else
{
expr = parse_expression(); eat(EOL);
return return_stmt(expr);
}
case FOR: return parse_for();
case IF: return parse_if();
case SWITCH: return parse_switch();
case ENDOFFILE: return NULL;
default:
next();
syntaxerror("expected instruction, not %s", tok->val);
return parse_instruction();
}
}
struct expr *infix(struct expr *left, char *expect)
{
exprlist_t args;
int toktype = tok->type;
char *ident;
switch (toktype)
{
case PLUS: case MINUS: case STAR: case SLASH: case OR: case XOR:
case LT: case LE: case GT: case GE: case NEQ: case EQ: case AND:
return binopexpr(left, toktype, expression(lbp(toktype)));
case LPAREN:
if (left->exprtype != identtype)
syntaxerror("calling non-callable expression");
args = empty_exprlist();
if (lookahead[0]->type != COMMA && lookahead[0]->type != RPAREN)
list_push_back(args, expression(0));
while (lookahead[0]->type == COMMA)
{
eat(COMMA);
list_push_back(args, expression(0));
}
eat(RPAREN);
ident = strdup(left->val.ident);
left->type = NULL; // To prevent segfaults when freeing the expr
free_expression(left);
return funcallexpr(ident, args);
case LSQBRACKET:
args = empty_exprlist();
list_push_back(args, expression(0));
while (lookahead[0]->type == COMMA)
{
eat(COMMA);
list_push_back(args, expression(0));
}
eat(RSQBRACKET);
return arrayexpr(left, args);
case DOT:
eat(IDENTIFIER);
char *ident = strdup(tok->val);
return record_access(left, ident);
case DEREF:
return make_deref(left);
default:
syntaxerror("expected %s, not %s", expect, tok->val);
next();
switch (tok->type)
{
case ENDOFFILE: return expr_from_val(0);
default: return infix(left, "expression");
}
}
}
FILTER* copyFilter(FILTER* original)
{
if (!original)
return original;
FILTER* copy = swf_NewFilter(original->type);
switch (original->type)
{
case FILTERTYPE_BLUR:
memcpy(copy, original, sizeof(FILTER_BLUR));
break;
case FILTERTYPE_GRADIENTGLOW:
{
memcpy(copy, original, sizeof(FILTER_GRADIENTGLOW));
FILTER_GRADIENTGLOW* ggcopy = (FILTER_GRADIENTGLOW*)copy;
ggcopy->gradient = (GRADIENT*)malloc(sizeof(GRADIENT));
ggcopy->gradient->ratios = (U8*)malloc(16 * sizeof(U8));
ggcopy->gradient->rgba = (RGBA*)malloc(16 * sizeof(RGBA));
copyGradient(ggcopy->gradient, ((FILTER_GRADIENTGLOW*)original)->gradient);
}
break;
case FILTERTYPE_DROPSHADOW:
memcpy(copy, original, sizeof(FILTER_DROPSHADOW));
break;
case FILTERTYPE_BEVEL:
memcpy(copy, original, sizeof(FILTER_BEVEL));
break;
default: syntaxerror("Internal error: unsupported filterype, cannot copy");
}
return copy;
}
void SyntaxAnalyzer::endcheck(std::set<symboltype> &followers)
{
if (followers.find(symbol) == followers.end()) {
syntaxerror(othersy);
skipto(followers);
}
}
variable_t* find_variable_safe(state_t*s, char*name)
{
variable_t* v = find_variable(s, name);
if(!v)
syntaxerror("undefined variable: %s", name);
return v;
}
struct expr *prefix(char *expect)
{
struct expr *res = NULL;
int toktype = tok->type;
switch (toktype)
{
case IDENTIFIER:
return identexpr(strdup(tok->val));
case LPAREN:
res = expression(0);
eat(RPAREN);
return res;
case PLUS: case MINUS: case NOT:
return unopexpr(toktype, expression(lbp(toktype) - 1));
case REAL:
return expr_from_val(realval(atof(tok->val)));
case INT:
return expr_from_val(intval(atoi(tok->val)));
case CHAR:
return expr_from_val(charval(tok->val[1]));
case STRING:
return expr_from_val(strval(strdup(tok->val)));
case TRUE:
return expr_from_val(boolval(1));
case FALSE:
return expr_from_val(boolval(0));
case NULLKW:
return nullexpr();
default:
syntaxerror("expected %s, not %s", expect, tok->val);
return NULL;
}
}
int history_change(history_t* past, U16 frame, char* parameter)
{
state_t* first = dict_lookup(past->states, parameter);
if (first) //should always be true.
return state_differs(first, frame);
syntaxerror("no history found to predict changes for parameter %s.\n", parameter);
return 0;
}
float history_value(history_t* past, U16 frame, char* parameter)
{
state_t* state = dict_lookup(past->states, parameter);
if (state) //should always be true.
return state_value(state, frame);
syntaxerror("no history found to get a value for parameter %s.\n", parameter);
return 0;
}
int history_changeFilter(history_t* past, U16 frame)
{
filterState_t* first = dict_lookup(past->states, "filter");
if (first) //should always be true.
return filterState_differs(first, frame);
syntaxerror("no history found to predict changes for parameter filter.\n");
return 0;
}
FILTERLIST* history_filterValue(history_t* past, U16 frame)
{
filterState_t* first = dict_lookup(past->states, "filter");
if (first) //should always be true.
return filterState_value(first, frame);
syntaxerror("no history found to get a value for parameter filter.\n");
return 0;
}
void history_rememberFilter(history_t* past, U16 frame, int function, FILTERLIST* value, interpolation_t* inter)
{
past->lastFrame = frame;
filterState_t* first = dict_lookup(past->states, "filter");
if (first) //should always be true
{
filterState_t* next = filterState_new(frame, function, value, inter);
filterState_append(first, next);
}
else
syntaxerror("Internal error: changing a filter not set for the instance.");
}
void history_remember(history_t* past, char* parameter, U16 frame, int function, float value, interpolation_t* inter)
{
past->lastFrame = frame;
state_t* state = dict_lookup(past->states, parameter);
if (state) //should always be true
{
state_t* next = state_new(frame, function, value, inter);
state_append(state, next);
}
else
syntaxerror("Internal error: changing parameter %s, which is unknown for the instance.", parameter);
}
bool SyntaxAnalyzer::startcheck(
std::set<symboltype> &starters,
std::set<symboltype> &followers
) {
if (starters.find(symbol) == starters.end()) {
syntaxerror(othersy);
skipto(starters, followers);
return false; //symbol not in starters
} else {
return true; //symbol in starters
}
}
void filterState_append(filterState_t* first, filterState_t* newChange)
{
while (first->next)
first = first->next;
if (!first->value || !newChange->value)
first->next = newChange;
else
{
int i, mergedCount = 0;
int common = first->value->num < newChange->value->num ? first->value->num : newChange->value->num;
for (i = 0; i < common; i++)
{
mergedCount++;
if (newChange->value->filter[i]->type != first->value->filter[i]->type)
mergedCount++;
}
mergedCount = mergedCount + first->value->num - common + newChange->value->num - common;
if (mergedCount > 8)
{
char* list1;
char* list2;
char* newList;
list1 = (char*)malloc(1);
*list1 = '\0';
for (i = 0; i < first->value->num; i++)
{
char*filter = filtername[first->value->filter[i]->type];
newList = (char*)malloc(strlen(list1) + strlen(filter) + 2);
strcpy(newList, list1);
strcat(newList, "+");
strcat(newList, filtername[first->value->filter[i]->type]);
free(list1);
list1 = newList;
}
list2 = (char*)malloc(1);
*list2 = '\0';
for (i = 0; i < newChange->value->num; i++)
{
char*filter = filtername[newChange->value->filter[i]->type];
newList = (char*)malloc(strlen(list2) + strlen(filter) + 2);
strcpy(newList, list2);
strcat(newList, "+");
strcat(newList, filter);
free(list2);
list2 = newList;
}
syntaxerror("filterlists %s and %s cannot be interpolated.", list1, list2);
}
first->next = newChange;
}
}
variable_t* new_variable2(methodstate_t*method, const char*name, classinfo_t*type, char init, char maybeslot)
{
if(maybeslot) {
variable_t*v = find_slot(method, name);
if(v) {
alloc_local();
return v;
}
}
NEW(variable_t, v);
v->type = type;
v->init = v->kill = init;
if(name) {
if(!method->no_variable_scoping) {
if(dict_contains(state->vars, name)) {
syntaxerror("variable %s already defined", name);
}
v->index = alloc_local();
dict_put(state->vars, name, v);
} else {
if(as3_pass==2 && dict_contains(state->method->allvars, name)) {
variable_t*v = dict_lookup(state->method->allvars, name);
if(v->type != type && (!v->type || v->type->kind!=INFOTYPE_UNRESOLVED)) {
syntaxerror("variable %s already defined.", name);
}
return v;
}
v->index = alloc_local();
}
dict_put(state->method->allvars, name, v);
} else {
v->index = alloc_local();
}
return v;
}
struct val *parse_val(void)
{
next();
switch (tok->type)
{
case INT: return intval(atoi(tok->val));
case REAL: return realval(atof(tok->val));
case STRING: return strval(tok->val);
case TRUE: return boolval(true);
case FALSE: return boolval(false);
case CHAR: return charval(tok->val[1]);
default:
syntaxerror("expected a value, not %s", tok->val);
return intval(0);
}
}
struct type_decl *parse_typedecl(void)
{
eat(IDENTIFIER);
struct pos pos = *tok->pos;
char *ident = strdup(tok->val);
struct type_def *type_def = NULL;
eat(EQ);
switch (lookahead[0]->type)
{
case LPAREN: type_def = parse_enum_def(); break;
case RECORD: type_def = parse_record_def(); break;
case INT: case IDENTIFIER: type_def = parse_array_def(); break;
case DEREF: type_def = parse_pointer_def(); break;
default: syntaxerror("expected type definition, not %s", tok->val);
}
return make_type_decl(ident, type_def, pos);
}
GRADIENT* interpolateNodes(GRADIENT* g1, GRADIENT* g2, float fraction, interpolation_t* inter)
{
if (g1->num != g2->num)
syntaxerror("Internal error: gradients are not equal in size");
int i;
GRADIENT* g = (GRADIENT*) malloc(sizeof(GRADIENT));
g->ratios = rfx_calloc(16*sizeof(U8));
g->rgba = rfx_calloc(16*sizeof(RGBA));
g->num = g1->num;
for (i = 0; i < g->num; i++)
{
g->ratios[i] = interpolateScalar(g1->ratios[i], g2->ratios[i], fraction, inter);
g->rgba[i] = interpolateColor(g1->rgba[i], g2->rgba[i], fraction, inter);
}
return g;
}
void old_state()
{
if(!state || !state->old)
syntaxerror("invalid nesting");
state_t*leaving = state;
state = state->old;
if(as3_pass>1 && leaving->method && leaving->method != state->method && !leaving->method->inner) {
methodstate_destroy(leaving->method);leaving->method=0;
}
if(as3_pass>1 && leaving->cls && leaving->cls != state->cls) {
free(leaving->cls);
leaving->cls=0;
}
state_destroy(leaving);
}
// <statement> ::= <simple statement>
// | <complex statement>
void SyntaxAnalyzer::statement(std::set<symboltype> followers)
{
//ako neterminala ne se vika ot drugo mqsto
//ne se pravi startcheck & endcheck v tqh a samo v parenta
if (statementStarters.find(symbol) != statementStarters.end()) {
switch(symbol) {
case ident: assignment(followers); break;
case beginsy: compoundStatement(followers); break;
case ifsy: ifStatement(followers); break;
case whilesy: whileStatement(followers); break;
case readsy: readStatement(followers); break;
case writesy: writeStatement(followers); break;
default:
break;
} // swtich
} else {
syntaxerror(othersy);
}
} // statement()
void finish_file()
{
if(!state || state->level!=1) {
syntaxerror("unexpected end of file in pass %d", as3_pass);
}
if(as3_pass==2) {
dict_del(global->file2token2info, current_filename);
code_t*header = method_header(state->method);
//if(global->init->method->body->code || global->init->traits) {
if(global->init) {
code_t*c = wrap_function(header, 0, global->init->method->body->code);
global->init->method->body->code = abc_returnvoid(c);
free(state->method);state->method=0;
}
}
//free(state->package);state->package=0; // used in registry
state_destroy(state);state=0;
}
struct expr* build_dim(struct token* tok)
{
switch(tok->type)
{
case INT:
return expr_from_val(intval(atoi(tok->val)));
case IDENTIFIER:
{
struct expr *e = malloc(sizeof(struct expr));
e->exprtype = identtype;
e->val.ident = strdup(tok->val);
e->type = NULL;
e->pos = *tok->pos;
return e;
}
default:
syntaxerror("expected integer or identifier not %s", tok->val);
}
return NULL;
}
FILTER* noFilter(int type)
{
switch (type)
{
case FILTERTYPE_BLUR:
return (FILTER*)noBlur;
break;
case FILTERTYPE_BEVEL:
return (FILTER*)noBevel;
break;
case FILTERTYPE_DROPSHADOW:
return (FILTER*)noDropshadow;
break;
case FILTERTYPE_GRADIENTGLOW:
return (FILTER*)noGradientGlow;
break;
default:
syntaxerror("Internal error: unsupported filtertype, cannot match filterlists");
}
return 0;
}
float history_rotateValue(history_t* past, U16 frame)
{
state_t* rotations = dict_lookup(past->states, "rotate");
if (rotations) //should always be true.
{
float angle = state_value(rotations, frame);
state_t* flags = dict_lookup(past->states, "flags");
U16 currentflags = state_value(flags, frame);
if (currentflags & IF_FIXED_ALIGNMENT)
{
flags = state_at(flags, frame);
if (frame == past->firstFrame)
frame++;
state_t *x, *y;
float dx, dy, pathAngle;
do
{
x = dict_lookup(past->states, "x");
dx = state_value(x, frame) - state_value(x, frame - 1);
y = dict_lookup(past->states, "y");
dy = state_value(y, frame) - state_value(y, frame - 1);
frame--;
}
while (dx == 0 && dy == 0 && frame > past->firstFrame);
if (frame == past->firstFrame)
pathAngle = 0;
else
pathAngle = getAngle(dx, dy) / M_PI * 180;
return angle + flags->params.instanceAngle + pathAngle - flags->params.pathAngle;
}
else
return angle;
}
syntaxerror("no history found to get a value for parameter rotate.\n");
return 0;
}
code_t*defaultvalue(code_t*c, classinfo_t*type)
{
as3_assert(!type || type->kind!=INFOTYPE_UNRESOLVED);
if(TYPE_IS_INT(type)) {
c = abc_pushbyte(c, 0);
} else if(TYPE_IS_UINT(type)) {
c = abc_pushuint(c, 0);
} else if(TYPE_IS_FLOAT(type)) {
c = abc_pushnan(c);
} else if(TYPE_IS_BOOLEAN(type)) {
c = abc_pushfalse(c);
} else if(TYPE_IS_STRING(type)) {
c = abc_pushnull(c);
c = abc_coerce_s(c);
} else if(!type) {
//c = abc_pushundefined(c);
syntaxerror("internal error: can't generate default value for * type");
} else {
c = abc_pushnull(c);
MULTINAME(m, type);
c = abc_coerce2(c, &m);
}
return c;
}
int main()
{
int fddata;
int i;
int j;
int k;
char ch;
unsigned long ttl;
char ttd[8];
char loc[2];
unsigned long u;
char ip[4];
char ip6[16];
char type[2];
char soa[20];
char buf[4];
umask(022);
fddata = open_read("data");
if (fddata == -1)
strerr_die2sys(111,FATAL,"unable to open data: ");
defaultsoa_init(fddata);
buffer_init(&b,buffer_unixread,fddata,bspace,sizeof bspace);
fdcdb = open_trunc("data.tmp");
if (fdcdb == -1) die_datatmp();
if (cdb_make_start(&cdb,fdcdb) == -1) die_datatmp();
while (match) {
++linenum;
if (getln(&b,&line,&match,'\n') == -1)
strerr_die2sys(111,FATAL,"unable to read line: ");
while (line.len) {
ch = line.s[line.len - 1];
if ((ch != ' ') && (ch != '\t') && (ch != '\n')) break;
--line.len;
}
if (!line.len) continue;
if (line.s[0] == '#') continue;
if (line.s[0] == '-') continue;
j = 1;
for (i = 0;i < NUMFIELDS;++i) {
if (j >= line.len) {
if (!stralloc_copys(&f[i],"")) nomem();
}
else {
k = byte_chr(line.s + j,line.len - j,':');
if (!stralloc_copyb(&f[i],line.s + j,k)) nomem();
j += k + 1;
}
}
switch(line.s[0]) {
case '%':
locparse(&f[0],loc);
if (!stralloc_copyb(&key,"\0%",2)) nomem();
if (!stralloc_0(&f[1])) nomem();
ipprefix_cat(&key,f[1].s);
if (cdb_make_add(&cdb,key.s,key.len,loc,2) == -1)
die_datatmp();
break;
case 'Z':
if (!dns_domain_fromdot(&d1,f[0].s,f[0].len)) nomem();
if (!stralloc_0(&f[3])) nomem();
if (!scan_ulong(f[3].s,&u)) uint32_unpack_big(defaultsoa,&u);
uint32_pack_big(soa,u);
if (!stralloc_0(&f[4])) nomem();
if (!scan_ulong(f[4].s,&u)) uint32_unpack_big(defaultsoa + 4,&u);
uint32_pack_big(soa + 4,u);
if (!stralloc_0(&f[5])) nomem();
if (!scan_ulong(f[5].s,&u)) uint32_unpack_big(defaultsoa + 8,&u);
uint32_pack_big(soa + 8,u);
if (!stralloc_0(&f[6])) nomem();
if (!scan_ulong(f[6].s,&u)) uint32_unpack_big(defaultsoa + 12,&u);
uint32_pack_big(soa + 12,u);
if (!stralloc_0(&f[7])) nomem();
if (!scan_ulong(f[7].s,&u)) uint32_unpack_big(defaultsoa + 16,&u);
uint32_pack_big(soa + 16,u);
if (!stralloc_0(&f[8])) nomem();
if (!scan_ulong(f[8].s,&ttl)) ttl = TTL_NEGATIVE;
ttdparse(&f[9],ttd);
locparse(&f[10],loc);
rr_start(DNS_T_SOA,ttl,ttd,loc);
if (!dns_domain_fromdot(&d2,f[1].s,f[1].len)) nomem();
rr_addname(d2);
if (!dns_domain_fromdot(&d2,f[2].s,f[2].len)) nomem();
rr_addname(d2);
rr_add(soa,20);
rr_finish(d1);
break;
case '.': case '&':
if (!dns_domain_fromdot(&d1,f[0].s,f[0].len)) nomem();
if (!stralloc_0(&f[3])) nomem();
if (!scan_ulong(f[3].s,&ttl)) ttl = TTL_NS;
ttdparse(&f[4],ttd);
locparse(&f[5],loc);
if (!stralloc_0(&f[1])) nomem();
if (byte_chr(f[2].s,f[2].len,'.') >= f[2].len) {
if (!stralloc_cats(&f[2],".ns.")) nomem();
if (!stralloc_catb(&f[2],f[0].s,f[0].len)) nomem();
}
if (!dns_domain_fromdot(&d2,f[2].s,f[2].len)) nomem();
if (line.s[0] == '.') {
rr_start(DNS_T_SOA,ttl ? TTL_NEGATIVE : 0,ttd,loc);
rr_addname(d2);
rr_add("\12hostmaster",11);
rr_addname(d1);
rr_add(defaultsoa,20);
rr_finish(d1);
}
rr_start(DNS_T_NS,ttl,ttd,loc);
rr_addname(d2);
rr_finish(d1);
if (ip4_scan(f[1].s,ip)) {
rr_start(DNS_T_A,ttl,ttd,loc);
rr_add(ip,4);
rr_finish(d2);
}
break;
case '+': case '=':
if (!dns_domain_fromdot(&d1,f[0].s,f[0].len)) nomem();
if (!stralloc_0(&f[2])) nomem();
if (!scan_ulong(f[2].s,&ttl)) ttl = TTL_POSITIVE;
ttdparse(&f[3],ttd);
locparse(&f[4],loc);
if (!stralloc_0(&f[1])) nomem();
if (ip4_scan(f[1].s,ip)) {
rr_start(DNS_T_A,ttl,ttd,loc);
rr_add(ip,4);
rr_finish(d1);
if (line.s[0] == '=') {
dns_name4_domain(dptr,ip);
rr_start(DNS_T_PTR,ttl,ttd,loc);
rr_addname(d1);
rr_finish(dptr);
}
}
break;
case '6': case '3':
if (!dns_domain_fromdot(&d1,f[0].s,f[0].len)) nomem();
if (!stralloc_0(&f[2])) nomem();
if (!scan_ulong(f[2].s,&ttl)) ttl = TTL_POSITIVE;
ttdparse(&f[3],ttd);
locparse(&f[4],loc);
if (!stralloc_0(&f[1])) nomem();
if (ip6_scan_flat(f[1].s,ip6)) {
rr_start(DNS_T_AAAA,ttl,ttd,loc);
rr_add(ip6,16);
rr_finish(d1);
if (line.s[0] == '6') { /* emit both .ip6.arpa and .ip6.int */
dns_name6_domain(d6ptr,ip6,DNS_IP6_ARPA);
rr_start(DNS_T_PTR,ttl,ttd,loc);
rr_addname(d1);
rr_finish(d6ptr);
dns_name6_domain(d6ptr,ip6,DNS_IP6_INT);
rr_start(DNS_T_PTR,ttl,ttd,loc);
rr_addname(d1);
rr_finish(d6ptr);
}
}
break;
case '@':
if (!dns_domain_fromdot(&d1,f[0].s,f[0].len)) nomem();
if (!stralloc_0(&f[4])) nomem();
if (!scan_ulong(f[4].s,&ttl)) ttl = TTL_POSITIVE;
ttdparse(&f[5],ttd);
locparse(&f[6],loc);
if (!stralloc_0(&f[1])) nomem();
if (byte_chr(f[2].s,f[2].len,'.') >= f[2].len) {
if (!stralloc_cats(&f[2],".mx.")) nomem();
if (!stralloc_catb(&f[2],f[0].s,f[0].len)) nomem();
}
if (!dns_domain_fromdot(&d2,f[2].s,f[2].len)) nomem();
if (!stralloc_0(&f[3])) nomem();
if (!scan_ulong(f[3].s,&u)) u = 0;
rr_start(DNS_T_MX,ttl,ttd,loc);
uint16_pack_big(buf,u);
rr_add(buf,2);
rr_addname(d2);
rr_finish(d1);
if (ip4_scan(f[1].s,ip)) {
rr_start(DNS_T_A,ttl,ttd,loc);
rr_add(ip,4);
rr_finish(d2);
}
break;
case '^': case 'C':
if (!dns_domain_fromdot(&d1,f[0].s,f[0].len)) nomem();
if (!dns_domain_fromdot(&d2,f[1].s,f[1].len)) nomem();
if (!stralloc_0(&f[2])) nomem();
if (!scan_ulong(f[2].s,&ttl)) ttl = TTL_POSITIVE;
ttdparse(&f[3],ttd);
locparse(&f[4],loc);
if (line.s[0] == 'C')
rr_start(DNS_T_CNAME,ttl,ttd,loc);
else
rr_start(DNS_T_PTR,ttl,ttd,loc);
rr_addname(d2);
rr_finish(d1);
break;
case '\'':
if (!dns_domain_fromdot(&d1,f[0].s,f[0].len)) nomem();
if (!stralloc_0(&f[2])) nomem();
if (!scan_ulong(f[2].s,&ttl)) ttl = TTL_POSITIVE;
ttdparse(&f[3],ttd);
locparse(&f[4],loc);
rr_start(DNS_T_TXT,ttl,ttd,loc);
txtparse(&f[1]);
i = 0;
while (i < f[1].len) {
k = f[1].len - i;
if (k > 127) k = 127;
ch = k;
rr_add(&ch,1);
rr_add(f[1].s + i,k);
i += k;
}
rr_finish(d1);
break;
case ':':
if (!dns_domain_fromdot(&d1,f[0].s,f[0].len)) nomem();
if (!stralloc_0(&f[3])) nomem();
if (!scan_ulong(f[3].s,&ttl)) ttl = TTL_POSITIVE;
ttdparse(&f[4],ttd);
locparse(&f[5],loc);
if (!stralloc_0(&f[1])) nomem();
scan_ulong(f[1].s,&u);
uint16_pack_big(type,u);
if (byte_equal(type,2,DNS_T_AXFR))
syntaxerror(": type AXFR prohibited");
if (byte_equal(type,2,"\0\0"))
syntaxerror(": type 0 prohibited");
if (byte_equal(type,2,DNS_T_SOA))
syntaxerror(": type SOA prohibited");
if (byte_equal(type,2,DNS_T_NS))
syntaxerror(": type NS prohibited");
if (byte_equal(type,2,DNS_T_CNAME))
syntaxerror(": type CNAME prohibited");
if (byte_equal(type,2,DNS_T_PTR))
syntaxerror(": type PTR prohibited");
if (byte_equal(type,2,DNS_T_MX))
syntaxerror(": type MX prohibited");
txtparse(&f[2]);
rr_start(type,ttl,ttd,loc);
rr_add(f[2].s,f[2].len);
rr_finish(d1);
break;
default:
syntaxerror(": unrecognized leading character");
}
}
if (cdb_make_finish(&cdb) == -1) die_datatmp();
if (fsync(fdcdb) == -1) die_datatmp();
if (close(fdcdb) == -1) die_datatmp(); /* NFS stupidity */
if (rename("data.tmp","data.cdb") == -1)
strerr_die2sys(111,FATAL,"unable to move data.tmp to data.cdb: ");
_exit(0);
}
int main()
{
char ip[4];
unsigned long u;
unsigned int j;
unsigned int k;
char ch;
umask(022);
fd = open_read("data");
if (fd == -1) strerr_die2sys(111,FATAL,"unable to open data: ");
buffer_init(&b,buffer_unixread,fd,bspace,sizeof bspace);
fdcdb = open_trunc("data.tmp");
if (fdcdb == -1) die_datatmp();
if (cdb_make_start(&cdb,fdcdb) == -1) die_datatmp();
while (match) {
++linenum;
if (getln(&b,&line,&match,'\n') == -1)
strerr_die2sys(111,FATAL,"unable to read line: ");
while (line.len) {
ch = line.s[line.len - 1];
if ((ch != ' ') && (ch != '\t') && (ch != '\n')) break;
--line.len;
}
if (!line.len) continue;
switch(line.s[0]) {
default:
syntaxerror(": unrecognized leading character");
case '#':
break;
case ':':
j = byte_chr(line.s + 1,line.len - 1,':');
if (j >= line.len - 1) syntaxerror(": missing colon");
if (ip4_scan(line.s + 1,ip) != j) syntaxerror(": malformed IP address");
if (!stralloc_copyb(&tmp,ip,4)) nomem();
if (!stralloc_catb(&tmp,line.s + j + 2,line.len - j - 2)) nomem();
if (cdb_make_add(&cdb,"",0,tmp.s,tmp.len) == -1)
die_datatmp();
break;
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
if (!stralloc_0(&line)) nomem();
j = 0;
if (!stralloc_copys(&tmp,"")) nomem();
for (;;) {
k = scan_ulong(line.s + j,&u);
if (!k) break;
ch = u;
if (!stralloc_catb(&tmp,&ch,1)) nomem();
j += k;
if (line.s[j] != '.') break;
++j;
}
if (!stralloc_catb(&tmp,"\0\0\0\0",4)) nomem();
tmp.len = 4;
if (line.s[j] == '/')
scan_ulong(line.s + j + 1,&u);
else
u = 32;
if (u > 32) u = 32;
ch = u;
if (!stralloc_catb(&tmp,&ch,1)) nomem();
if (cdb_make_add(&cdb,tmp.s,tmp.len,"",0) == -1)
die_datatmp();
break;
}
}
if (cdb_make_finish(&cdb) == -1) die_datatmp();
if (fsync(fdcdb) == -1) die_datatmp();
if (close(fdcdb) == -1) die_datatmp(); /* NFS stupidity */
if (rename("data.tmp","data.cdb") == -1)
strerr_die2sys(111,FATAL,"unable to move data.tmp to data.cdb: ");
return 0;
}
int main(int argc, char **argv)
{
int fddata;
uint32 loc;
//int v;
char ipa[4];
//char ipb[4];
//ip4_cidr_t *subnets = (ip4_cidr_t *)NULL;
//unsigned int slen = 0;
uint32 ipinta = 0U;
//unsigned int ipintb = 0;
unsigned short mask;
uint32 uid = 0;
uint32 mid = 0;
int i;
int j;
int k;
char ch;
unsigned long ttl;
char ttd[8];
//uint32 loc;
unsigned char keyloc[15];
unsigned long u;
char ip[4];
char locp[4];
//char map[9];
char type[2];
char soa[20];
char buf[4];
//int namlen = 0;
umask(022);
fddata = STDIN_FILENO;
if (argc != 3) {
fddata = open_read("data");
if (fddata == -1) strerr_die2sys(111,FATAL,"unable to open data: ");
if ( (fdcdb = open_trunc("data.tmp")) == -1) die_datatmp();
} else {
fddata = STDIN_FILENO;
if ( (fdcdb = open_trunc(argv[1])) == -1) die_datatmp();
}
defaultsoa_init(fddata);
buffer_init(&b,buffer_unixread,fddata,bspace,sizeof bspace);
if (cdb_make_start(&cdb,fdcdb) == -1) die_datatmp();
while (match) {
++linenum;
if (getln(&b,&line,&match,'\n') == -1)
strerr_die2sys(111,FATAL,"unable to read line: ");
while (line.len) {
ch = line.s[line.len - 1];
if ((ch != ' ') && (ch != '\t') && (ch != '\n')) break;
--line.len;
}
if (!line.len) continue;
if (line.s[0] == '#') continue;
if (line.s[0] == '-') continue;
//write(1,line.s,line.len);
//write(1,"\n",1);
j = 1;
for (i = 0;i < NUMFIELDS;++i) {
if (j >= line.len) {
if (!stralloc_copys(&f[i],"")) nomem();
}
else {
k = byte_chr(line.s + j,line.len - j,':');
if (!stralloc_copyb(&f[i],line.s + j,k)) nomem();
j += k + 1;
}
}
switch(line.s[0]) {
#ifdef USE_LOCMAPS
case '%':
//locparse(&f[0],loc);
loc = gethash(f[0].s,f[0].len);
uint32_pack(locp,loc);
if (!stralloc_0(&f[1])) nomem();
if (!stralloc_0(&f[2])) nomem();
ip4_scan(f[1].s,ipa);
//ip4_scan(f[2].s,ipb);
scan_ushort(f[2].s,&mask);
ip4_num(&ipinta,ipa);
//ip4_num(&ipintb,ipb);
//if (ipintb<ipinta) nomem();
//if (ip4_deaggregate(ipinta,ipintb,&subnets,&slen) <= 0) nomem();
mid = gethash(f[3].s,f[3].len);
uid = gethash(f[4].s,f[4].len);
//for (v = 0; v < slen; v++) {
ipdb_key4build(keyloc,ipinta,(unsigned char )mask&0xff,mid,uid);
//ipdb_key_from_uint(keyloc,ipinta,(unsigned char )mask&0xff,0,mid,uid);
cdb_make_add(&cdb,keyloc,15,locp,4);
//}
uid = 0;
//alloc_free(subnets);
//subnets = NULL;
//slen = 0;
byte_zero(ipa,4);ipinta=0; //byte_zero(ipb,4);ipinta=0;ipintb=0;
break;
#endif
case 'Z':
if (!dns_domain_fromdot(&d1,f[0].s,f[0].len)) nomem();
if (!stralloc_0(&f[3])) nomem();
if (!scan_ulong(f[3].s,&u)) uint32_unpack_big(defaultsoa,&u);
uint32_pack_big(soa,u);
if (!stralloc_0(&f[4])) nomem();
if (!scan_ulong(f[4].s,&u)) uint32_unpack_big(defaultsoa + 4,&u);
uint32_pack_big(soa + 4,u);
if (!stralloc_0(&f[5])) nomem();
if (!scan_ulong(f[5].s,&u)) uint32_unpack_big(defaultsoa + 8,&u);
uint32_pack_big(soa + 8,u);
if (!stralloc_0(&f[6])) nomem();
if (!scan_ulong(f[6].s,&u)) uint32_unpack_big(defaultsoa + 12,&u);
uint32_pack_big(soa + 12,u);
if (!stralloc_0(&f[7])) nomem();
if (!scan_ulong(f[7].s,&u)) uint32_unpack_big(defaultsoa + 16,&u);
uint32_pack_big(soa + 16,u);
if (!stralloc_0(&f[8])) nomem();
if (!scan_ulong(f[8].s,&ttl)) ttl = TTL_NEGATIVE;
ttdparse(&f[9],ttd);
loc = gethash(f[10].s,f[10].len);
mid = gethash(f[11].s,f[11].len);
uid = gethash(f[12].s,f[12].len);
rr_addloq(DNS_T_SOA,d1,loc,mid,uid);
rr_start(DNS_T_SOA,ttl,ttd,loc);
if (!dns_domain_fromdot(&d2,f[1].s,f[1].len)) nomem();
rr_addname(d2);
if (!dns_domain_fromdot(&d2,f[2].s,f[2].len)) nomem();
rr_addname(d2);
rr_add(soa,20);
rr_finish(d1);
break;
case '.': case '&':
if (!dns_domain_fromdot(&d1,f[0].s,f[0].len)) nomem();
if (!stralloc_0(&f[3])) nomem();
if (!scan_ulong(f[3].s,&ttl)) ttl = TTL_NS;
ttdparse(&f[4],ttd);
loc = gethash(f[5].s,f[5].len);
mid = gethash(f[6].s,f[6].len);
uid = gethash(f[7].s,f[7].len);
if (!stralloc_0(&f[1])) nomem();
if (byte_chr(f[2].s,f[2].len,'.') >= f[2].len) {
if (!stralloc_cats(&f[2],".ns.")) nomem();
if (!stralloc_catb(&f[2],f[0].s,f[0].len)) nomem();
}
if (!dns_domain_fromdot(&d2,f[2].s,f[2].len)) nomem();
if (line.s[0] == '.') {
rr_start(DNS_T_SOA,ttl ? TTL_NEGATIVE : 0,ttd,loc);
rr_addloq(DNS_T_SOA,d1,loc,mid,uid);
rr_addname(d2);
rr_add("\12hostmaster",11);
rr_addname(d1);
rr_add(defaultsoa,20);
rr_finish(d1);
}
rr_start(DNS_T_NS,ttl,ttd,loc);
rr_addname(d2);
rr_addloq(DNS_T_NS,d2,loc,mid,uid);
rr_finish(d1);
if (ip4_scan(f[1].s,ip)) {
rr_start(DNS_T_A,ttl,ttd,loc);
rr_addloq(DNS_T_A,d2,loc,mid,uid);
rr_add(ip,4);
rr_finish(d2);
}
break;
case '+': case '=':
if (!dns_domain_fromdot(&d1,f[0].s,f[0].len)) nomem();
if (!stralloc_0(&f[2])) nomem();
if (!scan_ulong(f[2].s,&ttl)) ttl = TTL_POSITIVE;
ttdparse(&f[3],ttd);
loc = gethash(f[4].s,f[4].len);
mid = gethash(f[5].s,f[5].len);
uid = gethash(f[6].s,f[6].len);
if (!stralloc_0(&f[1])) nomem();
if (ip4_scan(f[1].s,ip)) {
rr_addloq(DNS_T_A,d1,loc,mid,uid);
rr_start(DNS_T_A,ttl,ttd,loc);
//dbger("+addloq:d=%s,loc=%u,uid=%u,mid=%u",d1,loc,uid,mid);
rr_add(ip,4);
rr_finish(d1);
if (line.s[0] == '=') {
rr_addloq(DNS_T_PTR,d1,loc,mid,uid); //??????????????????/ TODO: checkthis
dns_name4_domain(dptr,ip);
rr_start(DNS_T_PTR,ttl,ttd,loc);
rr_addname(d1);
rr_finish(dptr);
}
}
break;
case '@':
if (!dns_domain_fromdot(&d1,f[0].s,f[0].len)) nomem();
if (!stralloc_0(&f[4])) nomem();
if (!scan_ulong(f[4].s,&ttl)) ttl = TTL_POSITIVE;
ttdparse(&f[5],ttd);
loc = gethash(f[6].s,f[6].len);
mid = gethash(f[7].s,f[7].len);
uid = gethash(f[8].s,f[8].len);
if (!stralloc_0(&f[1])) nomem();
if (byte_chr(f[2].s,f[2].len,'.') >= f[2].len) {
if (!stralloc_cats(&f[2],".mx.")) nomem();
if (!stralloc_catb(&f[2],f[0].s,f[0].len)) nomem();
}
if (!dns_domain_fromdot(&d2,f[2].s,f[2].len)) nomem();
if (!stralloc_0(&f[3])) nomem();
if (!scan_ulong(f[3].s,&u)) u = 0;
rr_addloq(DNS_T_MX,d1,loc,mid,uid);
rr_start(DNS_T_MX,ttl,ttd,loc);
uint16_pack_big(buf,u);
rr_add(buf,2);
rr_addname(d2);
rr_finish(d1);
if (ip4_scan(f[1].s,ip)) {
rr_addloq(DNS_T_A,d2,loc,mid,uid);
rr_start(DNS_T_A,ttl,ttd,loc);
rr_add(ip,4);
rr_finish(d2);
}
break;
case '^': case 'C':
if (!dns_domain_fromdot(&d1,f[0].s,f[0].len)) nomem();
if (!dns_domain_fromdot(&d2,f[1].s,f[1].len)) nomem();
if (!stralloc_0(&f[2])) nomem();
if (!scan_ulong(f[2].s,&ttl)) ttl = TTL_POSITIVE;
ttdparse(&f[3],ttd);
loc = gethash(f[4].s,f[4].len);
mid = gethash(f[5].s,f[5].len);
uid = gethash(f[6].s,f[6].len);
if (line.s[0] == 'C') {
//rr_addloq(DNS_T_CNAME,d1,loc,mid,uid);
//dbger("add loq for cname!");
rr_addloq(DNS_T_A,d1,loc,mid,uid);
rr_addloq(DNS_T_CNAME,d1,loc,mid,uid);
rr_start(DNS_T_CNAME,ttl,ttd,loc);
} else {
rr_addloq(DNS_T_PTR,d1,loc,mid,uid);
rr_start(DNS_T_PTR,ttl,ttd,loc);
}
rr_addname(d2);
rr_finish(d1);
break;
case '\'':
if (!dns_domain_fromdot(&d1,f[0].s,f[0].len)) nomem();
if (!stralloc_0(&f[2])) nomem();
if (!scan_ulong(f[2].s,&ttl)) ttl = TTL_POSITIVE;
ttdparse(&f[3],ttd);
loc = gethash(f[4].s,f[4].len);
mid = gethash(f[5].s,f[5].len);
uid = gethash(f[6].s,f[6].len);
rr_addloq(DNS_T_TXT,d1,loc,mid,uid);
rr_start(DNS_T_TXT,ttl,ttd,loc);
txtparse(&f[1]);
i = 0;
while (i < f[1].len) {
k = f[1].len - i;
if (k > 127) k = 127;
ch = k;
rr_add(&ch,1);
rr_add(f[1].s + i,k);
i += k;
}
rr_finish(d1);
break;
case ':':
if (!dns_domain_fromdot(&d1,f[0].s,f[0].len)) nomem();
if (!stralloc_0(&f[3])) nomem();
if (!scan_ulong(f[3].s,&ttl)) ttl = TTL_POSITIVE;
ttdparse(&f[4],ttd);
loc = gethash(f[5].s,f[5].len);
mid = gethash(f[6].s,f[6].len);
uid = gethash(f[7].s,f[7].len);
if (!stralloc_0(&f[1])) nomem();
scan_ulong(f[1].s,&u);
uint16_pack_big(type,u);
if (byte_equal(type,2,DNS_T_AXFR))
syntaxerror(": type AXFR prohibited");
if (byte_equal(type,2,"\0\0"))
syntaxerror(": type 0 prohibited");
if (byte_equal(type,2,DNS_T_SOA))
syntaxerror(": type SOA prohibited");
if (byte_equal(type,2,DNS_T_NS))
syntaxerror(": type NS prohibited");
if (byte_equal(type,2,DNS_T_CNAME))
syntaxerror(": type CNAME prohibited");
if (byte_equal(type,2,DNS_T_PTR))
syntaxerror(": type PTR prohibited");
if (byte_equal(type,2,DNS_T_MX))
syntaxerror(": type MX prohibited");
txtparse(&f[2]);
rr_addloq(type,d1,loc,mid,uid);
rr_start(type,ttl,ttd,loc);
rr_add(f[2].s,f[2].len);
rr_finish(d1);
break;
default:
dienow("error here: %s\n", line.s);
syntaxerror(": unrecognized leading character");
}
}
if (cdb_make_finish(&cdb) == -1) die_datatmp();
if (fsync(fdcdb) == -1) die_datatmp();
if (close(fdcdb) == -1) die_datatmp(); /* NFS stupidity */
if (argc == 3) {
if (rename(argv[1],argv[2]) == -1) strerr_die2sys(111,FATAL,"unable to move data.tmp to data.cdb: ");
} else {
if (rename("data.tmp","data.cdb") == -1) strerr_die2sys(111,FATAL,"unable to move data.tmp to data.cdb: ");
}
_exit(0);
}
