Expr operator+(Expr a, Expr b) {
//assert(a.type() == b.type() && "Arguments to + must have the same type");
matchTypes(&a, &b);
Expr e(makeAdd(a.node(), b.node()), a.type());
e.child(a);
e.child(b);
return e;
}
void ashley::Engine::EngineOperationHandler::add(ashley::Entity * const entity, std::unique_ptr<Component> &&component,
const std::type_index typeIndex) {
if (engine->updating) {
auto operation = engine->operationPool.obtain();
operation->makeAdd(entity, std::move(component), typeIndex);
engine->operationVector.push_back(operation);
} else {
entity->addInternal(std::move(component), typeIndex);
}
}
/* the real thing */
int
delta(char* src, long n_src, char* tar, long n_tar, int delfd)
{
register char *sp, *tp, *esrc, *etar;
register long size, addr;
Suftree *tree;
Move *moves, *last;
char inst, buf[BUFSIZE];
/* initialize the output area */
delinit(buf,delfd);
/* output file sizes */
inst = DELTA_TYPE | ((NBYTE(n_src)&07) << 3) | (NBYTE(n_tar)&07);
if(delputc(inst) < 0)
return -1;
if(delputl(NBYTE(n_src),n_src) < 0 || delputl(NBYTE(n_tar),n_tar) < 0)
return -1;
/* bases */
Bsrc = src;
Btar = tar;
esrc = src + n_src - 1;
etar = tar + n_tar - 1;
/* initialize list and last block */
moves = 0;
last = 0;
/* try making suffix tree */
if(!(tree = n_tar > 0 ? bldsuftree(src,n_src) : (Suftree*)0))
{
/* not enough space for tree, remove matching prefix and suffix */
for(; src <= esrc && tar <= etar; ++src, ++tar)
if(*src != *tar)
break;
if((size = src-Bsrc) > 0)
{
register int cost_m, cost_a;
cost_m = NBYTE(size) + NBYTE(0);
cost_a = NBYTE(size) + size;
if(cost_m < cost_a)
{
moves = newMove(DELTA_MOVE,size,0L,NiL);
if(!moves)
return -1;
n_src -= src-Bsrc;
n_tar -= tar-Btar;
}
else
{
src = Bsrc;
tar = Btar;
}
}
for(sp = esrc, tp = etar; sp >= src && tp >= tar; --sp, --tp)
if(*sp != *tp)
break;
if((size = esrc-sp) > 0)
{
addr = sp+1-Bsrc;
if(chkMove(size,addr,0L) > 0)
{
last = newMove(DELTA_MOVE,size,addr,NiL);
if(!last)
return -1;
esrc = sp;
etar = tp;
n_tar = etar-tar+1;
n_src = esrc-src+1;
}
}
/* try making the tree again */
tree = n_tar > 0 ? bldsuftree(src,n_src) : (Suftree*)0;
}
/* compute block moves */
tp = 0;
while(n_tar > 0)
{
char *match;
if(tree)
size = mtchsuftree(tree,tar,n_tar,&match);
else size = mtchstring(src,n_src,tar,n_tar,&match);
if(size < 0)
return -1;
if(size > 0)
size = chkMove(size,(long)(match-Bsrc),(long)(tp ? tp-tar : 0));
/* output a block move */
if(size > 0)
{
if(tp)
{
moves = makeAdd(tp,tar,moves);
if(!moves)
return -1;
tp = 0;
}
moves = newMove(DELTA_MOVE,size,(long)(match-Bsrc),moves);
if(!moves)
return -1;
tar += size;
n_tar -= size;
}
else
{
if(!tp)
tp = tar;
tar += 1;
n_tar -= 1;
}
}
/* add any remaining blocks */
if(tp)
{
if(last && chkMove(last->size,last->addr,(long)(tar-tp)) <= 0)
{
tar += last->size;
last = delMove(last);
}
moves = makeAdd(tp,tar,moves);
if(!moves)
return -1;
}
if(last)
{
moves->next = last;
last->last = moves;
}
/* release space use for string matching */
if(tree)
delsuftree(tree);
else mtchstring(NiL,0L,NiL,0L,NiL);
/* optimize move instructions */
if(moves)
{
register Move *ip;
ip = moves;
while(ip->last)
ip = ip->last;
for(; ip; ip = ip->next)
if(ip->type == DELTA_MOVE && ip->size <= (M_MAX+A_MAX))
moves = ip = optMove(ip);
while(moves->last)
moves = moves->last;
}
/* write out the move instructions */
addr = 0L;
while(moves)
{
if(moves->type == DELTA_ADD)
moves->addr = addr;
addr += moves->size;
if(putMove(moves) < 0)
return -1;
moves = delMove(moves);
}
/* write ending token */
delputc((char)DELTA_TYPE);
/* flush buffer */
return delflush();
}
void Expr::operator+=(Expr other) {
other = cast(type(), other);
contents->node = makeAdd(node(), other.node());
child(other);
}
/** Parse with one token worth of look-ahead, return the expression object representing
the syntax parsed.
@param tok next token from the input.
@param fp file subsequent tokens are being read from.
@return the expression object constructed from the input.
*/
Expr *parse( char *tok, FILE *fp )
{
// Create a literal token for anything that looks like a number.
{
long dummy;
int pos;
// See if the whole token parses as a long int.
if ( sscanf( tok, "%ld%n", &dummy, &pos ) == 1 &&
pos == strlen( tok ) ) {
// Copy the literal to a dynamically allocated string, since makeLiteral wants
// a string it can keep.
char *str = (char *) malloc( strlen( tok ) + 1 );
return makeLiteral( strcpy( str, tok ) );
}
}
// Create a literal token for a quoted string, without the quotes.
if ( tok[ 0 ] == '"' ) {
// Same as above, make a dynamically allocated copy of the token that the literal
// expression can keep as long as at wants to.
int len = strlen( tok );
char *str = (char *) malloc( len - 1 );
strncpy( str, tok + 1, len - 2 );
str[ len - 2 ] = '\0';
return makeLiteral( str );
}
// Handle compound statements
if ( strcmp( tok, "{" ) == 0 ) {
int len = 0;
int cap = INITIAL_CAPACITY;
Expr **eList = (Expr **) malloc( cap * sizeof( Expr * ) );
// Keep parsing subexpressions until we hit the closing curly bracket.
while ( strcmp( expectToken( tok, fp ), "}" ) != 0 ) {
if ( len >= cap )
eList = (Expr **) realloc( eList, ( cap *= 2 ) * sizeof( Expr * ) );
eList[ len++ ] = parse( tok, fp );
}
return makeCompound( eList, len );
}
// Handle language operators (reserved words)
if ( strcmp( tok, "print" ) == 0 ) {
// Parse the one argument to print, and create a print expression.
Expr *arg = parse( expectToken( tok, fp ), fp );
return makePrint( arg );
}
if ( strcmp( tok, "set" ) == 0 ) {
// Parse the two operands, then make a set expression with them.
char *str = expectToken( tok, fp );
int len = strlen( str );
char *name = (char *) malloc( len + 1 );
strcpy( name, str );
name[ len ] = '\0';
if ( !isalpha(name[0]) || strlen( name ) > MAX_VAR || strchr( name, LEFT_BRACKET ) || strchr( name, RIGHT_BRACKET ) || strchr( name, POUND ) ) {
// Complain if we can't make sense of the variable.
fprintf( stderr, "line %d: invalid variable name \"%s\"\n", linesRead(), name );
exit( EXIT_FAILURE );
}
Expr *expr = parse( expectToken( tok, fp ), fp );
Expr *set = makeSet
( name, expr );
free(name);
return set;
}
if ( strcmp( tok, "add" ) == 0 ) {
// Parse the two operands, then make an add expression with them.
Expr *op1 = parse( expectToken( tok, fp ), fp );
Expr *op2 = parse( expectToken( tok, fp ), fp );
return makeAdd( op1, op2 );
}
if ( strcmp( tok, "sub" ) == 0 ) {
// Parse the two operands, then make a sub expression with them.
Expr *op1 = parse( expectToken( tok, fp ), fp );
Expr *op2 = parse( expectToken( tok, fp ), fp );
return makeSub( op1, op2 );
}
if ( strcmp( tok, "mul" ) == 0 ) {
// Parse the two operands, then make a mul expression with them.
Expr *op1 = parse( expectToken( tok, fp ), fp );
Expr *op2 = parse( expectToken( tok, fp ), fp );
return makeMul( op1, op2 );
}
if ( strcmp( tok, "div" ) == 0 ) {
// Parse the two operands, then make a div expression with them.
Expr *op1 = parse( expectToken( tok, fp ), fp );
Expr *op2 = parse( expectToken( tok, fp ), fp );
return makeDiv
( op1, op2 );
}
if ( strcmp( tok, "equal" ) == 0 ) {
// Parse the two operands, then make an equal expression with them.
Expr *op1 = parse( expectToken( tok, fp ), fp );
Expr *op2 = parse( expectToken( tok, fp ), fp );
return makeEqual
( op1, op2 );
}
if ( strcmp( tok, "less" ) == 0 ) {
// Parse the two operands, then make a less expression with them.
Expr *op1 = parse( expectToken( tok, fp ), fp );
Expr *op2 = parse( expectToken( tok, fp ), fp );
return makeLess
( op1, op2 );
}
if ( strcmp( tok, "not" ) == 0 ) {
// Parse the operand, then make a not expression with it.
Expr *op = parse( expectToken( tok, fp ), fp );
return makeNot
( op );
}
if ( strcmp( tok, "and" ) == 0 ) {
// Parse the two operands, then make an and expression with them.
Expr *op1 = parse( expectToken( tok, fp ), fp );
Expr *op2 = parse( expectToken( tok, fp ), fp );
return makeAnd
( op1, op2 );
}
if ( strcmp( tok, "or" ) == 0 ) {
// Parse the two operands, then make an or expression with them.
Expr *op1 = parse( expectToken( tok, fp ), fp );
Expr *op2 = parse( expectToken( tok, fp ), fp );
return makeOr
( op1, op2 );
}
if ( strcmp( tok, "if" ) == 0 ) {
// Parse the two operands, then make an if expression with them.
Expr *op1 = parse( expectToken( tok, fp ), fp );
Expr *op2 = parse( expectToken( tok, fp ), fp );
return makeIf
( op1, op2 );
}
if ( strcmp( tok, "while" ) == 0 ) {
// Parse the two operands, then make a while expression with them.
Expr *op1 = parse( expectToken( tok, fp ), fp );
Expr *op2 = parse( expectToken( tok, fp ), fp );
return makeWhile
( op1, op2 );
}
if ( strcmp( tok, "concat" ) == 0 ) {
// Parse the two operands, then make a concatenation expression with them.
Expr *op1 = parse( expectToken( tok, fp ), fp );
Expr *op2 = parse( expectToken( tok, fp ), fp );
return makeConcat
( op1, op2 );
}
if ( strcmp( tok, "substr" ) == 0 ) {
// Parse the three operands, then make a substring expression with them.
Expr *op1 = parse( expectToken( tok, fp ), fp );
Expr *op2 = parse( expectToken( tok, fp ), fp );
Expr *op3 = parse( expectToken( tok, fp ), fp );
return makeSubstr
( op1, op2, op3 );
}
// Handle variables
if ( isalpha(tok[0]) && strlen( tok ) <= MAX_VAR && !strchr( tok, LEFT_BRACKET ) && !strchr( tok, RIGHT_BRACKET ) && !strchr( tok, POUND ) ) {
// Parse the variable name and make a variable expression.
char *str = tok;
int len = strlen( str );
char *name = (char *) malloc( len + 1 );
strcpy( name, str );
name[ len ] = '\0';
Expr *var = makeVariable( name );
free(name);
return var;
}
// Complain if we can't make sense of the token.
fprintf( stderr, "line %d: invalid token \"%s\"\n", linesRead(), tok );
exit( EXIT_FAILURE );
// Never reached.
return NULL;
}
