static int startloop(struct bf_ctx *ctx)
{
if (ctx->sp == BRAINFUCK_MAX_LOOP_NEST_DEPTH) {
printf("stack overflow error in cmd %lu\n", lastcmd(ctx));
return 1;
}
ctx->stack[ctx->sp] = lastcmd(ctx);
if (ctx->data[ctx->dp]) {
ctx->sp++;
} else {
unsigned int count = 1;
char cmd;
while (1) {
if (readone(ctx, &cmd) != sizeof(cmd)) {
puts("unbalanced loops");
return 1;
}
switch (cmd) {
case '[':
count++;
break;
case ']':
if (!--count)
return 0;
break;
}
}
}
return 0;
}
/* plist - parse a list */
LOCAL LVAL plist(LVAL fptr)
{
LVAL val,expr,lastnptr,nptr;
/* protect some pointers */
xlstkcheck(2);
xlsave(val);
xlsave(expr);
/* keep appending nodes until a closing paren is found */
for (lastnptr = NIL; nextch(fptr) != ')'; )
/* get the next expression */
switch (readone(fptr,&expr)) {
case EOF:
badeof(fptr);
case TRUE:
/* check for a dotted tail */
if (expr == s_dot) {
/* make sure there's a node */
if (lastnptr == NIL)
xlfail("invalid dotted pair");
/* parse the expression after the dot */
if (!xlread(fptr,&expr,TRUE))
badeof(fptr);
rplacd(lastnptr,expr);
/* make sure its followed by a close paren */
if (nextch(fptr) != ')')
xlfail("invalid dotted pair");
}
/* otherwise, handle a normal list element */
else {
nptr = consa(expr);
if (lastnptr == NIL)
val = nptr;
else
rplacd(lastnptr,nptr);
lastnptr = nptr;
}
break;
}
/* skip the closing paren */
xlgetc(fptr);
/* restore the stack */
xlpopn(2);
/* return successfully */
return (val);
}
bool findfile(char *path)
{
char tbname[BUFNAMMAX + 1];
zbuff_t *tbuff;
zbuff_t *was = Curbuff;
Arg = 0;
/* limit name to BUFNAMMAX */
strncpy(tbname, lastpart(path), BUFNAMMAX);
tbname[BUFNAMMAX] = '\0';
/* If is this file already in a buffer - use it.
* At startup, we are done.
*/
foreachbuff(tbuff)
if (tbuff->fname && strcmp(path, tbuff->fname) == 0) {
zswitchto(tbuff);
if (Initializing)
return true;
set_last_bufname(was);
break;
}
if (!tbuff) {
if (cfindbuff(tbname)) {
/* Resolve buffer name collisions by creating
* a unique name */
char *p;
int i;
i = strlen(tbname);
p = &tbname[i < BUFNAMMAX - 3 ? i : BUFNAMMAX - 3];
/* We cannot use 100 here due to a bug in gcc 7.3.0 */
for (i = 0; i < 99; ++i) {
strfmt(p, 4, ".%d", i);
if (!cfindbuff(tbname))
break;
}
if (cfindbuff(tbname))
return false;
}
if (!readone(tbname, path))
return false;
}
if (!Initializing) {
cswitchto(Curbuff);
reframe();
} else if (!*Fname)
strcpy(Fname, path);
return true;
}
static int execute_bf_program(char *filenmae)
{
struct bf_ctx *ctx;
char cmd;
int ret;
ctx = malloc(sizeof(*ctx));
if (!ctx) {
puts("malloc failed");
ret = 1;
goto out_none;
}
memset(ctx, 0, sizeof(*ctx));
ctx->fd = open(filenmae, O_RDONLY);
if (ctx->fd < 0) {
perror("open");
ret = 1;
goto out_nofd;
}
while (1) {
unsigned int i;
/* fetch */
ret = readone(ctx, &cmd);
if (ret < 0) {
perror("read");
ret = 1;
goto out;
} else if (ret == 0) {
/* reached EOF. program is finished */
break;
}
/* decode */
for (i = 0; i < NCMDS; i++)
if (cmds[i].cmd == cmd)
break;
if (i == NCMDS) {
/* no such command. treat as comment */
continue;
}
/* execute */
ret = cmds[i].fn(ctx);
if (ret)
goto out;
};
ret = 0;
out:
close(ctx->fd);
out_nofd:
free(ctx);
out_none:
return ret;
}
/* xlread - read an xlisp expression */
int xlread(LVAL fptr, LVAL *pval, int rflag)
{
int sts;
/* read an expression */
while ((sts = readone(fptr,pval)) == FALSE)
;
/* return status */
return (sts == EOF ? FALSE : TRUE);
}
list* readfromfile()
{///home/pi/wd/sitchart/src/
FILE *rd[4];
rd[0]=fopen("col_0","rb");
rd[1]=fopen("col_1","rb");
rd[2]=fopen("col_2","rb");
rd[3]=fopen("col_3","rb");
list *p=createlist();
for(int i=0;i<4;i++)
readone(rd[i],p);
return p;
}
/* pvector - parse a vector */
LOCAL LVAL pvector(LVAL fptr)
{
LVAL list,expr,val,lastnptr,nptr;
int len,ch,i;
/* protect some pointers */
xlstkcheck(2);
xlsave(list);
xlsave(expr);
/* keep appending nodes until a closing paren is found */
for (lastnptr = NIL, len = 0; (ch = nextch(fptr)) != ')'; ) {
/* check for end of file */
if (ch == EOF)
badeof(fptr);
/* get the next expression */
switch (readone(fptr,&expr)) {
case EOF:
badeof(fptr);
case TRUE:
nptr = consa(expr);
if (lastnptr == NIL)
list = nptr;
else
rplacd(lastnptr,nptr);
lastnptr = nptr;
len++;
break;
}
}
/* skip the closing paren */
xlgetc(fptr);
/* make a vector of the appropriate length */
val = newvector(len);
/* copy the list into the vector */
for (i = 0; i < len; ++i, list = cdr(list))
setelement(val,i,car(list));
/* restore the stack */
xlpopn(2);
/* return successfully */
return (val);
}
static
void
doreadone(int which)
{
off_t pos;
pos = lseek(dirfd, testfiles[which].pos, SEEK_SET);
if (pos<0) {
err(1, ".: lseek(%ld, SEEK_SET)", (long) testfiles[which].pos);
}
if (pos != testfiles[which].pos) {
errx(1, ".: lseek(%ld, SEEK_SET) returned %ld",
(long) testfiles[which].pos, (long) pos);
}
readone(testfiles[which].name);
}
int main(int argc, char * argv[])
{
int parser_ret;
void * instance;
int arg;
FILE * file;
char user_state[USER_STATE_SIZE];
int ret;
fc_solve_display_information_context_t debug_context;
init_debug_context(&debug_context);
dc = &debug_context;
instance = freecell_solver_user_alloc();
current_instance = instance;
{
char * error_string;
parser_ret =
freecell_solver_user_cmd_line_parse_args(
instance,
argc,
(freecell_solver_str_t *)argv,
1,
(freecell_solver_str_t *)known_parameters,
cmd_line_callback,
&debug_context,
&error_string,
&arg
);
if (parser_ret == EXIT_AND_RETURN_0)
{
freecell_solver_user_free(instance);
return 0;
}
else if (
(parser_ret == FCS_CMD_LINE_PARAM_WITH_NO_ARG)
)
{
fprintf(stderr, "The command line parameter \"%s\" requires an argument"
" and was not supplied with one.\n", argv[arg]);
return (-1);
}
else if (
(parser_ret == FCS_CMD_LINE_ERROR_IN_ARG)
)
{
if (error_string != NULL)
{
fprintf(stderr, "%s", error_string);
free(error_string);
}
freecell_solver_user_free(instance);
return -1;
}
}
if ((arg == argc) || (!strcmp(argv[arg], "-")))
{
file = stdin;
if (!getenv("FREECELL_SOLVER_QUIET"))
{
fprintf(stderr, "%s",
"Reading the board from the standard input.\n"
"Type \"fc-solve --help\" for more usage information.\n"
"To cancel this message set the FREECELL_SOLVER_QUIET environment variable.\n"
);
}
}
else if (argv[arg][0] == '-')
{
fprintf(stderr,
"Unknown option \"%s\". "
"Type \"%s --help\" for usage information.\n",
argv[arg],
argv[0]
);
freecell_solver_user_free(instance);
return -1;
}
else
{
file = fopen(argv[arg], "r");
if (file == NULL)
{
fprintf(stderr,
"Could not open file \"%s\" for input. Exiting.\n",
argv[arg]
);
freecell_solver_user_free(instance);
return -1;
}
}
memset(user_state, '\0', sizeof(user_state));
fread(user_state, sizeof(user_state[0]), USER_STATE_SIZE-1, file);
fclose(file);
/* Win32 Does not have those signals */
#ifndef WIN32
signal(SIGUSR1, command_signal_handler);
signal(SIGUSR2, select_signal_handler);
#endif
#if 0
{
int limit = 500;
freecell_solver_user_limit_iterations(instance, limit);
ret = freecell_solver_user_solve_board(instance, user_state);
while (ret == FCS_STATE_SUSPEND_PROCESS)
{
limit += 500;
freecell_solver_user_limit_iterations(instance, limit);
ret = freecell_solver_user_resume_solution(instance);
}
}
#elif defined(FCS_TRACE_MEM)
{
#define STEP 100000
int limit = STEP;
char stat_fn[1024], foo_str[1024];
fcs_portable_time_t mytime;
FILE * stat;
long long int rss;
unsigned long long unsigned_foo;
snprintf(stat_fn, sizeof(stat_fn), "/proc/%ld/stat", (long)(getpid()));
freecell_solver_user_limit_iterations(instance, limit);
ret = freecell_solver_user_solve_board(instance, user_state);
while (ret == FCS_STATE_SUSPEND_PROCESS)
{
FCS_GET_TIME(mytime);
/* This was taken from:
*
* http://www.brokestream.com/procstat.html
* */
stat = fopen(stat_fn, "r");
#define readone(foo) (fscanf(stat, "%lld ", &rss))
#define readstr(foo) (fscanf(stat, "%1000s ", foo_str))
#define readchar(foo) (fscanf(stat, "%c ", foo_str))
#define readunsigned(foo) (fscanf(stat, "%llu ", &unsigned_foo))
readone(&pid);
readstr(tcomm);
readchar(&state);
readone(&ppid);
readone(&pgid);
readone(&sid);
readone(&tty_nr);
readone(&tty_pgrp);
readone(&flags);
readone(&min_flt);
readone(&cmin_flt);
readone(&maj_flt);
readone(&cmaj_flt);
readone(&utime);
readone(&stimev);
readone(&cutime);
readone(&cstime);
readone(&priority);
readone(&nicev);
readone(&num_threads);
readone(&it_real_value);
readunsigned(&start_time);
readone(&vsize);
readone(&rss);
#undef readone
#undef readunsigned
#undef readchar
#undef readstr
fclose(stat);
printf("Reached:\t%d\t%li.%.6li\t%lld\n",
limit,
FCS_TIME_GET_SEC(mytime),
FCS_TIME_GET_USEC(mytime),
rss
);
fflush(stdout);
limit += STEP;
freecell_solver_user_limit_iterations(instance, limit);
ret = freecell_solver_user_resume_solution(instance);
}
}
#undef STEP
#else
ret = freecell_solver_user_solve_board(instance, user_state);
#endif
if (ret == FCS_STATE_INVALID_STATE)
{
char * error_string;
error_string =
freecell_solver_user_get_invalid_state_error_string(
instance,
debug_context.display_10_as_t
);
printf("%s\n", error_string);
free(error_string);
error_string = NULL;
}
else if (ret == FCS_STATE_FLARES_PLAN_ERROR)
{
const char * error_string;
error_string = freecell_solver_user_get_last_error_string(instance);
printf("Flares Plan: %s\n", error_string);
}
else
{
FILE * output_fh;
if (debug_context.output_filename)
{
output_fh = fopen(debug_context.output_filename, "wt");
if (! output_fh)
{
fprintf(stderr,
"Could not open output file '%s' for writing!",
debug_context.output_filename
);
return -1;
}
}
else
{
output_fh = stdout;
}
if (ret == FCS_STATE_WAS_SOLVED)
{
fprintf(output_fh, "-=-=-=-=-=-=-=-=-=-=-=-\n\n");
{
fcs_move_t move;
FILE * move_dump;
char * as_string;
int move_num = 0;
move_dump = output_fh;
if (debug_context.display_states)
{
as_string =
freecell_solver_user_current_state_as_string(
instance,
debug_context.parseable_output,
debug_context.canonized_order_output,
debug_context.display_10_as_t
);
fprintf(move_dump, "%s\n", as_string);
free(as_string);
fprintf(move_dump, "%s", "\n====================\n\n");
}
while (
freecell_solver_user_get_next_move(
instance,
&move
) == 0
)
{
if (debug_context.display_moves)
{
as_string =
freecell_solver_user_move_to_string_w_state(
instance,
move,
debug_context.standard_notation
);
if (debug_context.display_states && debug_context.standard_notation)
{
fprintf(move_dump, "Move: ");
}
fprintf(
move_dump,
(debug_context.standard_notation ?
"%s " :
"%s\n"
),
as_string
);
move_num++;
if (debug_context.standard_notation)
{
if ((move_num % 10 == 0) || debug_context.display_states)
{
fprintf(move_dump, "\n");
}
}
if (debug_context.display_states)
{
fprintf(move_dump, "\n");
}
fflush(move_dump);
free(as_string);
}
if (debug_context.display_states)
{
as_string =
freecell_solver_user_current_state_as_string(
instance,
debug_context.parseable_output,
debug_context.canonized_order_output,
debug_context.display_10_as_t
);
fprintf(move_dump, "%s\n", as_string);
free(as_string);
}
if (debug_context.display_states || (!debug_context.standard_notation))
{
fprintf(move_dump, "%s", "\n====================\n\n");
}
}
if (debug_context.standard_notation && (!debug_context.display_states))
{
fprintf(move_dump, "\n\n");
}
}
fprintf(output_fh, "This game is solveable.\n");
}
else
{
fprintf (output_fh, "I could not solve this game.\n");
}
fprintf(
output_fh,
"Total number of states checked is %i.\n",
freecell_solver_user_get_num_times(instance)
);
#if 1
fprintf(
output_fh,
"This scan generated %i states.\n",
freecell_solver_user_get_num_states_in_collection(instance)
);
#endif
if (debug_context.output_filename)
{
fclose(output_fh);
output_fh = NULL;
}
}
freecell_solver_user_free(instance);
return 0;
}
