/*
* Replacement lex(1) character retrieval routines.
*/
int
engine_cmd_getc(engine_state_t *E)
{
if (E->sc_cmd_file != NULL)
return (getc(E->sc_cmd_file));
if (E->sc_cmd_flags & SC_CMD_EOF)
return (EOF);
if (E->sc_cmd_bufoff < E->sc_cmd_bufsz)
return (*(E->sc_cmd_buf + E->sc_cmd_bufoff++));
if (!(E->sc_cmd_flags & SC_CMD_IACTIVE)) {
E->sc_cmd_flags |= SC_CMD_EOF;
return (EOF);
} else {
#ifdef NATIVE_BUILD
return (EOF);
#else
extern int parens;
if (parens <= 0) {
E->sc_cmd_flags |= SC_CMD_EOF;
return (EOF);
}
for (;;) {
E->sc_cmd_buf = gl_get_line(E->sc_gl, "> ", NULL, -1);
if (E->sc_cmd_buf != NULL)
break;
switch (gl_return_status(E->sc_gl)) {
case GLR_SIGNAL:
gl_abandon_line(E->sc_gl);
continue;
case GLR_EOF:
E->sc_cmd_flags |= SC_CMD_EOF;
return (EOF);
case GLR_ERROR:
uu_die(gettext("Error reading terminal: %s.\n"),
gl_error_message(E->sc_gl, NULL, 0));
/* NOTREACHED */
default:
#ifndef NDEBUG
(void) fprintf(stderr, "%s:%d: gl_get_line() "
"returned unexpected value %d.\n", __FILE__,
__LINE__, gl_return_status(E->sc_gl));
#endif
abort();
}
}
E->sc_cmd_bufsz = strlen(E->sc_cmd_buf);
E->sc_cmd_bufoff = 1;
return (E->sc_cmd_buf[0]);
#endif /* NATIVE_BUILD */
}
}
int main(int argc, char *argv[])
{
if (SDL_Init(SDL_INIT_EVERYTHING) < 0)
{
Printf("Failed to initialize SDL: %s\n", SDL_GetError());
return -1;
}
VideoMode mode = {};
mode.width = 800;
mode.height = 600;
mode.gl_major = 1;
mode.gl_minor = 5;
mode.double_buffer = 1;
mode.depth_bits = 24;
mode.stencil_bits = 8;
mode.multisamples = 4;
mode.swap_interval = 1;
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, mode.gl_major);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, mode.gl_minor);
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, mode.double_buffer);
SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, mode.depth_bits);
SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, mode.stencil_bits);
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, mode.multisamples>0?1:0);
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, mode.multisamples);
mode.window = SDL_CreateWindow(
"World Simulator",
SDL_WINDOWPOS_UNDEFINED,
SDL_WINDOWPOS_UNDEFINED,
mode.width, mode.height,
SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE);
if (!mode.window)
{
Printf("Failed to create a window: %s\n", SDL_GetError());
return -1;
}
SDL_GLContext context = SDL_GL_CreateContext(mode.window);
// Note: This must be set on a valid context
SDL_GL_SetSwapInterval(mode.swap_interval);
SDL_GL_GetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, &mode.gl_major);
SDL_GL_GetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, &mode.gl_minor);
SDL_GL_GetAttribute(SDL_GL_DOUBLEBUFFER, &mode.double_buffer);
SDL_GL_GetAttribute(SDL_GL_DEPTH_SIZE, &mode.depth_bits);
SDL_GL_GetAttribute(SDL_GL_STENCIL_SIZE, &mode.stencil_bits);
SDL_GL_GetAttribute(SDL_GL_MULTISAMPLESAMPLES, &mode.multisamples);
mode.swap_interval = SDL_GL_GetSwapInterval();
sim_init_msgs(false);
ImGui_ImplSdl_Init(mode.window);
STATE = sim_init((u32)get_tick());
HISTORY_LENGTH = 0;
bool running = true;
u64 initial_tick = get_tick();
u64 last_frame_t = initial_tick;
r32 elapsed_time = 0.0f;
r32 delta_time = 1.0f / 60.0f;
while (running)
{
SDL_Event event;
while (SDL_PollEvent(&event))
{
ImGui_ImplSdl_ProcessEvent(&event);
switch (event.type)
{
case SDL_WINDOWEVENT:
{
switch (event.window.event)
{
case SDL_WINDOWEVENT_SIZE_CHANGED:
{
Printf("Window %d size changed to %dx%d\n",
event.window.windowID,
event.window.data1,
event.window.data2);
mode.width = event.window.data1;
mode.height = event.window.data2;
} break;
}
} break;
case SDL_QUIT:
{
running = false;
} break;
}
}
gui_tick(mode, elapsed_time, delta_time);
SDL_GL_SwapWindow(mode.window);
delta_time = time_since(last_frame_t);
if (mode.fps_lock > 0)
{
r32 target_time = 1.0f / (r32)mode.fps_lock;
r32 sleep_time = target_time - delta_time;
if (sleep_time >= 0.01f)
SDL_Delay((u32)(sleep_time * 1000.0f));
delta_time = time_since(last_frame_t);
}
last_frame_t = get_tick();
elapsed_time = time_since(initial_tick);
GLenum error = glGetError();
if (error != GL_NO_ERROR)
{
Printf("An error occurred: %s\n", gl_error_message(error));
running = false;
}
}
ImGui_ImplSdl_Shutdown();
SDL_GL_DeleteContext(context);
SDL_DestroyWindow(mode.window);
SDL_Quit();
return 0;
}
int
engine_interp()
{
#ifdef NATIVE_BUILD
uu_die("native build does not support interactive mode.");
#else
char *selfmri;
size_t sfsz;
int r;
extern int parens;
(void) sigset(SIGINT, SIG_IGN);
est->sc_gl = new_GetLine(512, 8000);
if (est->sc_gl == NULL)
uu_die(gettext("Out of memory.\n"));
/* The longest string is "[snapname]fmri[:instname]> ". */
sfsz = 1 + max_scf_name_len + 1 + max_scf_fmri_len + 2 +
max_scf_name_len + 1 + 2 + 1;
selfmri = safe_malloc(sfsz);
r = gl_customize_completion(est->sc_gl, NULL, complete);
assert(r == 0);
for (;;) {
lscf_get_selection_str(selfmri, sfsz - 2);
(void) strcat(selfmri, "> ");
est->sc_cmd_buf = gl_get_line(est->sc_gl, selfmri, NULL, -1);
if (est->sc_cmd_buf == NULL) {
switch (gl_return_status(est->sc_gl)) {
case GLR_SIGNAL:
gl_abandon_line(est->sc_gl);
continue;
case GLR_EOF:
break;
case GLR_ERROR:
uu_die(gettext("Error reading terminal: %s.\n"),
gl_error_message(est->sc_gl, NULL, 0));
/* NOTREACHED */
default:
#ifndef NDEBUG
(void) fprintf(stderr, "%s:%d: gl_get_line() "
"returned unexpected value %d.\n", __FILE__,
__LINE__, gl_return_status(est->sc_gl));
#endif
abort();
}
break;
}
parens = 0;
est->sc_cmd_bufsz = strlen(est->sc_cmd_buf);
est->sc_cmd_bufoff = 0;
est->sc_cmd_flags = SC_CMD_IACTIVE;
(void) yyparse();
}
free(selfmri);
est->sc_gl = del_GetLine(est->sc_gl); /* returns NULL */
#endif /* NATIVE_BUILD */
return (0);
}
int
interactive_loop(int fd_in, int fd_out, char *file1, char *file2)
{
char *pwd;
char *dir = NULL;
char cmd[2048];
struct sftp_conn *conn;
int err, interactive;
void *il = NULL;
#ifdef USE_LIBEDIT
EditLine *el = NULL;
History *hl = NULL;
HistEvent hev;
if (!batchmode && isatty(STDIN_FILENO)) {
if ((il = el = el_init(__progname, stdin, stdout, stderr)) == NULL)
fatal("Couldn't initialise editline");
if ((hl = history_init()) == NULL)
fatal("Couldn't initialise editline history");
history(hl, &hev, H_SETSIZE, 100);
el_set(el, EL_HIST, history, hl);
el_set(el, EL_PROMPT, prompt);
el_set(el, EL_EDITOR, "emacs");
el_set(el, EL_TERMINAL, NULL);
el_set(el, EL_SIGNAL, 1);
el_source(el, NULL);
}
#else
#ifdef USE_LIBTECLA
GetLine *gl = NULL;
if (!batchmode && isatty(STDIN_FILENO)) {
if ((il = gl = new_GetLine(MAX_LINE_LEN, MAX_CMD_HIST)) == NULL)
fatal("Couldn't initialize GetLine");
if (gl_customize_completion(gl, NULL, nomatch) != 0) {
(void) del_GetLine(gl);
fatal("Couldn't register completion function");
}
}
#endif /* USE_LIBTECLA */
#endif /* USE_LIBEDIT */
conn = do_init(fd_in, fd_out, copy_buffer_len, num_requests);
if (conn == NULL)
fatal("Couldn't initialise connection to server");
pwd = do_realpath(conn, ".");
if (pwd == NULL)
fatal("Need cwd");
if (file1 != NULL) {
dir = xstrdup(file1);
dir = make_absolute(dir, pwd);
if (remote_is_dir(conn, dir) && file2 == NULL) {
printf(gettext("Changing to: %s\n"), dir);
snprintf(cmd, sizeof cmd, "cd \"%s\"", dir);
if (parse_dispatch_command(conn, cmd, &pwd, 1) != 0) {
xfree(dir);
xfree(pwd);
xfree(conn);
return (-1);
}
} else {
if (file2 == NULL)
snprintf(cmd, sizeof cmd, "get %s", dir);
else
snprintf(cmd, sizeof cmd, "get %s %s", dir,
file2);
err = parse_dispatch_command(conn, cmd, &pwd, 1);
xfree(dir);
xfree(pwd);
xfree(conn);
return (err);
}
xfree(dir);
}
#if defined(HAVE_SETVBUF) && !defined(BROKEN_SETVBUF)
setvbuf(stdout, NULL, _IOLBF, 0);
setvbuf(infile, NULL, _IOLBF, 0);
#else
setlinebuf(stdout);
setlinebuf(infile);
#endif
interactive = !batchmode && isatty(STDIN_FILENO);
err = 0;
for (;;) {
char *cp;
signal(SIGINT, SIG_IGN);
if (il == NULL) {
if (interactive)
printf("sftp> ");
if (fgets(cmd, sizeof(cmd), infile) == NULL) {
if (interactive)
printf("\n");
break;
}
if (!interactive) { /* Echo command */
printf("sftp> %s", cmd);
if (strlen(cmd) > 0 &&
cmd[strlen(cmd) - 1] != '\n')
printf("\n");
}
}
#ifdef USE_LIBEDIT
else {
const char *line;
int count = 0;
if ((line = el_gets(el, &count)) == NULL || count <= 0) {
printf("\n");
break;
}
history(hl, &hev, H_ENTER, line);
if (strlcpy(cmd, line, sizeof(cmd)) >= sizeof(cmd)) {
fprintf(stderr, gettext("Error: input line too long\n"));
continue;
}
}
#else
#ifdef USE_LIBTECLA
else {
const char *line;
line = gl_get_line(gl, "sftp> ", NULL, -1);
if (line != NULL) {
if (strlcpy(cmd, line, sizeof(cmd)) >=
sizeof(cmd)) {
fprintf(stderr, gettext(
"Error: input line too long\n"));
continue;
}
} else {
GlReturnStatus rtn;
rtn = gl_return_status(gl);
if (rtn == GLR_SIGNAL) {
gl_abandon_line(gl);
continue;
} else if (rtn == GLR_ERROR) {
fprintf(stderr, gettext(
"Error reading terminal: %s/\n"),
gl_error_message(gl, NULL, 0));
}
break;
}
}
#endif /* USE_LIBTECLA */
#endif /* USE_LIBEDIT */
cp = strrchr(cmd, '\n');
if (cp)
*cp = '\0';
/* Handle user interrupts gracefully during commands */
interrupted = 0;
signal(SIGINT, cmd_interrupt);
err = parse_dispatch_command(conn, cmd, &pwd, batchmode);
if (err != 0)
break;
}
