Cube  Diff

// command.cpp: implements the parsing and execution of a tiny script language
// which is largely backwards compatible with the quake console language.

#include "cube.h"

#import "Alias.h"
#import "Command.h"
#import "Identifier.h"
#import "OFString+Cube.h"
#import "Variable.h"

// contains ALL vars/commands/aliases
static OFMutableDictionary<OFString *, __kindof Identifier *> *identifiers;

static void
cleanup(char **string)
{
	free(*string);
}

void
alias(OFString *name, OFString *action)
{
	Alias *alias = identifiers[name];
	Alias *alias = [Identifier identifierForName:name];

	if (alias == nil) {
		alias = [Alias aliasWithName:name action:action persisted:true];

	if (alias == nil)
		[Identifier addIdentifier:[Alias aliasWithName:name
		                                        action:action
		if (identifiers == nil)
			identifiers = [[OFMutableDictionary alloc] init];

		                                     persisted:true]];
		identifiers[name] = alias;
	} else {
	else {
		if ([alias isKindOfClass:Alias.class])
			alias.action = action;
		else
			conoutf(
			    @"cannot redefine builtin %@ with an alias", name);
	}
}

COMMAND(alias, ARG_2STR)
COMMAND(alias, ARG_2STR, ^(OFString *name, OFString *action) {
	alias(name, action);
})

int
variable(OFString *name, int min, int cur, int max, int *storage,
    void (*function)(), bool persisted)
{
	Variable *variable = [Variable variableWithName:name
	                                            min:min
	                                            max:max
	                                        storage:storage
	                                       function:function
	                                      persisted:persisted];
	[Identifier addIdentifier:[Variable variableWithName:name
	                                                 min:min
	                                                 max:max
	                                             storage:storage
	                                            function:function
	                                           persisted:persisted]];

	if (identifiers == nil)
		identifiers = [[OFMutableDictionary alloc] init];

	identifiers[name] = variable;

	return cur;
}

void
setvar(OFString *name, int i)
{
	Variable *variable = [Identifier identifierForName:name];
	*[identifiers[name] storage] = i;

	if ([variable isKindOfClass:Variable.class])
		*variable.storage = i;
}

int
getvar(OFString *name)
{
	Variable *variable = [Identifier identifierForName:name];

	if ([variable isKindOfClass:Variable.class])
		return *variable.storage;

	return *[identifiers[name] storage];
	return 0;
}

bool
identexists(OFString *name)
{
	return (identifiers[name] != nil);
	return ([Identifier identifierForName:name] != nil);
}

OFString *
getalias(OFString *name)
{
	Alias *alias = identifiers[name];
	Alias *alias = [Identifier identifierForName:name];

	if ([alias isKindOfClass:Alias.class])
		return alias.action;

	return nil;
}

bool
addcommand(OFString *name, void (*function)(), int argumentsTypes)
{
	Command *command = [Command commandWithName:name
	                                   function:function
	                             argumentsTypes:argumentsTypes];

	if (identifiers == nil)
		identifiers = [[OFMutableDictionary alloc] init];

	identifiers[name] = command;

	return false;
}

// parse any nested set of () or []
static char *
parseexp(char **p, int right)
{
	int left = *(*p)++;
	char *word = *p;
	for (int brak = 1; brak;) {

	return strndup(word, *p - word);
}

// find value of ident referenced with $ in exp
OFString *
lookup(OFString *n)
{
	__kindof Identifier *identifier = identifiers[[n substringFromIndex:1]];
	__kindof Identifier *identifier =
	    [Identifier identifierForName:[n substringFromIndex:1]];

	if ([identifier isKindOfClass:Variable.class]) {
		return [OFString stringWithFormat:@"%d", *[identifier storage]];
	} else if ([identifier isKindOfClass:Alias.class])
		return [identifier action];

	conoutf(@"unknown alias lookup: %@", [n substringFromIndex:1]);

			c = [c substringFromIndex:1];
			w[0] = c;
		}
		// empty statement
		if (c.length == 0)
			continue;

		val = executeIdentifier(identifiers[c],
		val = executeIdentifier([Identifier identifierForName:c],
		    [OFArray arrayWithObjects:w count:numargs], isDown);
	}

	return val;
}

// tab-completion of all identifiers

	if (!completesize) {
		completesize = s.length - 1;
		completeidx = 0;
	}

	__block int idx = 0;
	[identifiers enumerateKeysAndObjectsUsingBlock:^(
	    OFString *name, Identifier *identifier, bool *stop) {
	[Identifier enumerateIdentifiersUsingBlock:^(
	    __kindof Identifier *identifier) {
		if (strncmp(identifier.name.UTF8String, s.UTF8String + 1,
		        completesize) == 0 &&
		    idx++ == completeidx)
			[s replaceCharactersInRange:OFMakeRange(1, s.length - 1)
			                 withString:identifier.name];
	}];

{
	if (!execfile([Cube.sharedInstance.userDataIRI
	        IRIByAppendingPathComponent:cfgfile]) &&
	    !execfile([Cube.sharedInstance.gameDataIRI
	        IRIByAppendingPathComponent:cfgfile]))
		conoutf(@"could not read \"%@\"", cfgfile);
}

COMMAND(exec, ARG_1STR, ^(OFString *cfgfile) {
	exec(cfgfile);
})

void
writecfg()
{
	OFStream *stream;
	@try {
		OFIRI *IRI = [Cube.sharedInstance.userDataIRI

	                    @"overwrite these settings\n"
	                    @"// modify settings in game, or put settings in "
	                    @"autoexec.cfg to override anything\n"
	                    @"\n"];
	writeclientinfo(stream);
	[stream writeString:@"\n"];

	[identifiers enumerateKeysAndObjectsUsingBlock:^(
	    OFString *name, __kindof Identifier *identifier, bool *stop) {
		if (![identifier isKindOfClass:Variable.class] ||
		    ![identifier persisted])
			return;
	[Identifier
	    enumerateIdentifiersUsingBlock:^(__kindof Identifier *identifier) {
		    if (![identifier isKindOfClass:Variable.class] ||
		        ![identifier persisted])
			    return;

		[stream writeFormat:@"%@ %d\n", identifier.name,
		        *[identifier storage]];
	}];
		    [stream writeFormat:@"%@ %d\n", identifier.name,
		            *[identifier storage]];
	    }];
	[stream writeString:@"\n"];

	writebinds(stream);
	[stream writeString:@"\n"];

	[identifiers enumerateKeysAndObjectsUsingBlock:^(
	    OFString *name, __kindof Identifier *identifier, bool *stop) {
		if (![identifier isKindOfClass:Alias.class] ||
		    [identifier.name hasPrefix:@"nextmap_"])
			return;
	[Identifier
	    enumerateIdentifiersUsingBlock:^(__kindof Identifier *identifier) {
		    if (![identifier isKindOfClass:Alias.class] ||
		        [identifier.name hasPrefix:@"nextmap_"])
			    return;

		[stream writeFormat:@"alias \"%@\" [%@]\n", identifier.name,
		        [identifier action]];
	}];
		    [stream writeFormat:@"alias \"%@\" [%@]\n", identifier.name,
		            [identifier action]];
	    }];

	[stream close];
}

COMMAND(writecfg, ARG_NONE)
COMMAND(writecfg, ARG_NONE, ^{
	writecfg();
})

// below the commands that implement a small imperative language. thanks to the
// semantics of () and [] expressions, any control construct can be defined
// trivially.

void
intset(OFString *name, int v)
{
	alias(name, [OFString stringWithFormat:@"%d", v]);
}

void
ifthen(OFString *cond, OFString *thenp, OFString *elsep)
COMMAND(if, ARG_3STR, ^(OFString *cond, OFString *thenp, OFString *elsep) {
{
	execute((![cond hasPrefix:@"0"] ? thenp : elsep), true);
}
})

void
loopa(OFString *times, OFString *body)
COMMAND(loop, ARG_2STR, ^(OFString *times, OFString *body) {
{
	int t = times.cube_intValue;

	for (int i = 0; i < t; i++) {
		intset(@"i", i);
		execute(body, true);
	}
}
})

void
whilea(OFString *cond, OFString *body)
COMMAND(while, ARG_2STR, ^(OFString *cond, OFString *body) {
{
	while (execute(cond, true))
		execute(body, true);
}
})

void
onrelease(bool on, OFString *body)
COMMAND(onrelease, ARG_DWN1, ^(bool on, OFString *body) {
{
	if (!on)
		execute(body, true);
}
})

void
concat(OFString *s)
{
	alias(@"s", s);
}

void
concatword(OFString *s)
{
COMMAND(concat, ARG_VARI, ^(OFString *s) {
	concat(s);
})

COMMAND(concatword, ARG_VARI, ^(OFString *s) {
	concat([s stringByReplacingOccurrencesOfString:@" " withString:@""]);
}
})

int
listlen(OFString *a_)
COMMAND(listlen, ARG_1EST, ^(OFString *a_) {
{
	const char *a = a_.UTF8String;

	if (!*a)
		return 0;

	int n = 0;
	while (*a)
		if (*a++ == ' ')
			n++;

	return n + 1;
}
})

void
at(OFString *s_, OFString *pos)
COMMAND(at, ARG_2STR, ^(OFString *s_, OFString *pos) {
{
	int n = pos.cube_intValue;
	char *copy __attribute__((__cleanup__(cleanup))) =
	    strdup(s_.UTF8String);
	char *s = copy;
	for (int i = 0; i < n; i++) {
		s += strcspn(s, " \0");
		s += strspn(s, " ");
	}
	s[strcspn(s, " \0")] = 0;
	concat(@(s));
}
})

COMMANDN(loop, loopa, ARG_2STR)
COMMANDN(while, whilea, ARG_2STR)
COMMANDN(if, ifthen, ARG_3STR)
COMMAND(onrelease, ARG_DWN1)
COMMAND(exec, ARG_1STR)
COMMAND(concat, ARG_VARI)
COMMAND(concatword, ARG_VARI)
COMMAND(at, ARG_2STR)
COMMAND(listlen, ARG_1EST)

int
add(int a, int b)
COMMAND(+, ARG_2EXP, ^(int a, int b) {
{
	return a + b;
}
})
COMMANDN(+, add, ARG_2EXP)

int
mul(int a, int b)
COMMAND(*, ARG_2EXP, ^(int a, int b) {
{
	return a * b;
}
})
COMMANDN(*, mul, ARG_2EXP)

int
sub(int a, int b)
COMMAND(-, ARG_2EXP, ^(int a, int b) {
{
	return a - b;
}
})
COMMANDN(-, sub, ARG_2EXP)

int
divi(int a, int b)
COMMAND(div, ARG_2EXP, ^(int a, int b) {
{
	return b ? a / b : 0;
}
})
COMMANDN(div, divi, ARG_2EXP)

int
mod(int a, int b)
COMMAND(mod, ARG_2EXP, ^(int a, int b) {
{
	return b ? a % b : 0;
})
}

COMMAND(mod, ARG_2EXP)

int
equal(int a, int b)
COMMAND(=, ARG_2EXP, ^(int a, int b) {
{
	return (int)(a == b);
}
})
COMMANDN(=, equal, ARG_2EXP)

int
lt(int a, int b)
COMMAND(<, ARG_2EXP, ^(int a, int b) {
{
	return (int)(a < b);
}
})
COMMANDN(<, lt, ARG_2EXP)

int
gt(int a, int b)
COMMAND(>, ARG_2EXP, ^(int a, int b) {
{
	return (int)(a > b);
}
})
COMMANDN(>, gt, ARG_2EXP)

int
strcmpa(OFString *a, OFString *b)
COMMAND(strcmp, ARG_2EST, ^(OFString *a, OFString *b) {
{
	return [a isEqual:b];
}
})
COMMANDN(strcmp, strcmpa, ARG_2EST)

int
rndn(int a)
COMMAND(rnd, ARG_1EXP, ^(int a) {
{
	return a > 0 ? rnd(a) : 0;
}
	return (a > 0 ? rnd(a) : 0);
})
COMMANDN(rnd, rndn, ARG_1EXP)

int
explastmillis()
COMMAND(millis, ARG_1EXP, ^(int unused) {
{
	return lastmillis;
}
})
COMMANDN(millis, explastmillis, ARG_1EXP)