server/src/kernel/order.c
2019-09-13 21:35:44 +02:00

644 lines
15 KiB
C

#ifdef _MSC_VER
#include <platform.h>
#endif
#include <kernel/config.h>
#include "order.h"
#include "db/driver.h"
#include "skill.h"
#include <util/base36.h>
#include "util/keyword.h"
#include <util/language.h>
#include <util/log.h>
#include <util/param.h>
#include <util/parser.h>
#include <util/strings.h>
#include <stream.h>
/* libc includes */
#include <assert.h>
#include <ctype.h>
#include <stdarg.h>
#include <stdlib.h>
#include <string.h>
# define ORD_KEYWORD(ord) (keyword_t)((ord)->command & 0xFFFF)
# define OD_STRING(odata) ((odata) ? (odata)->_str : NULL)
order_data *odata_load(int id)
{
if (id > 0) {
return db_driver_order_load(id);
}
return NULL;
}
int odata_save(order_data *od)
{
if (od->_str) {
return db_driver_order_save(od->_str);
}
return 0;
}
void odata_create(order_data **pdata, size_t len, const char *str)
{
order_data *data;
char *result;
assert(pdata);
data = malloc(sizeof(order_data) + len + 1);
if (!data) abort();
data->_refcount = 1;
result = (char *)(data + 1);
data->_str = (len > 0) ? result : NULL;
if (str) {
strcpy(result, str);
}
*pdata = data;
}
void odata_release(order_data * od)
{
if (od) {
if (--od->_refcount == 0) {
free(od);
}
}
}
void odata_addref(order_data *od)
{
++od->_refcount;
}
void replace_order(order ** dlist, order * orig, const order * src)
{
assert(src);
assert(orig);
assert(dlist);
while (*dlist != NULL) {
order *dst = *dlist;
if (dst->id == orig->id) {
order *cpy = copy_order(src);
*dlist = cpy;
cpy->next = dst->next;
dst->next = 0;
free_order(dst);
}
dlist = &(*dlist)->next;
}
}
keyword_t getkeyword(const order * ord)
{
if (ord == NULL) {
return NOKEYWORD;
}
return ORD_KEYWORD(ord);
}
/** returns a plain-text representation of the order.
* This is the inverse function to the parse_order command. Note that
* keywords are expanded to their full length.
*/
char* get_command(const order *ord, const struct locale *lang, char *sbuffer, size_t size) {
keyword_t kwd = ORD_KEYWORD(ord);
sbstring sbs;
sbs_init(&sbs, sbuffer, size);
if (ord->command & CMD_QUIET) {
sbs_strcat(&sbs, "!");
}
if (ord->command & CMD_PERSIST) {
sbs_strcat(&sbs, "@");
}
if (kwd != NOKEYWORD) {
const char *str = (const char *)LOC(lang, keyword(kwd));
assert(str);
sbs_strcat(&sbs, str);
if (ord->id < 0) {
skill_t sk = (skill_t)(100+ord->id);
assert((kwd == K_STUDY || kwd == K_AUTOSTUDY) && sk != SK_MAGIC && sk < MAXSKILLS);
str = skillname(sk, lang);
if (str) {
if (strchr(str, ' ') == NULL) {
sbs_strcat(&sbs, " ");
sbs_strcat(&sbs, str);
}
else {
sbs_strcat(&sbs, " '");
sbs_strcat(&sbs, str);
sbs_strcat(&sbs, "'");
}
}
} else {
order_data *od = odata_load(ord->id);
str = OD_STRING(od);
if (str) {
sbs_strcat(&sbs, " ");
sbs_strcat(&sbs, str);
}
odata_release(od);
}
}
return sbuffer;
}
const char *crescape(const char *str, char *buffer, size_t size) {
const char *replace = "\"\\";
const char * pos = strpbrk(str, replace);
if (!pos) {
return str;
}
return str_escape_ex(str, buffer, size, replace);
}
int stream_order(struct stream *out, const struct order *ord, const struct locale *lang, bool escape)
{
const char *text;
keyword_t kwd = ORD_KEYWORD(ord);
if (ord->command & CMD_QUIET) {
swrite("!", 1, 1, out);
}
if (ord->command & CMD_PERSIST) {
swrite("@", 1, 1, out);
}
if (kwd != NOKEYWORD) {
const char *str = (const char *)LOC(lang, keyword(kwd));
assert(str);
swrite(str, 1, strlen(str), out);
}
if (ord->id < 0) {
skill_t sk = (skill_t)(100 + ord->id);
assert(kwd == K_AUTOSTUDY || kwd == K_STUDY);
assert(sk != SK_MAGIC && sk < MAXSKILLS);
text = skillname(sk, lang);
if (strchr(text, ' ') != NULL) {
swrite(" '", 1, 2, out);
swrite(text, 1, strlen(text), out);
swrite("'", 1, 1, out);
}
else {
swrite(" ", 1, 1, out);
swrite(text, 1, strlen(text), out);
}
}
else {
order_data *od = odata_load(ord->id);
text = OD_STRING(od);
if (text) {
char obuf[1024];
swrite(" ", 1, 1, out);
if (escape) {
text = crescape(text, obuf, sizeof(obuf));
}
swrite(text, 1, strlen(text), out);
}
odata_release(od);
}
return 0;
}
void free_order(order * ord)
{
if (ord != NULL) {
assert(ord->next == 0);
free(ord);
}
}
order *copy_order(const order * src)
{
if (src != NULL) {
order *ord = (order *)malloc(sizeof(order));
if (!ord) abort();
ord->next = NULL;
ord->command = src->command;
ord->id = src->id;
return ord;
}
return NULL;
}
void set_order(struct order **destp, struct order *src)
{
if (*destp == src)
return;
free_order(*destp);
*destp = src;
}
void free_orders(order ** olist)
{
while (*olist) {
order *ord = *olist;
*olist = ord->next;
ord->next = NULL;
free_order(ord);
}
}
static int create_data(keyword_t kwd, const char *s,
const struct locale *lang)
{
order_data *data;
int id;
assert(kwd != NOKEYWORD);
if (!s || *s == 0) {
return 0;
}
if (kwd == K_STUDY || kwd == K_AUTOSTUDY) {
const char * sptr = s;
skill_t sk = get_skill(parse_token_depr(&sptr), lang);
if (sk != SK_MAGIC && sk != NOSKILL) {
return ((int)sk)-100;
}
}
/* TODO: between mkdata and odata_release, this object is very
* short-lived. */
odata_create(&data, strlen(s), s);
id = odata_save(data);
odata_release(data);
return id;
}
static void create_order_i(order *ord, keyword_t kwd, const char *sptr, bool persistent,
bool noerror, const struct locale *lang)
{
assert(ord);
assert(kwd != NOKEYWORD && !keyword_disabled(kwd));
ord->command = (int)kwd;
if (persistent) ord->command |= CMD_PERSIST;
if (noerror) ord->command |= CMD_QUIET;
ord->next = NULL;
while (isspace(*(unsigned char *)sptr)) ++sptr;
ord->id = create_data(kwd, sptr, lang);
}
order *create_order(keyword_t kwd, const struct locale * lang,
const char *params, ...)
{
order *ord;
char zBuffer[DISPLAYSIZE];
if (params) {
sbstring sbs;
va_list marker;
char *tok;
assert(lang);
va_start(marker, params);
sbs_init(&sbs, zBuffer, sizeof(zBuffer));
while (*params) {
tok = strchr(params, '%');
if (tok) {
const char *s;
int i;
if (tok != params) {
sbs_strncat(&sbs, params, tok - params);
}
switch (tok[1]) {
case 's':
s = va_arg(marker, const char *);
assert(s);
sbs_strcat(&sbs, s);
break;
case 'd':
i = va_arg(marker, int);
sbs_strcat(&sbs, itoa10(i));
break;
case 'i':
i = va_arg(marker, int);
sbs_strcat(&sbs, itoa36(i));
break;
default:
assert(!"unknown format-character in create_order");
}
params = tok + 2;
}
else {
sbs_strcat(&sbs, params);
break;
}
}
va_end(marker);
}
else {
zBuffer[0] = 0;
}
ord = (order *)malloc(sizeof(order));
create_order_i(ord, kwd, zBuffer, false, false, lang);
return ord;
}
order *parse_order(const char *s, const struct locale * lang)
{
assert(lang);
assert(s);
if (*s != 0) {
char token[32];
keyword_t kwd = NOKEYWORD;
const char *sptr = s;
bool persistent = false, noerror = false;
char * p;
p = parse_token(&sptr, token, sizeof(token));
if (p) {
while (*p == '!' || *p == '@') {
if (*p == '!') noerror = true;
else if (*p == '@') persistent = true;
++p;
}
kwd = get_keyword(p, lang);
}
if (kwd == K_MAKE) {
const char *sp = sptr;
p = parse_token(&sp, token, sizeof(token));
if (p && isparam(p, lang, P_TEMP)) {
kwd = K_MAKETEMP;
sptr = sp;
}
}
else if (kwd == K_STUDY) {
const char *sp = sptr;
p = parse_token(&sp, token, sizeof(token));
if (p && isparam(p, lang, P_AUTO)) {
skill_t sk;
sptr = sp;
p = parse_token(&sp, token, sizeof(token));
sk = get_skill(p, lang);
if (sk == NOSKILL || !expensive_skill(sk)) {
kwd = K_AUTOSTUDY;
}
}
}
if (kwd != NOKEYWORD) {
order *ord = (order *)malloc(sizeof(order));
if (ord == NULL) abort();
create_order_i(ord, kwd, sptr, persistent, noerror, lang);
return ord;
}
}
return NULL;
}
/**
* Returns true if the order qualifies as "repeated". An order is repeated if it will overwrite the
* old default order. K_BUY is in this category, but not K_MOVE.
*
* \param ord An order.
* \return true if the order is long
* \sa is_exclusive(), is_repeated(), is_persistent()
*/
bool is_repeated(keyword_t kwd)
{
switch (kwd) {
case K_CAST:
case K_BUY:
case K_SELL:
case K_ROUTE:
case K_DRIVE:
case K_WORK:
case K_ENTERTAIN:
case K_TAX:
case K_RESEARCH:
case K_SPY:
case K_STEAL:
case K_SABOTAGE:
case K_STUDY:
case K_AUTOSTUDY:
case K_TEACH:
case K_GROW:
case K_PLANT:
case K_PIRACY:
case K_MAKE:
case K_LOOT:
case K_DESTROY:
return true;
default:
break;
}
return false;
}
/**
* Returns true if the order qualifies as "exclusive". An order is exclusive if it makes all other
* long orders illegal. K_MOVE is in this category, but not K_BUY.
*
* \param ord An order.
* \return true if the order is long
* \sa is_exclusive(), is_repeated(), is_persistent()
*/
bool is_exclusive(const order * ord)
{
keyword_t kwd = ORD_KEYWORD(ord);
switch (kwd) {
case K_MOVE:
case K_ROUTE:
case K_DRIVE:
case K_WORK:
case K_ENTERTAIN:
case K_TAX:
case K_RESEARCH:
case K_SPY:
case K_STEAL:
case K_SABOTAGE:
case K_STUDY:
case K_AUTOSTUDY:
case K_TEACH:
case K_GROW:
case K_PLANT:
case K_PIRACY:
case K_MAKE:
case K_LOOT:
case K_DESTROY:
return true;
default:
break;
}
return false;
}
/**
* Returns true if the order qualifies as "long". An order is long if it excludes most other long
* orders.
*
* \param ord An order.
* \return true if the order is long
* \sa is_exclusive(), is_repeated(), is_persistent()
*/
bool is_long(keyword_t kwd)
{
switch (kwd) {
case K_CAST:
case K_BUY:
case K_SELL:
case K_MOVE:
case K_ROUTE:
case K_DRIVE:
case K_WORK:
case K_ENTERTAIN:
case K_TAX:
case K_RESEARCH:
case K_SPY:
case K_STEAL:
case K_SABOTAGE:
case K_STUDY:
case K_AUTOSTUDY:
case K_TEACH:
case K_GROW:
case K_PLANT:
case K_PIRACY:
case K_MAKE:
case K_LOOT:
case K_DESTROY:
return true;
default:
break;
}
return false;
}
/**
* Returns true if the order qualifies as "persistent". An order is persistent if it will be
* included in the template orders. @-orders, comments and most long orders are in this category,
* but not K_MOVE.
*
* \param ord An order.
* \return true if the order is persistent
* \sa is_exclusive(), is_repeated(), is_persistent()
*/
bool is_persistent(const order * ord)
{
keyword_t kwd = ORD_KEYWORD(ord);
switch (kwd) {
case K_MOVE:
case NOKEYWORD:
/* lang, aber niemals persistent! */
return false;
case K_KOMMENTAR:
return true;
default:
return (ord->command & CMD_PERSIST) || is_repeated(kwd);
}
}
bool is_silent(const order * ord)
{
return (ord->command & CMD_QUIET) != 0;
}
char *write_order(const order * ord, const struct locale *lang, char *buffer, size_t size)
{
if (ord == 0) {
buffer[0] = 0;
}
else {
keyword_t kwd = ORD_KEYWORD(ord);
if (kwd == NOKEYWORD) {
order_data *od = odata_load(ord->id);
const char *text = OD_STRING(od);
if (text) str_strlcpy(buffer, (const char *)text, size);
else buffer[0] = 0;
odata_release(od);
}
else {
get_command(ord, lang, buffer, size);
}
}
return buffer;
}
void push_order(order ** ordp, order * ord)
{
while (*ordp)
ordp = &(*ordp)->next;
*ordp = ord;
}
static order_data *parser_od;
keyword_t init_order(const struct order *ord, const struct locale *lang)
{
if (!ord) {
odata_release(parser_od);
parser_od = NULL;
return NOKEYWORD;
}
else {
keyword_t kwd = ORD_KEYWORD(ord);
if (parser_od) {
/* TODO: warning */
odata_release(parser_od);
parser_od = NULL;
}
if (ord->id < 0) {
const char *str;
skill_t sk = (skill_t)(100 + ord->id);
assert(sk < MAXSKILLS);
assert(lang);
assert(kwd == K_STUDY || kwd == K_AUTOSTUDY);
str = skillname(sk, lang);
if (strchr(str, ' ') == NULL) {
init_tokens_str(str);
}
else {
char token[32], *dup;
size_t len = strlen(str);
assert(len + 3 < sizeof(token));
token[0] = '\'';
memcpy(token + 1, str, len);
token[len + 1] = '\'';
token[len + 2] = '\0';
dup = str_strdup(token);
init_tokens_ex(dup, dup, free);
}
}
else {
const char *str;
parser_od = odata_load(ord->id);
if (parser_od) {
odata_addref(parser_od);
}
str = OD_STRING(parser_od);
init_tokens_ex(str, parser_od, (void(*)(void *))odata_release);
}
return kwd;
}
}
keyword_t init_order_depr(const struct order *ord)
{
if (ord) {
keyword_t kwd = ORD_KEYWORD(ord);
assert(kwd != K_STUDY && kwd != K_AUTOSTUDY);
}
return init_order(ord, NULL);
}
void close_orders(void) {
if (parser_od) {
(void)init_order(NULL, NULL);
}
}