return ret;
}
-static char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, int full)
{
if (params->w < 2 || params->h < 2)
return "Width and height must both be at least two";
return ret;
}
-static char *validate_desc(const game_params *params, const char *desc)
+static const char *validate_desc(const game_params *params, const char *desc)
{
int nballs, dlen = strlen(desc), i;
unsigned char *bmp;
}
static char *solve_game(const game_state *state, const game_state *currstate,
- const char *aux, char **error)
+ const char *aux, const char **error)
{
return dupstr("S");
}
return ret;
}
-static char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, int full)
{
if (params->w < 3 || params->h < 3)
return "Width and height must be at least 3";
return ret;
}
-static char *validate_desc(const game_params *params, const char *desc)
+static const char *validate_desc(const game_params *params, const char *desc)
{
int i, wh = params->w * params->h;
}
static char *solve_game(const game_state *state, const game_state *currstate,
- const char *aux, char **error)
+ const char *aux, const char **error)
{
char *ret;
game_state *solved;
classes[thisclass]++;
}
-static char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, int full)
{
int classes[5];
int i;
return ret;
}
-static char *validate_desc(const game_params *params, const char *desc)
+static const char *validate_desc(const game_params *params, const char *desc)
{
int area = grid_area(params->d1, params->d2, solids[params->solid]->order);
int i, j;
}
static char *solve_game(const game_state *state, const game_state *currstate,
- const char *aux, char **error)
+ const char *aux, const char **error)
{
return NULL;
}
\S{backend-validate-params} \cw{validate_params()}
-\c char *(*validate_params)(const game_params *params, int full);
+\c const char *(*validate_params)(const game_params *params,
+\c int full);
This function takes a \c{game_params} structure as input, and checks
that the parameters described in it fall within sensible limits. (At
\S{backend-validate-desc} \cw{validate_desc()}
-\c char *(*validate_desc)(const game_params *params, const char *desc);
+\c const char *(*validate_desc)(const game_params *params,
+\c const char *desc);
This function is given a game description, and its job is to
validate that it describes a puzzle which makes sense.
\S{backend-solve} \cw{solve()}
\c char *(*solve)(const game_state *orig, const game_state *curr,
-\c const char *aux, char **error);
+\c const char *aux, const char **error);
This function is called when the user selects the \q{Solve} option
from the menu.
\H{midend-set-config} \cw{midend_set_config()}
-\c char *midend_set_config(midend *me, int which,
-\c config_item *cfg);
+\c const char *midend_set_config(midend *me, int which,
+\c config_item *cfg);
Passes the mid-end the results of a configuration dialog box.
\c{which} should have the same value which it had when
\H{midend-game-id} \cw{midend_game_id()}
-\c char *midend_game_id(midend *me, char *id);
+\c const char *midend_game_id(midend *me, char *id);
Passes the mid-end a string game ID (of any of the valid forms
\cq{params}, \cq{params:description} or \cq{params#seed}) which the
\H{midend-solve} \cw{midend_solve()}
-\c char *midend_solve(midend *me);
+\c const char *midend_solve(midend *me);
Requests the mid-end to perform a Solve operation.
\H{midend-deserialise} \cw{midend_deserialise()}
-\c char *midend_deserialise(midend *me,
-\c int (*read)(void *ctx, void *buf, int len),
-\c void *rctx);
+\c const char *midend_deserialise(midend *me,
+\c int (*read)(void *ctx, void *buf, int len), void *rctx);
This function is the counterpart to \cw{midend_serialise()}. It
calls the supplied \cw{read} function repeatedly to read a quantity
\H{identify-game} \cw{identify_game()}
-\c char *identify_game(char **name,
-\c int (*read)(void *ctx, void *buf, int len),
-\c void *rctx);
+\c const char *identify_game(char **name,
+\c int (*read)(void *ctx, void *buf, int len), void *rctx);
This function examines a serialised midend stream, of the same kind
used by \cw{midend_serialise()} and \cw{midend_deserialise()}, and
return ret;
}
-static char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, int full)
{
if (params->n < 1)
return "Maximum face number must be at least one";
return ret;
}
-static char *validate_desc(const game_params *params, const char *desc)
+static const char *validate_desc(const game_params *params, const char *desc)
{
int n = params->n, w = n+2, h = n+1, wh = w*h;
int *occurrences;
}
static char *solve_game(const game_state *state, const game_state *currstate,
- const char *aux, char **error)
+ const char *aux, const char **error)
{
int n = state->params.n, w = n+2, h = n+1, wh = w*h;
int *placements;
/*
* User hit OK.
*/
- char *err = midend_set_config(me, cfg_which, cfg);
+ const char *err = midend_set_config(me, cfg_which, cfg);
if (err) {
/*
break;
case 9: /* Solve */
if (thegame.can_solve) {
- char *msg = midend_solve(me);
+ const char *msg = midend_solve(me);
if (msg)
js_error_box(msg);
}
*/
int main(int argc, char **argv)
{
- char *param_err;
+ const char *param_err;
float *colours;
int i;
return ret;
}
-static char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, int full)
{
if (params->w < 2 || params->h < 2)
return "Width and height must both be at least two";
return ret;
}
-static char *validate_desc(const game_params *params, const char *desc)
+static const char *validate_desc(const game_params *params, const char *desc)
{
const char *p;
char *err;
}
static char *solve_game(const game_state *state, const game_state *currstate,
- const char *aux, char **error)
+ const char *aux, const char **error)
{
return dupstr("S");
}
{
game_params *params;
game_state *state;
- char *id = NULL, *desc, *err;
+ char *id = NULL, *desc;
+ const char *err;
int grade = FALSE;
char *progname = argv[0];
return ret;
}
-static char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, int full)
{
if (params->w < 1) return "Width must be at least one";
if (params->h < 1) return "Height must be at least one";
return sresize(description, j, char);
}
-static char *validate_desc(const game_params *params, const char *desc)
+static const char *validate_desc(const game_params *params, const char *desc)
{
const int sz = params->w * params->h;
const char m = '0' + max(max(params->w, params->h), 3);
}
static char *solve_game(const game_state *state, const game_state *currstate,
- const char *aux, char **error)
+ const char *aux, const char **error)
{
if (aux == NULL) {
const int w = state->shared->params.w;
return ret;
}
-static char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, int full)
{
if (params->w <= 0 || params->h <= 0)
return "Width and height must both be greater than zero";
return ret;
}
-static char *validate_desc(const game_params *params, const char *desc)
+static const char *validate_desc(const game_params *params, const char *desc)
{
int w = params->w, h = params->h, wh = w * h;
int mlen = (wh*wh+3)/4, glen = (wh+3)/4;
}
static char *solve_game(const game_state *state, const game_state *currstate,
- const char *aux, char **error)
+ const char *aux, const char **error)
{
int w = state->w, h = state->h, wh = w * h;
unsigned char *equations, *solution, *shortest;
return ret;
}
-static char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, int full)
{
if (params->w < 2 && params->h < 2)
return "Grid must contain at least two squares";
return desc;
}
-static char *validate_desc(const game_params *params, const char *desc)
+static const char *validate_desc(const game_params *params, const char *desc)
{
int w = params->w, h = params->h, wh = w*h;
int i;
}
static char *solve_game(const game_state *state, const game_state *currstate,
- const char *aux, char **error)
+ const char *aux, const char **error)
{
int w = state->w, h = state->h, wh = w*h;
char *moves, *ret, *p;
return ret;
}
-static char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, int full)
{
if (params->w < 3 || params->h < 3)
return "Width and height must both be at least 3";
return NULL;
}
-static char *validate_desc(const game_params *params, const char *desc)
+static const char *validate_desc(const game_params *params, const char *desc)
{
char *why = NULL;
game_state *dummy = load_game(params, desc, &why);
#ifndef EDITOR
static char *solve_game(const game_state *state, const game_state *currstate,
- const char *aux, char **error)
+ const char *aux, const char **error)
{
game_state *tosolve;
char *ret;
int main(int argc, char **argv)
{
game_params *p;
- char *id = NULL, *desc, *err;
+ char *id = NULL, *desc;
+ const char *err;
game_state *s;
int diff, do_soak = 0, verbose = 0;
random_state *rs;
}
#if GTK_CHECK_VERSION(3,0,0)
-int message_box(GtkWidget *parent, char *title, char *msg, int centre,
- int type)
+int message_box(GtkWidget *parent, const char *title, const char *msg,
+ int centre, int type)
{
GtkWidget *window;
gint ret;
}
#endif /* GTK_CHECK_VERSION(3,0,0) */
-void error_box(GtkWidget *parent, char *msg)
+void error_box(GtkWidget *parent, const char *msg)
{
message_box(parent, "Error", msg, FALSE, MB_OK);
}
static void config_ok_button_clicked(GtkButton *button, gpointer data)
{
frontend *fe = (frontend *)data;
- char *err;
+ const char *err;
err = midend_set_config(fe->me, fe->cfg_which, fe->cfg);
static void menu_load_event(GtkMenuItem *menuitem, gpointer data)
{
frontend *fe = (frontend *)data;
- char *name, *err;
+ char *name;
+ const char *err;
name = file_selector(fe, "Enter name of saved game file to load", FALSE);
static void menu_solve_event(GtkMenuItem *menuitem, gpointer data)
{
frontend *fe = (frontend *)data;
- char *msg;
+ const char *msg;
msg = midend_solve(fe->me);
fe->me = midend_new(fe, &thegame, >k_drawing, fe);
if (arg) {
- char *err;
+ const char *err;
FILE *fp;
errbuf[0] = '\0';
* generated descriptive game IDs.)
*/
while (ngenerate == 0 || i < n) {
- char *pstr, *err, *seed;
+ char *pstr, *seed;
+ const char *err;
struct rusage before, after;
if (ngenerate == 0) {
* re-entering the same game id, and then try to solve
* it.
*/
- char *game_id, *err;
+ char *game_id;
game_id = midend_get_game_id(me);
err = midend_game_id(me, game_id);
sprintf(realname, "%s%d%s", savefile, i, savesuffix);
if (soln) {
- char *err = midend_solve(me);
+ const char *err = midend_solve(me);
if (err) {
fprintf(stderr, "%s: unable to show solution: %s\n",
realname, err);
return ret;
}
-static char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, int full)
{
if (params->ncolours < 2 || params->npegs < 2)
return "Trivial solutions are uninteresting";
return ret;
}
-static char *validate_desc(const game_params *params, const char *desc)
+static const char *validate_desc(const game_params *params, const char *desc)
{
unsigned char *bmp;
int i;
}
static char *solve_game(const game_state *state, const game_state *currstate,
- const char *aux, char **error)
+ const char *aux, const char **error)
{
return dupstr("S");
}
return ret;
}
-static char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, int full)
{
/*
* Avoid completely degenerate cases which only have one
return gengrid(params->w, params->h, rs);
}
-static char *validate_desc(const game_params *params, const char *desc)
+static const char *validate_desc(const game_params *params, const char *desc)
{
int w = params->w, h = params->h, wh = w*h;
int starts = 0, gems = 0, i;
}
static char *solve_game(const game_state *state, const game_state *currstate,
- const char *aux, char **error)
+ const char *aux, const char **error)
{
int w = currstate->p.w, h = currstate->p.h, wh = w*h;
int *nodes, *nodeindex, *edges, *backedges, *edgei, *backedgei, *circuit;
assert(ret->solnpos < ret->soln->len); /* or gems == 0 */
assert(!ret->dead); /* or not a solution */
} else {
- char *error = NULL, *soln = solve_game(NULL, ret, NULL, &error);
+ const char *error = NULL;
+ char *soln = solve_game(NULL, ret, NULL, &error);
if (!error) {
install_new_solution(ret, soln);
sfree(soln);
return ret;
}
-static char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, int full)
{
if (params->w < 3 || params->w > 9)
return "Grid size must be between 3 and 9";
* Gameplay.
*/
-static char *validate_desc(const game_params *params, const char *desc)
+static const char *validate_desc(const game_params *params, const char *desc)
{
int w = params->w, a = w*w;
int *dsf;
}
static char *solve_game(const game_state *state, const game_state *currstate,
- const char *aux, char **error)
+ const char *aux, const char **error)
{
int w = state->par.w, a = w*w;
int i, ret;
{
game_params *p;
game_state *s;
- char *id = NULL, *desc, *err;
+ char *id = NULL, *desc;
+ const char *err;
int grade = FALSE;
int ret, diff, really_show_working = FALSE;
return ret;
}
-static char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, int full)
{
if (params->w < 2 || params->h < 2)
return "Width and height must be at least 2";
return ret;
}
-static char *validate_desc(const game_params *params, const char *desc)
+static const char *validate_desc(const game_params *params, const char *desc)
{
int i;
for (i = 0; i < params->w*params->h; i++) {
}
static char *solve_game(const game_state *state, const game_state *currstate,
- const char *aux, char **error)
+ const char *aux, const char **error)
{
game_state *solved;
char *move = NULL, buf[80];
{
game_params *p;
game_state *s;
- char *id = NULL, *desc, *err, *result;
+ char *id = NULL, *desc, *result;
+ const char *err;
int nsol, diff, really_verbose = 0;
unsigned int sflags;
char *clue_satisfied;
};
-static char *validate_desc(const game_params *params, const char *desc);
+static const char *validate_desc(const game_params *params, const char *desc);
static int dot_order(const game_state* state, int i, char line_type);
static int face_order(const game_state* state, int i, char line_type);
static solver_state *solve_game_rec(const solver_state *sstate);
return ret;
}
-static char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, int full)
{
if (params->type < 0 || params->type >= NUM_GRID_TYPES)
return "Illegal grid type";
/* We require that the params pass the test in validate_params and that the
* description fills the entire game area */
-static char *validate_desc(const game_params *params, const char *desc)
+static const char *validate_desc(const game_params *params, const char *desc)
{
int count = 0;
grid *g;
}
static char *solve_game(const game_state *state, const game_state *currstate,
- const char *aux, char **error)
+ const char *aux, const char **error)
{
char *soln = NULL;
solver_state *sstate, *new_sstate;
{
game_params *p;
game_state *s;
- char *id = NULL, *desc, *err;
+ char *id = NULL, *desc;
+ const char *err;
int grade = FALSE;
int ret, diff;
#if 0 /* verbose solver not supported here (yet) */
return ret;
}
-static char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, int full)
{
if (params->w < 2) return "Width must be at least one";
if (params->h < 2) return "Height must be at least one";
return state;
}
-static char *validate_desc(const game_params *params, const char *desc)
+static const char *validate_desc(const game_params *params, const char *desc)
{
const char *prob;
game_state *st = new_game_int(params, desc, &prob);
}
static char *solve_game(const game_state *state, const game_state *currstate,
- const char *aux, char **error)
+ const char *aux, const char **error)
{
game_state *solved = dup_game(currstate);
char *move = NULL;
int main(int argc, const char *argv[])
{
int print = 0, soak = 0, solved = 0, ret;
- char *id = NULL, *desc, *desc_gen = NULL, *err, *aux = NULL;
+ char *id = NULL, *desc, *desc_gen = NULL, *aux = NULL;
+ const char *err;
game_state *s = NULL;
game_params *p = NULL;
random_state *rs = NULL;
return ret;
}
-static char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, int full)
{
if (params->w < 2 || params->h < 2)
return "Width and height must be at least two";
return NULL;
}
-static char *validate_desc(const game_params *params, const char *desc)
+static const char *validate_desc(const game_params *params, const char *desc)
{
int w = params->w, h = params->h, wh = w*h, n = params->n;
int area;
}
static char *solve_game(const game_state *state, const game_state *currstate,
- const char *aux, char **error)
+ const char *aux, const char **error)
{
if (!aux) {
/*
{
game_params *p;
game_state *s;
- char *id = NULL, *desc, *err;
+ char *id = NULL, *desc;
+ const char *err;
int grade = FALSE;
int ret, diff, really_verbose = FALSE;
struct solver_scratch *sc;
/*
* Forward reference.
*/
-static char *midend_deserialise_internal(
+static const char *midend_deserialise_internal(
midend *me, int (*read)(void *ctx, void *buf, int len), void *rctx,
char *(*check)(void *ctx, midend *, const struct deserialise_data *),
void *cctx);
*/
if (me->ourgame->can_solve && me->aux_info) {
game_state *s;
- char *msg, *movestr;
+ const char *msg;
+ char *movestr;
msg = NULL;
movestr = me->ourgame->solve(me->states[0].state,
static int midend_undo(midend *me)
{
- char *deserialise_error;
+ const char *deserialise_error;
if (me->statepos > 1) {
if (me->ui)
return NULL;
}
-static char *midend_game_id_int(midend *me, char *id, int defmode)
+static const char *midend_game_id_int(midend *me, char *id, int defmode)
{
- char *error, *par, *desc, *seed;
+ const char *error;
+ char *par, *desc, *seed;
game_params *newcurparams, *newparams, *oldparams1, *oldparams2;
int free_params;
return NULL;
}
-char *midend_game_id(midend *me, char *id)
+const char *midend_game_id(midend *me, char *id)
{
return midend_game_id_int(me, id, DEF_PARAMS);
}
return ret;
}
-char *midend_set_config(midend *me, int which, config_item *cfg)
+const char *midend_set_config(midend *me, int which, config_item *cfg)
{
- char *error;
+ const char *error;
game_params *params;
switch (which) {
return NULL;
}
-char *midend_solve(midend *me)
+const char *midend_solve(midend *me)
{
game_state *s;
- char *msg, *movestr;
+ const char *msg;
+ char *movestr;
if (!me->ourgame->can_solve)
return "This game does not support the Solve operation";
* Like midend_deserialise proper, this function returns NULL on
* success, or an error message.
*/
-static char *midend_deserialise_internal(
+static const char *midend_deserialise_internal(
midend *me, int (*read)(void *ctx, void *buf, int len), void *rctx,
char *(*check)(void *ctx, midend *, const struct deserialise_data *data),
void *cctx)
return ret;
}
-char *midend_deserialise(
+const char *midend_deserialise(
midend *me, int (*read)(void *ctx, void *buf, int len), void *rctx)
{
return midend_deserialise_internal(me, read, rctx, NULL, NULL);
* allocated and should be caller-freed), or an error message on
* failure.
*/
-char *identify_game(char **name, int (*read)(void *ctx, void *buf, int len),
- void *rctx)
+const char *identify_game(char **name,
+ int (*read)(void *ctx, void *buf, int len),
+ void *rctx)
{
int nstates = 0, statepos = -1, gotstates = 0;
int started = FALSE;
return ret;
}
-char *midend_print_puzzle(midend *me, document *doc, int with_soln)
+const char *midend_print_puzzle(midend *me, document *doc, int with_soln)
{
game_state *soln = NULL;
return "No game set up to print";/* _shouldn't_ happen! */
if (with_soln) {
- char *msg, *movestr;
+ const char *msg;
+ char *movestr;
if (!me->ourgame->can_solve)
return "This game does not support the Solve operation";
return ret;
}
-static char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, int full)
{
/*
* Lower limit on grid size: each dimension must be at least 3.
}
}
-static char *validate_desc(const game_params *params, const char *desc)
+static const char *validate_desc(const game_params *params, const char *desc)
{
int wh = params->w * params->h;
int x, y;
}
static char *solve_game(const game_state *state, const game_state *currstate,
- const char *aux, char **error)
+ const char *aux, const char **error)
{
if (!state->layout->mines) {
*error = "Game has not been started yet";
{
game_params *p;
game_state *s;
- char *id = NULL, *desc, *err;
+ char *id = NULL, *desc;
+ const char *err;
int y, x;
while (--argc > 0) {
void jcallback_config_ok()
{
frontend *fe = (frontend *)_fe;
- char *err;
+ const char *err;
err = midend_set_config(fe->me, fe->cfg_which, fe->cfg);
int jcallback_solve_event()
{
frontend *fe = (frontend *)_fe;
- char *msg;
+ const char *msg;
msg = midend_solve(fe->me);
return ret;
}
-static char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, int full)
{
if (params->width <= 0 || params->height <= 0)
return "Width and height must both be greater than zero";
return desc;
}
-static char *validate_desc(const game_params *params, const char *desc)
+static const char *validate_desc(const game_params *params, const char *desc)
{
int w = params->width, h = params->height;
int i;
}
static char *solve_game(const game_state *state, const game_state *currstate,
- const char *aux, char **error)
+ const char *aux, const char **error)
{
unsigned char *tiles;
char *ret;
return ret;
}
-static char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, int full)
{
if (params->width <= 1 || params->height <= 1)
return "Width and height must both be greater than one";
return desc;
}
-static char *validate_desc(const game_params *params, const char *desc)
+static const char *validate_desc(const game_params *params, const char *desc)
{
int w = params->width, h = params->height;
int i;
}
static char *solve_game(const game_state *state, const game_state *currstate,
- const char *aux, char **error)
+ const char *aux, const char **error)
{
if (!aux) {
*error = "Solution not known for this puzzle";
return NULL;
}
-static char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, int full)
{
return NULL;
}
return dupstr("FIXME");
}
-static char *validate_desc(const game_params *params, const char *desc)
+static const char *validate_desc(const game_params *params, const char *desc)
{
return NULL;
}
}
static char *solve_game(const game_state *state, const game_state *currstate,
- const char *aux, char **error)
+ const char *aux, const char **error)
{
return NULL;
}
const char *name = [[[op filenames] objectAtIndex:0]
cStringUsingEncoding:
[NSString defaultCStringEncoding]];
- char *err;
+ const char *err;
FILE *fp = fopen(name, "r");
- (void)solveGame:(id)sender
{
- char *msg;
+ const char *msg;
msg = midend_solve(me);
* +---+ the dominos is horizontal or vertical. +---+---+
*/
-static char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, int full)
{
int w = params->w, h = params->h, k = params->k, wh = w * h;
return sresize(numbers, p - numbers, clue);
}
-static char *validate_desc(const game_params *params, const char *desc)
+static const char *validate_desc(const game_params *params, const char *desc)
{
int w = params->w, h = params->h, wh = w*h, squares = 0;
}
static char *solve_game(const game_state *state, const game_state *currstate,
- const char *aux, char **error)
+ const char *aux, const char **error)
{
int w = state->shared->params.w, h = state->shared->params.h, wh = w*h;
borderflag *move;
return ret;
}
-static char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, int full)
{
if (params->w <= 0 || params->h <= 0)
return "Width and height must both be greater than zero";
return desc;
}
-static char *validate_desc(const game_params *params, const char *desc)
+static const char *validate_desc(const game_params *params, const char *desc)
{
int i, n, rowspace;
const char *p;
}
static char *solve_game(const game_state *state, const game_state *currstate,
- const char *ai, char **error)
+ const char *ai, const char **error)
{
unsigned char *matrix;
int w = state->common->w, h = state->common->h;
{
game_params *p;
game_state *s;
- char *id = NULL, *desc, *err;
+ char *id = NULL, *desc;
+ const char *err;
while (--argc > 0) {
char *p = *++argv;
return ret;
}
-static char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, int full)
{
if (params->w < 5) return "Width must be at least five";
if (params->h < 5) return "Height must be at least five";
return desc;
}
-static char *validate_desc(const game_params *params, const char *desc)
+static const char *validate_desc(const game_params *params, const char *desc)
{
int i, sizesofar;
const int totalsize = params->w * params->h;
}
static char *solve_game(const game_state *state, const game_state *currstate,
- const char *aux, char **error)
+ const char *aux, const char **error)
{
game_state *solved = dup_game(state);
int i, ret, sz = state->shared->sz;
game_params *p = NULL;
random_state *rs = NULL;
time_t seed = time(NULL);
- char *id = NULL, *err;
+ char *id = NULL;
+ const char *err;
setvbuf(stdout, NULL, _IONBF, 0);
return ret;
}
-static char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, int full)
{
if (full && (params->w <= 3 || params->h <= 3))
return "Width and height must both be greater than three";
return ret;
}
-static char *validate_desc(const game_params *params, const char *desc)
+static const char *validate_desc(const game_params *params, const char *desc)
{
int len = params->w * params->h;
}
static char *solve_game(const game_state *state, const game_state *currstate,
- const char *aux, char **error)
+ const char *aux, const char **error)
{
return NULL;
}
int midend_wants_statusbar(midend *me);
enum { CFG_SETTINGS, CFG_SEED, CFG_DESC, CFG_FRONTEND_SPECIFIC };
config_item *midend_get_config(midend *me, int which, char **wintitle);
-char *midend_set_config(midend *me, int which, config_item *cfg);
-char *midend_game_id(midend *me, char *id);
+const char *midend_set_config(midend *me, int which, config_item *cfg);
+const char *midend_game_id(midend *me, char *id);
char *midend_get_game_id(midend *me);
char *midend_get_random_seed(midend *me);
int midend_can_format_as_text_now(midend *me);
char *midend_text_format(midend *me);
-char *midend_solve(midend *me);
+const char *midend_solve(midend *me);
int midend_status(midend *me);
int midend_can_undo(midend *me);
int midend_can_redo(midend *me);
void midend_serialise(midend *me,
void (*write)(void *ctx, void *buf, int len),
void *wctx);
-char *midend_deserialise(midend *me,
- int (*read)(void *ctx, void *buf, int len),
- void *rctx);
-char *identify_game(char **name, int (*read)(void *ctx, void *buf, int len),
- void *rctx);
+const char *midend_deserialise(midend *me,
+ int (*read)(void *ctx, void *buf, int len),
+ void *rctx);
+const char *identify_game(char **name,
+ int (*read)(void *ctx, void *buf, int len),
+ void *rctx);
void midend_request_id_changes(midend *me, void (*notify)(void *), void *ctx);
/* Printing functions supplied by the mid-end */
-char *midend_print_puzzle(midend *me, document *doc, int with_soln);
+const char *midend_print_puzzle(midend *me, document *doc, int with_soln);
int midend_tilesize(midend *me);
/*
int can_configure;
config_item *(*configure)(const game_params *params);
game_params *(*custom_params)(const config_item *cfg);
- char *(*validate_params)(const game_params *params, int full);
+ const char *(*validate_params)(const game_params *params, int full);
char *(*new_desc)(const game_params *params, random_state *rs,
char **aux, int interactive);
- char *(*validate_desc)(const game_params *params, const char *desc);
+ const char *(*validate_desc)(const game_params *params, const char *desc);
game_state *(*new_game)(midend *me, const game_params *params,
const char *desc);
game_state *(*dup_game)(const game_state *state);
void (*free_game)(game_state *state);
int can_solve;
char *(*solve)(const game_state *orig, const game_state *curr,
- const char *aux, char **error);
+ const char *aux, const char **error);
int can_format_as_text_ever;
int (*can_format_as_text_now)(const game_params *params);
char *(*text_format)(const game_state *state);
static move *solve_internal(const game_state *state, move *base, int diff);
static char *solve_game(const game_state *orig, const game_state *curpos,
- const char *aux, char **error)
+ const char *aux, const char **error)
{
int const n = orig->params.w * orig->params.h;
move *const base = snewn(n, move);
return k;
}
-static char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, int full)
{
int const w = params->w, h = params->h;
if (w < 1) return "Error: width is less than 1";
return desc;
}
-static char *validate_desc(const game_params *params, const char *desc)
+static const char *validate_desc(const game_params *params, const char *desc)
{
int const n = params->w * params->h;
int squares = 0;
return ret;
}
-static char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, int full)
{
if (params->w <= 0 || params->h <= 0)
return "Width and height must both be greater than zero";
return desc;
}
-static char *validate_desc(const game_params *params, const char *desc)
+static const char *validate_desc(const game_params *params, const char *desc)
{
int area = params->w * params->h;
int squares = 0;
}
static char *solve_game(const game_state *state, const game_state *currstate,
- const char *ai, char **error)
+ const char *ai, const char **error)
{
unsigned char *vedge, *hedge;
int x, y, len;
return ret;
}
-static char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, int full)
{
if (params->w < 1 || params->h < 1)
return "Width and height must both be positive";
return ret;
}
-static char *validate_desc(const game_params *params, const char *desc)
+static const char *validate_desc(const game_params *params, const char *desc)
{
int area = params->w * params->h, i;
const char *p = desc;
}
static char *solve_game(const game_state *state, const game_state *currstate,
- const char *aux, char **error)
+ const char *aux, const char **error)
{
return NULL;
}
return ret;
}
-static char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, int full)
{
if (params->w < 1) return "Width must be at least one";
if (params->h < 1) return "Height must be at least one";
return ret;
}
-static char *validate_desc(const game_params *params, const char *desc)
+static const char *validate_desc(const game_params *params, const char *desc)
{
char *ret = NULL;
}
static char *solve_game(const game_state *state, const game_state *currstate,
- const char *aux, char **error)
+ const char *aux, const char **error)
{
game_state *tosolve;
char *ret = NULL;
if (move[0] == 'S') {
game_params p;
game_state *tmp;
- char *valid;
+ const char *valid;
int i;
p.w = state->w; p.h = state->h;
static void process_desc(char *id)
{
- char *desc, *err, *solvestr;
+ char *desc, *solvestr;
+ const char *err;
game_params *p;
game_state *s;
int main(int argc, const char *argv[])
{
- char *id = NULL, *desc, *err, *aux = NULL;
+ char *id = NULL, *desc, *aux = NULL;
+ const char *err;
int soak = 0, verbose = 0, stdin_desc = 0, n = 1, i;
char *seedstr = NULL, newseed[16];
return ret;
}
-static char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, int full)
{
if (params->w < 2 || params->h < 2)
return "Width and neight must be at least two";
}
static char *solve_game(const game_state *state, const game_state *currstate,
- const char *aux, char **error)
+ const char *aux, const char **error)
{
game_state *solved = dup_game(currstate);
char *move = NULL;
return ret;
}
-static char *validate_desc(const game_params *params, const char *desc)
+static const char *validate_desc(const game_params *params, const char *desc)
{
char *ret = NULL;
int main(int argc, char **argv)
{
- char *id = NULL, *desc, *desc_gen = NULL, *tgame, *err, *aux;
+ char *id = NULL, *desc, *desc_gen = NULL, *tgame, *aux;
+ const char *err;
game_state *s = NULL;
game_params *p = NULL;
int soln, soak = 0, ret = 1;
return ret;
}
-static char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, int full)
{
if (params->w < 2 || params->h < 2)
return "Width and height must both be at least two";
}
-static char *validate_desc(const game_params *params, const char *desc)
+static const char *validate_desc(const game_params *params, const char *desc)
{
const char *p;
char *err;
}
static char *solve_game(const game_state *state, const game_state *currstate,
- const char *aux, char **error)
+ const char *aux, const char **error)
{
return dupstr("S");
}
return ret;
}
-static char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, int full)
{
/*
* (At least at the time of writing this comment) The grid
return desc;
}
-static char *validate_desc(const game_params *params, const char *desc)
+static const char *validate_desc(const game_params *params, const char *desc)
{
int w = params->w, h = params->h, W = w+1, H = h+1;
int area = W*H;
}
static char *solve_game(const game_state *state, const game_state *currstate,
- const char *aux, char **error)
+ const char *aux, const char **error)
{
int w = state->p.w, h = state->p.h;
signed char *soln;
{
game_params *p;
game_state *s;
- char *id = NULL, *desc, *err;
+ char *id = NULL, *desc;
+ const char *err;
int grade = FALSE;
int ret, diff, really_verbose = FALSE;
struct solver_scratch *sc;
return ret;
}
-static char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, int full)
{
if (params->c < 2)
return "Both dimensions must be at least 2";
* end of the block spec, and return an error string or NULL if everything
* is OK. The DSF is stored in *PDSF.
*/
-static char *spec_to_dsf(const char **pdesc, int **pdsf, int cr, int area)
+static const char *spec_to_dsf(const char **pdesc, int **pdsf,
+ int cr, int area)
{
const char *desc = *pdesc;
int pos = 0;
return NULL;
}
-static char *validate_grid_desc(const char **pdesc, int range, int area)
+static const char *validate_grid_desc(const char **pdesc, int range, int area)
{
const char *desc = *pdesc;
int squares = 0;
return NULL;
}
-static char *validate_block_desc(const char **pdesc, int cr, int area,
- int min_nr_blocks, int max_nr_blocks,
- int min_nr_squares, int max_nr_squares)
+static const char *validate_block_desc(const char **pdesc, int cr, int area,
+ int min_nr_blocks, int max_nr_blocks,
+ int min_nr_squares, int max_nr_squares)
{
- char *err;
+ const char *err;
int *dsf;
err = spec_to_dsf(pdesc, &dsf, cr, area);
return NULL;
}
-static char *validate_desc(const game_params *params, const char *desc)
+static const char *validate_desc(const game_params *params, const char *desc)
{
int cr = params->c * params->r, area = cr*cr;
- char *err;
+ const char *err;
err = validate_grid_desc(&desc, cr, area);
if (err)
state->immutable[i] = TRUE;
if (r == 1) {
- char *err;
+ const char *err;
int *dsf;
assert(*desc == ',');
desc++;
make_blocks_from_whichblock(state->blocks);
if (params->killer) {
- char *err;
+ const char *err;
int *dsf;
assert(*desc == ',');
desc++;
}
static char *solve_game(const game_state *state, const game_state *currstate,
- const char *ai, char **error)
+ const char *ai, const char **error)
{
int cr = state->cr;
char *ret;
{
game_params *p;
game_state *s;
- char *id = NULL, *desc, *err;
+ char *id = NULL, *desc;
+ const char *err;
int grade = FALSE;
struct difficulty dlev;
return ret;
}
-static char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, int full)
{
/*
* Generating anything under 4x4 runs into trouble of one kind
return ret;
}
-static char *validate_desc(const game_params *params, const char *desc)
+static const char *validate_desc(const game_params *params, const char *desc)
{
int w = params->w, h = params->h;
int area, i;
}
static char *solve_game(const game_state *state, const game_state *currstate,
- const char *aux, char **error)
+ const char *aux, const char **error)
{
int w = state->p.w, h = state->p.h;
{
game_params *p;
game_state *s, *s2;
- char *id = NULL, *desc, *err;
+ char *id = NULL, *desc;
+ const char *err;
int grade = FALSE;
int ret, diff, really_verbose = FALSE;
struct solver_scratch *sc;
return ret;
}
-static char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, int full)
{
if (params->w < 3 || params->w > 9)
return "Grid size must be between 3 and 9";
* Gameplay.
*/
-static char *validate_desc(const game_params *params, const char *desc)
+static const char *validate_desc(const game_params *params, const char *desc)
{
int w = params->w, a = w*w;
const char *p = desc;
}
static char *solve_game(const game_state *state, const game_state *currstate,
- const char *aux, char **error)
+ const char *aux, const char **error)
{
int w = state->par.w, a = w*w;
int i, ret;
{
game_params *p;
game_state *s;
- char *id = NULL, *desc, *err;
+ char *id = NULL, *desc;
+ const char *err;
int grade = FALSE;
int ret, diff, really_show_working = FALSE;
return ret;
}
-static char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, int full)
{
/*
* Generating anything under 4x4 runs into trouble of one kind
return desc;
}
-static char *validate_desc(const game_params *params, const char *desc)
+static const char *validate_desc(const game_params *params, const char *desc)
{
int i = 0, w = params->w, h = params->h, in = 0, out = 0;
}
static char *solve_game(const game_state *state, const game_state *currstate,
- const char *aux, char **error)
+ const char *aux, const char **error)
{
game_state *solved;
int ret;
return ret;
}
-static char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, int full)
{
if (params->n < 2)
return "Rotating block size must be at least two";
return ret;
}
-static char *validate_desc(const game_params *params, const char *desc)
+static const char *validate_desc(const game_params *params, const char *desc)
{
const char *p;
int w = params->w, h = params->h, wh = w*h;
}
static char *solve_game(const game_state *state, const game_state *currstate,
- const char *aux, char **error)
+ const char *aux, const char **error)
{
return dupstr("S");
}
return ret;
}
-static char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, int full)
{
if ((params->w * params->h ) > 54) return "Grid is too big";
if (params->w < 3) return "Width must be at least 3";
return state;
}
-static char *validate_desc(const game_params *params, const char *desc)
+static const char *validate_desc(const game_params *params, const char *desc)
{
int i;
int w = params->w, h = params->h;
}
static char *solve_game(const game_state *state_start, const game_state *currstate,
- const char *aux, char **error)
+ const char *aux, const char **error)
{
int p;
int *old_guess;
return ret;
}
-static char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, int full)
{
if (params->order < 3 || params->order > 32)
return "Order must be between 3 and 32";
return state;
}
-static char *validate_desc(const game_params *params, const char *desc)
+static const char *validate_desc(const game_params *params, const char *desc)
{
char *why = NULL;
game_state *dummy = load_game(params, desc, &why);
}
static char *solve_game(const game_state *state, const game_state *currstate,
- const char *aux, char **error)
+ const char *aux, const char **error)
{
game_state *solved;
int r;
static void check(game_params *p)
{
- char *msg = validate_params(p, 1);
+ const char *msg = validate_params(p, 1);
if (msg) {
fprintf(stderr, "%s: %s", quis, msg);
exit(1);
int i;
for (i = 0; i < argc; i++) {
const char *id = *argv++;
- char *desc = strchr(id, ':'), *err;
+ char *desc = strchr(id, ':');
+ const char *err;
p = default_params();
if (desc) {
*desc++ = '\0';
return ret;
}
-static char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, int full)
{
if (params->w < 3 || params->w > 26)
return "Grid size must be between 3 and 26";
* Gameplay.
*/
-static char *validate_grid_desc(const char **pdesc, int range, int area)
+static const char *validate_grid_desc(const char **pdesc, int range, int area)
{
const char *desc = *pdesc;
int squares = 0;
return NULL;
}
-static char *validate_desc(const game_params *params, const char *desc)
+static const char *validate_desc(const game_params *params, const char *desc)
{
int w = params->w, a = w*w;
const char *p = desc;
}
static char *solve_game(const game_state *state, const game_state *currstate,
- const char *aux, char **error)
+ const char *aux, const char **error)
{
int w = state->par.w, a = w*w;
int i, ret;
{
game_params *p;
game_state *s;
- char *id = NULL, *desc, *err;
+ char *id = NULL, *desc;
+ const char *err;
digit *grid;
int grade = FALSE;
int ret, diff, really_show_working = FALSE;
return NULL;
}
-static char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, int full)
{
return NULL;
}
return desc;
}
-static char *validate_desc(const game_params *params, const char *desc)
+static const char *validate_desc(const game_params *params, const char *desc)
{
return NULL;
}
}
static char *solve_game(const game_state *state, const game_state *currstate,
- const char *aux, char **error)
+ const char *aux, const char **error)
{
return NULL;
}
return ret;
}
-static char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, int full)
{
if (params->w > MAXWID)
return "Width must be at most " STR(MAXWID);
return ret;
}
-static char *validate_desc(const game_params *params, const char *desc)
+static const char *validate_desc(const game_params *params, const char *desc)
{
int w = params->w, h = params->h, wh = w*h;
int *active, *link;
}
static char *solve_game(const game_state *state, const game_state *currstate,
- const char *aux, char **error)
+ const char *aux, const char **error)
{
int *moves;
int nmoves;
return ret;
}
-static char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, int full)
{
if (params->w < 4 || params->h < 4)
return "Width and height must both be at least 4";
return desc;
}
-static char *validate_desc(const game_params *params, const char *desc)
+static const char *validate_desc(const game_params *params, const char *desc)
{
int w = params->w, h = params->h;
int area = 0;
}
static char *solve_game(const game_state *state, const game_state *currstate,
- const char *aux, char **error)
+ const char *aux, const char **error)
{
return NULL;
}
return ret;
}
-static char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, int full)
{
if ((params->w2 & 1) || (params->h2 & 1))
return "Width and height must both be even";
return NULL;
}
-static char *validate_desc(const game_params *params, const char *desc)
+static const char *validate_desc(const game_params *params, const char *desc)
{
int w2 = params->w2, h2 = params->h2;
int s = w2 * h2;
}
static char *solve_game(const game_state *state, const game_state *currstate,
- const char *aux, char **error)
+ const char *aux, const char **error)
{
game_state *solved = dup_game(state);
struct unruly_scratch *scratch = unruly_new_scratch(solved);
game_params *params = NULL;
- char *id = NULL, *desc = NULL, *err;
+ char *id = NULL, *desc = NULL;
+ const char *err;
quis = argv[0];
return ret;
}
-static char *validate_params(const game_params *params, int full)
+static const char *validate_params(const game_params *params, int full)
{
if (params->n < 4)
return "Number of points must be at least four";
return ret;
}
-static char *validate_desc(const game_params *params, const char *desc)
+static const char *validate_desc(const game_params *params, const char *desc)
{
int a, b;
}
static char *solve_game(const game_state *state, const game_state *currstate,
- const char *aux, char **error)
+ const char *aux, const char **error)
{
int n = state->params.n;
int matrix[4];
document *doc;
midend *nme = NULL; /* non-interactive midend for bulk puzzle generation */
int i;
- char *err = NULL;
+ const char *err = NULL;
/*
* Create our document structure and fill it up with puzzles.
midend_new_game(me);
} else {
FILE *fp;
- char *err_param, *err_load;
+ const char *err_param, *err_load;
/*
* See if arg is a valid filename of a save game file.
}
}
-static char *frontend_set_config(frontend *fe, int which, config_item *cfg)
+static const char *frontend_set_config(
+ frontend *fe, int which, config_item *cfg)
{
if (which < CFG_FRONTEND_SPECIFIC) {
return midend_set_config(fe->me, which, cfg);
*/
if ((LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL)) {
if (LOWORD(wParam) == IDOK) {
- char *err = frontend_set_config(fe, fe->cfg_which, fe->cfg);
+ const char *err = frontend_set_config(
+ fe, fe->cfg_which, fe->cfg);
if (err) {
MessageBox(hwnd, err, "Validation error",
break;
case IDM_SOLVE:
{
- char *msg = midend_solve(fe->me);
+ const char *msg = midend_solve(fe->me);
if (msg)
MessageBox(hwnd, msg, "Unable to solve",
MB_ICONERROR | MB_OK);
fclose(fp);
} else {
FILE *fp = fopen(filename, "r");
- char *err = NULL;
+ const char *err = NULL;
+ char *err_w = NULL;
midend *me = fe->me;
#ifdef COMBINED
char *id_name;
"supported by this program";
} else {
me = midend_for_new_game(fe, gamelist[i], NULL,
- FALSE, FALSE, &err);
+ FALSE, FALSE, &err_w);
+ err = err_w;
rewind(fp); /* for the actual load */
}
sfree(id_name);
if (err) {
MessageBox(hwnd, err, "Error", MB_ICONERROR|MB_OK);
+ sfree(err_w);
break;
}