mirror of https://github.com/dirtbags/tanks.git
clang-format
This commit is contained in:
Neale Pickett
parent
9d3cce9bf6
commit
ffc7d07214
155
ctanks.c
155
ctanks.c
|
|
@ -1,11 +1,13 @@
|
|||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <math.h>
|
||||
#include "ctanks.h"
|
||||
#include <math.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
/* Debugging help */
|
||||
#define DUMPf(fmt, args...) fprintf(stderr, "%s:%s:%d " fmt "\n", __FILE__, __FUNCTION__, __LINE__, ##args)
|
||||
#define DUMPf(fmt, args...) \
|
||||
fprintf(stderr, "%s:%s:%d " fmt "\n", __FILE__, __FUNCTION__, __LINE__, \
|
||||
##args)
|
||||
#define DUMP() DUMPf("")
|
||||
#define DUMP_d(v) DUMPf("%s = %d", #v, v)
|
||||
#define DUMP_x(v) DUMPf("%s = 0x%x", #v, v)
|
||||
|
|
@ -14,94 +16,63 @@
|
|||
#define DUMP_f(v) DUMPf("%s = %f", #v, v)
|
||||
#define DUMP_p(v) DUMPf("%s = %p", #v, v)
|
||||
#define DUMP_xy(v) DUMPf("%s = (%f, %f)", #v, v[0], v[1]);
|
||||
#define DUMP_angle(v) DUMPf("%s = %.3fτ", #v, (v/TAU));
|
||||
#define DUMP_angle(v) DUMPf("%s = %.3fτ", #v, (v / TAU));
|
||||
|
||||
#define sq(x) ((x) * (x))
|
||||
|
||||
|
||||
void
|
||||
tank_init(struct tank *tank, tank_run_func *run, void *udata)
|
||||
{
|
||||
void tank_init(struct tank *tank, tank_run_func *run, void *udata) {
|
||||
memset(tank, 0, sizeof(*tank));
|
||||
tank->run = run;
|
||||
tank->udata = udata;
|
||||
}
|
||||
|
||||
int
|
||||
tank_fire_ready(struct tank *tank)
|
||||
{
|
||||
return (! tank->turret.recharge);
|
||||
}
|
||||
int tank_fire_ready(struct tank *tank) { return (!tank->turret.recharge); }
|
||||
|
||||
void
|
||||
tank_fire(struct tank *tank)
|
||||
{
|
||||
void tank_fire(struct tank *tank) {
|
||||
tank->turret.firing = tank_fire_ready(tank);
|
||||
}
|
||||
|
||||
void
|
||||
tank_set_speed(struct tank *tank, float left, float right)
|
||||
{
|
||||
void tank_set_speed(struct tank *tank, float left, float right) {
|
||||
tank->speed.desired[0] = min(max(left, -100), 100);
|
||||
tank->speed.desired[1] = min(max(right, -100), 100);
|
||||
}
|
||||
|
||||
float
|
||||
tank_get_turret(struct tank *tank)
|
||||
{
|
||||
return tank->turret.current;
|
||||
}
|
||||
float tank_get_turret(struct tank *tank) { return tank->turret.current; }
|
||||
|
||||
void
|
||||
tank_set_turret(struct tank *tank, float angle)
|
||||
{
|
||||
void tank_set_turret(struct tank *tank, float angle) {
|
||||
tank->turret.desired = fmodf(angle, TAU);
|
||||
}
|
||||
|
||||
int
|
||||
tank_get_sensor(struct tank *tank, int sensor_num)
|
||||
{
|
||||
int tank_get_sensor(struct tank *tank, int sensor_num) {
|
||||
if ((sensor_num < 0) || (sensor_num > TANK_MAX_SENSORS)) {
|
||||
return 0;
|
||||
}
|
||||
return tank->sensors[sensor_num].triggered;
|
||||
}
|
||||
|
||||
void
|
||||
tank_set_led(struct tank *tank, int active)
|
||||
{
|
||||
tank->led = active;
|
||||
}
|
||||
void tank_set_led(struct tank *tank, int active) { tank->led = active; }
|
||||
|
||||
static void
|
||||
rotate_point(float angle, float point[2])
|
||||
{
|
||||
static void rotate_point(float angle, float point[2]) {
|
||||
float cos_, sin_;
|
||||
float new[2];
|
||||
|
||||
cos_ = cosf(angle);
|
||||
sin_ = sinf(angle);
|
||||
|
||||
new[0] = point[0]*cos_ - point[1]*sin_;
|
||||
new[1] = point[0]*sin_ + point[1]*cos_;
|
||||
new[0] = point[0] * cos_ - point[1] * sin_;
|
||||
new[1] = point[0] * sin_ + point[1] * cos_;
|
||||
|
||||
point[0] = new[0];
|
||||
point[1] = new[1];
|
||||
}
|
||||
|
||||
|
||||
static void
|
||||
tanks_fire_cannon(struct tanks_game *game,
|
||||
struct tank *this,
|
||||
struct tank *that,
|
||||
float vector[2],
|
||||
float dist2)
|
||||
{
|
||||
static void tanks_fire_cannon(struct tanks_game *game, struct tank *this,
|
||||
struct tank *that, float vector[2], float dist2) {
|
||||
float theta = this->angle + this->turret.current;
|
||||
float rpos[2];
|
||||
|
||||
/* If someone's a crater, this is easy (unless we were just killed by the other one, in which case
|
||||
we have to check the other direction) */
|
||||
/* If someone's a crater, this is easy (unless we were just killed by the
|
||||
other one, in which case we have to check the other direction) */
|
||||
if ((this->killer && this->killer != that) || that->killer) {
|
||||
return;
|
||||
}
|
||||
|
|
@ -118,7 +89,7 @@ tanks_fire_cannon(struct tanks_game *game,
|
|||
}
|
||||
|
||||
/* No need to check if it's not even firing */
|
||||
if (! this->turret.firing) {
|
||||
if (!this->turret.firing) {
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
@ -138,14 +109,9 @@ tanks_fire_cannon(struct tanks_game *game,
|
|||
}
|
||||
}
|
||||
|
||||
static void
|
||||
tanks_sensor_calc(struct tanks_game *game,
|
||||
struct tank *this,
|
||||
struct tank *that,
|
||||
float vector[2],
|
||||
float dist2)
|
||||
{
|
||||
int i;
|
||||
static void tanks_sensor_calc(struct tanks_game *game, struct tank *this,
|
||||
struct tank *that, float vector[2], float dist2) {
|
||||
int i;
|
||||
|
||||
/* If someone's a crater, this is easy */
|
||||
if (this->killer || that->killer) {
|
||||
|
|
@ -211,14 +177,9 @@ tanks_sensor_calc(struct tanks_game *game,
|
|||
}
|
||||
}
|
||||
|
||||
void
|
||||
compute_vector(struct tanks_game *game,
|
||||
float vector[2],
|
||||
float *dist2,
|
||||
struct tank *this,
|
||||
struct tank *that)
|
||||
{
|
||||
int i;
|
||||
void compute_vector(struct tanks_game *game, float vector[2], float *dist2,
|
||||
struct tank *this, struct tank *that) {
|
||||
int i;
|
||||
|
||||
/* Establish shortest vector from center of this to center of that,
|
||||
* taking wrapping into account */
|
||||
|
|
@ -228,8 +189,7 @@ compute_vector(struct tanks_game *game,
|
|||
vector[i] = that->position[i] - this->position[i];
|
||||
if (vector[i] > halfsize) {
|
||||
vector[i] = vector[i] - game->size[i];
|
||||
}
|
||||
else if (vector[i] < -halfsize) {
|
||||
} else if (vector[i] < -halfsize) {
|
||||
vector[i] = game->size[i] + vector[i];
|
||||
}
|
||||
}
|
||||
|
|
@ -238,18 +198,15 @@ compute_vector(struct tanks_game *game,
|
|||
*dist2 = sq(vector[0]) + sq(vector[1]);
|
||||
}
|
||||
|
||||
void
|
||||
tanks_move_tank(struct tanks_game *game,
|
||||
struct tank *tank)
|
||||
{
|
||||
int i;
|
||||
void tanks_move_tank(struct tanks_game *game, struct tank *tank) {
|
||||
int i;
|
||||
float movement;
|
||||
float angle;
|
||||
int dir = 1;
|
||||
int dir = 1;
|
||||
|
||||
/* Rotate the turret */
|
||||
{
|
||||
float rot_angle; /* Quickest way there */
|
||||
float rot_angle; /* Quickest way there */
|
||||
|
||||
/* Constrain rot_angle to between -PI and PI */
|
||||
rot_angle = tank->turret.desired - tank->turret.current;
|
||||
|
|
@ -268,18 +225,18 @@ tanks_move_tank(struct tanks_game *game,
|
|||
if (tank->speed.current[i] == tank->speed.desired[i]) {
|
||||
/* Do nothing */
|
||||
} else if (tank->speed.current[i] < tank->speed.desired[i]) {
|
||||
tank->speed.current[i] = min(tank->speed.current[i] + TANK_MAX_ACCEL,
|
||||
tank->speed.desired[i]);
|
||||
tank->speed.current[i] =
|
||||
min(tank->speed.current[i] + TANK_MAX_ACCEL, tank->speed.desired[i]);
|
||||
} else {
|
||||
tank->speed.current[i] = max(tank->speed.current[i] - TANK_MAX_ACCEL,
|
||||
tank->speed.desired[i]);
|
||||
tank->speed.current[i] =
|
||||
max(tank->speed.current[i] - TANK_MAX_ACCEL, tank->speed.desired[i]);
|
||||
}
|
||||
}
|
||||
|
||||
/* The simple case */
|
||||
if (tank->speed.current[0] == tank->speed.current[1]) {
|
||||
movement = tank->speed.current[0] * (TANK_TOP_SPEED / 100.0);
|
||||
angle = 0;
|
||||
angle = 0;
|
||||
} else {
|
||||
/* pflarr's original comment:
|
||||
*
|
||||
|
|
@ -301,7 +258,8 @@ tanks_move_tank(struct tanks_game *game,
|
|||
to be a penalty for having the treads go in opposite directions.
|
||||
This probably plays hell with precisely-planned tanks, which I
|
||||
find very ha ha. */
|
||||
friction = TANK_FRICTION * (fabsf(tank->speed.current[0] - tank->speed.current[1]) / 200);
|
||||
friction = TANK_FRICTION *
|
||||
(fabsf(tank->speed.current[0] - tank->speed.current[1]) / 200);
|
||||
v[0] = tank->speed.current[0] * (1 - friction) * (TANK_TOP_SPEED / 100.0);
|
||||
v[1] = tank->speed.current[1] * (1 - friction) * (TANK_TOP_SPEED / 100.0);
|
||||
|
||||
|
|
@ -330,7 +288,7 @@ tanks_move_tank(struct tanks_game *game,
|
|||
theta = So/r
|
||||
We multiply it by dir to adjust for the direction of rotation
|
||||
*/
|
||||
theta = So/r * dir;
|
||||
theta = So / r * dir;
|
||||
|
||||
movement = r * tanf(theta);
|
||||
angle = theta;
|
||||
|
|
@ -345,18 +303,16 @@ tanks_move_tank(struct tanks_game *game,
|
|||
m[1] = sinf(tank->angle) * movement * dir;
|
||||
|
||||
for (i = 0; i < 2; i += 1) {
|
||||
tank->position[i] = fmodf(tank->position[i] + m[i] + game->size[i],
|
||||
game->size[i]);
|
||||
tank->position[i] =
|
||||
fmodf(tank->position[i] + m[i] + game->size[i], game->size[i]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
tanks_run_turn(struct tanks_game *game, struct tank *tanks, int ntanks)
|
||||
{
|
||||
int i, j;
|
||||
void tanks_run_turn(struct tanks_game *game, struct tank *tanks, int ntanks) {
|
||||
int i, j;
|
||||
float vector[2];
|
||||
float dist2; /* distance squared */
|
||||
float dist2; /* distance squared */
|
||||
|
||||
/* It takes (at least) two to tank-o */
|
||||
if (ntanks < 2) {
|
||||
|
|
@ -369,7 +325,8 @@ tanks_run_turn(struct tanks_game *game, struct tank *tanks, int ntanks)
|
|||
tanks[i].turret.firing = 0;
|
||||
tanks[i].turret.recharge = TANK_CANNON_RECHARGE;
|
||||
}
|
||||
if (tanks[i].killer) continue;
|
||||
if (tanks[i].killer)
|
||||
continue;
|
||||
if (tanks[i].turret.recharge) {
|
||||
tanks[i].turret.recharge -= 1;
|
||||
}
|
||||
|
|
@ -380,13 +337,15 @@ tanks_run_turn(struct tanks_game *game, struct tank *tanks, int ntanks)
|
|||
|
||||
/* Move tanks */
|
||||
for (i = 0; i < ntanks; i += 1) {
|
||||
if (tanks[i].killer) continue;
|
||||
if (tanks[i].killer)
|
||||
continue;
|
||||
tanks_move_tank(game, &(tanks[i]));
|
||||
}
|
||||
|
||||
/* Probe sensors */
|
||||
for (i = 0; i < ntanks; i += 1) {
|
||||
if (tanks[i].killer) continue;
|
||||
if (tanks[i].killer)
|
||||
continue;
|
||||
for (j = i + 1; j < ntanks; j += 1) {
|
||||
struct tank *this = &tanks[i];
|
||||
struct tank *that = &tanks[j];
|
||||
|
|
@ -401,13 +360,15 @@ tanks_run_turn(struct tanks_game *game, struct tank *tanks, int ntanks)
|
|||
|
||||
/* Run programs */
|
||||
for (i = 0; i < ntanks; i += 1) {
|
||||
if (tanks[i].killer) continue;
|
||||
if (tanks[i].killer)
|
||||
continue;
|
||||
tanks[i].run(&tanks[i], tanks[i].udata);
|
||||
}
|
||||
|
||||
/* Fire cannons and check for crashes */
|
||||
for (i = 0; i < ntanks; i += 1) {
|
||||
if (tanks[i].killer) continue;
|
||||
if (tanks[i].killer)
|
||||
continue;
|
||||
for (j = i + 1; j < ntanks; j += 1) {
|
||||
struct tank *this = &tanks[i];
|
||||
struct tank *that = &tanks[j];
|
||||
|
|
|
|||
67
ctanks.h
67
ctanks.h
|
|
@ -2,44 +2,44 @@
|
|||
|
||||
/* τ = 2π */
|
||||
#define TAU 6.28318530717958647692
|
||||
#define PI 3.14159265358979323846
|
||||
#define PI 3.14159265358979323846
|
||||
|
||||
/* Some in-game constants */
|
||||
#define TANK_MAX_SENSORS 10
|
||||
#define TANK_RADIUS 7.5
|
||||
#define TANK_SENSOR_RANGE 100
|
||||
#define TANK_MAX_SENSORS 10
|
||||
#define TANK_RADIUS 7.5
|
||||
#define TANK_SENSOR_RANGE 100
|
||||
#define TANK_CANNON_RECHARGE 20 /* Turns to recharge cannon */
|
||||
#define TANK_CANNON_RANGE (TANK_SENSOR_RANGE / 2)
|
||||
#define TANK_MAX_ACCEL 35
|
||||
#define TANK_MAX_TURRET_ROT (TAU/8)
|
||||
#define TANK_TOP_SPEED 7
|
||||
#define TANK_CANNON_RANGE (TANK_SENSOR_RANGE / 2)
|
||||
#define TANK_MAX_ACCEL 35
|
||||
#define TANK_MAX_TURRET_ROT (TAU / 8)
|
||||
#define TANK_TOP_SPEED 7
|
||||
#define TANK_FRICTION 0.75
|
||||
|
||||
/* (tank radius + tank radius)^2 */
|
||||
#define TANK_COLLISION_ADJ2 \
|
||||
#define TANK_COLLISION_ADJ2 \
|
||||
((TANK_RADIUS + TANK_RADIUS) * (TANK_RADIUS + TANK_RADIUS))
|
||||
|
||||
/* (Sensor range + tank radius)^2
|
||||
* If the distance^2 to the center of a tank <= TANK_SENSOR_ADJ2,
|
||||
* that tank is within sensor range. */
|
||||
#define TANK_SENSOR_ADJ2 \
|
||||
#define TANK_SENSOR_ADJ2 \
|
||||
((TANK_SENSOR_RANGE + TANK_RADIUS) * (TANK_SENSOR_RANGE + TANK_RADIUS))
|
||||
|
||||
#define TANK_CANNON_ADJ2 \
|
||||
#define TANK_CANNON_ADJ2 \
|
||||
((TANK_CANNON_RANGE + TANK_RADIUS) * (TANK_CANNON_RANGE + TANK_RADIUS))
|
||||
|
||||
#ifndef rad2deg
|
||||
#define rad2deg(r) ((int)(360*(r)/TAU))
|
||||
#define deg2rad(r) ((r*TAU)/360)
|
||||
#define rad2deg(r) ((int)(360 * (r) / TAU))
|
||||
#define deg2rad(r) ((r * TAU) / 360)
|
||||
#endif
|
||||
|
||||
#ifndef max
|
||||
#define max(a,b) (((a) > (b)) ? (a) : (b))
|
||||
#define min(a,b) (((a) < (b)) ? (a) : (b))
|
||||
#define max(a, b) (((a) > (b)) ? (a) : (b))
|
||||
#define min(a, b) (((a) < (b)) ? (a) : (b))
|
||||
#endif
|
||||
|
||||
struct tanks_game {
|
||||
float size[2]; /* dimensions of playing field */
|
||||
float size[2]; /* dimensions of playing field */
|
||||
};
|
||||
|
||||
struct tank;
|
||||
|
|
@ -47,39 +47,38 @@ struct tank;
|
|||
struct sensor {
|
||||
float angle;
|
||||
float width;
|
||||
int range;
|
||||
int turret; /* Mounted to turret? */
|
||||
int triggered;
|
||||
int range;
|
||||
int turret; /* Mounted to turret? */
|
||||
int triggered;
|
||||
};
|
||||
|
||||
typedef void tank_run_func(struct tank *, void *);
|
||||
|
||||
struct tank {
|
||||
float position[2]; /* Current position on the board */
|
||||
float angle; /* Current orientation */
|
||||
float position[2]; /* Current position on the board */
|
||||
float angle; /* Current orientation */
|
||||
struct {
|
||||
float current[2]; /* Current tread speed */
|
||||
float desired[2]; /* Desired tread speed */
|
||||
float current[2]; /* Current tread speed */
|
||||
float desired[2]; /* Desired tread speed */
|
||||
} speed;
|
||||
struct {
|
||||
float current; /* Current turret angle */
|
||||
float desired; /* Desired turret angle */
|
||||
int firing; /* True if firing this turn */
|
||||
int recharge; /* Turns until gun is recharged */
|
||||
float current; /* Current turret angle */
|
||||
float desired; /* Desired turret angle */
|
||||
int firing; /* True if firing this turn */
|
||||
int recharge; /* Turns until gun is recharged */
|
||||
} turret;
|
||||
struct sensor sensors[TANK_MAX_SENSORS]; /* Sensor array */
|
||||
int led; /* State of the LED */
|
||||
struct tank *killer; /* Killer, or NULL if alive */
|
||||
char *cause_death; /* Cause of death */
|
||||
struct sensor sensors[TANK_MAX_SENSORS]; /* Sensor array */
|
||||
int led; /* State of the LED */
|
||||
struct tank *killer; /* Killer, or NULL if alive */
|
||||
char *cause_death; /* Cause of death */
|
||||
|
||||
tank_run_func *run; /* Function to run a tank */
|
||||
void *udata; /* Argument to pass to run */
|
||||
tank_run_func *run; /* Function to run a tank */
|
||||
void *udata; /* Argument to pass to run */
|
||||
};
|
||||
|
||||
void tank_init(struct tank *tank, tank_run_func *run, void *udata);
|
||||
void tanks_run_turn(struct tanks_game *game, struct tank *tanks, int ntanks);
|
||||
|
||||
|
||||
/*
|
||||
*
|
||||
* Tanks API for scripts
|
||||
|
|
|
|||
12
dump.h
12
dump.h
|
|
@ -7,7 +7,9 @@
|
|||
#endif
|
||||
|
||||
/* Debugging */
|
||||
#define DUMPf(fmt, args...) fprintf(stderr, "%s:%s:%d " fmt "\n", __FILE__, __FUNCTION__, __LINE__, ##args)
|
||||
#define DUMPf(fmt, args...) \
|
||||
fprintf(stderr, "%s:%s:%d " fmt "\n", __FILE__, __FUNCTION__, __LINE__, \
|
||||
##args)
|
||||
#define DUMP() DUMPf("")
|
||||
#define DUMP_d(v) DUMPf("%s = %d", #v, v)
|
||||
#define DUMP_x(v) DUMPf("%s = 0x%x", #v, v)
|
||||
|
|
@ -16,15 +18,17 @@
|
|||
#define DUMP_f(v) DUMPf("%s = %f", #v, v)
|
||||
#define DUMP_p(v) DUMPf("%s = %p", #v, v)
|
||||
#define DUMP_xy(v) DUMPf("%s = (%f, %f)", #v, v[0], v[1]);
|
||||
#define DUMP_angle(v) DUMPf("%s = %.3fτ", #v, (v/TAU));
|
||||
#define DUMP_angle(v) DUMPf("%s = %.3fτ", #v, (v / TAU));
|
||||
|
||||
/* Tektronix 4014 drawing */
|
||||
#define TEK_ENABLE "\033[?38h"
|
||||
#define TEK_DISABLE "\033\003"
|
||||
#define TEK(fmt, args...) fprintf(stderr, TEK_ENABLE fmt TEK_DISABLE, ##args)
|
||||
#define TEK_coord(x, y) ((int)y/32)+32,((int)y%32)+96,((int)x/32)+32,((int)x%32)+64
|
||||
#define TEK_coord(x, y) \
|
||||
((int)y / 32) + 32, ((int)y % 32) + 96, ((int)x / 32) + 32, ((int)x % 32) + 64
|
||||
|
||||
#define TEK_cls() TEK("\033\014")
|
||||
#define TEK_line(x1, y1, x2, y2) TEK("\035%c%c%c%c%c%c%c%c", TEK_coord(x1, y1), TEK_coord(x2, y2))
|
||||
#define TEK_line(x1, y1, x2, y2) \
|
||||
TEK("\035%c%c%c%c%c%c%c%c", TEK_coord(x1, y1), TEK_coord(x2, y2))
|
||||
#define TEK_point(x, y) TEK("\034%c%c%c%c", TEK_coord(x, y))
|
||||
#define TEK_text(x, y, s) TEK("\035%c%c%c%c\037%s", TEK_coord(x, y), s)
|
||||
|
|
|
|||
537
forf.c
537
forf.c
|
|
@ -27,28 +27,22 @@
|
|||
* and not new stack types.
|
||||
*/
|
||||
|
||||
#include <limits.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <limits.h>
|
||||
|
||||
#include "forf.h"
|
||||
#include "dump.h"
|
||||
#include "forf.h"
|
||||
|
||||
#ifndef max
|
||||
#define max(a,b) (((a) > (b)) ? (a) : (b))
|
||||
#define min(a,b) (((a) < (b)) ? (a) : (b))
|
||||
#define max(a, b) (((a) > (b)) ? (a) : (b))
|
||||
#define min(a, b) (((a) < (b)) ? (a) : (b))
|
||||
#endif
|
||||
|
||||
char *forf_error_str[] = {
|
||||
"None",
|
||||
"Runtime",
|
||||
"Parse",
|
||||
"Underflow",
|
||||
"Overflow",
|
||||
"Type",
|
||||
"No such procedure",
|
||||
"Divide by zero",
|
||||
"None", "Runtime", "Parse", "Underflow", "Overflow",
|
||||
"Type", "No such procedure", "Divide by zero",
|
||||
};
|
||||
|
||||
/*
|
||||
|
|
@ -56,47 +50,29 @@ char *forf_error_str[] = {
|
|||
* Memory manipulation
|
||||
*
|
||||
*/
|
||||
void
|
||||
forf_memory_init(struct forf_memory *m,
|
||||
long *values,
|
||||
size_t size)
|
||||
{
|
||||
m->mem = values;
|
||||
void forf_memory_init(struct forf_memory *m, long *values, size_t size) {
|
||||
m->mem = values;
|
||||
m->size = size;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
*
|
||||
* Stack manipulation
|
||||
*
|
||||
*/
|
||||
|
||||
void
|
||||
forf_stack_init(struct forf_stack *s,
|
||||
struct forf_value *values,
|
||||
size_t size)
|
||||
{
|
||||
void forf_stack_init(struct forf_stack *s, struct forf_value *values,
|
||||
size_t size) {
|
||||
s->stack = values;
|
||||
s->size = size;
|
||||
s->top = 0;
|
||||
}
|
||||
|
||||
void
|
||||
forf_stack_reset(struct forf_stack *s)
|
||||
{
|
||||
s->top = 0;
|
||||
}
|
||||
void forf_stack_reset(struct forf_stack *s) { s->top = 0; }
|
||||
|
||||
size_t
|
||||
forf_stack_len(struct forf_stack *s)
|
||||
{
|
||||
return s->top;
|
||||
}
|
||||
size_t forf_stack_len(struct forf_stack *s) { return s->top; }
|
||||
|
||||
int
|
||||
forf_stack_push(struct forf_stack *s, struct forf_value *v)
|
||||
{
|
||||
int forf_stack_push(struct forf_stack *s, struct forf_value *v) {
|
||||
if (s->top == s->size) {
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -104,9 +80,7 @@ forf_stack_push(struct forf_stack *s, struct forf_value *v)
|
|||
return 1;
|
||||
}
|
||||
|
||||
int
|
||||
forf_stack_pop(struct forf_stack *s, struct forf_value *v)
|
||||
{
|
||||
int forf_stack_pop(struct forf_stack *s, struct forf_value *v) {
|
||||
if (0 == s->top) {
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -114,23 +88,18 @@ forf_stack_pop(struct forf_stack *s, struct forf_value *v)
|
|||
return 1;
|
||||
}
|
||||
|
||||
void
|
||||
forf_stack_copy(struct forf_stack *dst, struct forf_stack *src)
|
||||
{
|
||||
void forf_stack_copy(struct forf_stack *dst, struct forf_stack *src) {
|
||||
int top = min(dst->size, src->top);
|
||||
|
||||
dst->top = top;
|
||||
memcpy(dst->stack, src->stack, sizeof(*dst->stack) * top);
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
forf_stack_reverse(struct forf_stack *s)
|
||||
{
|
||||
void forf_stack_reverse(struct forf_stack *s) {
|
||||
struct forf_value val;
|
||||
size_t pos;
|
||||
|
||||
for (pos = 0; pos < (s->top)/2; pos += 1) {
|
||||
for (pos = 0; pos < (s->top) / 2; pos += 1) {
|
||||
size_t qos = s->top - pos - 1;
|
||||
|
||||
val = s->stack[pos];
|
||||
|
|
@ -139,12 +108,10 @@ forf_stack_reverse(struct forf_stack *s)
|
|||
}
|
||||
}
|
||||
|
||||
long
|
||||
forf_pop_num(struct forf_env *env)
|
||||
{
|
||||
long forf_pop_num(struct forf_env *env) {
|
||||
struct forf_value val;
|
||||
|
||||
if (! forf_stack_pop(env->data, &val)) {
|
||||
if (!forf_stack_pop(env->data, &val)) {
|
||||
env->error = forf_error_underflow;
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -156,19 +123,16 @@ forf_pop_num(struct forf_env *env)
|
|||
return val.v.i;
|
||||
}
|
||||
|
||||
void
|
||||
forf_push_num(struct forf_env *env, long i)
|
||||
{
|
||||
void forf_push_num(struct forf_env *env, long i) {
|
||||
struct forf_value val;
|
||||
|
||||
val.type = forf_type_number;
|
||||
val.v.i = i;
|
||||
if (! forf_stack_push(env->data, &val)) {
|
||||
if (!forf_stack_push(env->data, &val)) {
|
||||
env->error = forf_error_overflow;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* Pop an entire stack
|
||||
*
|
||||
* DANGER WILL ROBINSON
|
||||
|
|
@ -177,14 +141,12 @@ forf_push_num(struct forf_env *env, long i)
|
|||
* finished with this stack before you push anything onto the data
|
||||
* stack, otherwise your returned stack will be corrupted.
|
||||
*/
|
||||
struct forf_stack
|
||||
forf_pop_stack(struct forf_env *env)
|
||||
{
|
||||
struct forf_stack s = { 0, 0, NULL };
|
||||
struct forf_stack forf_pop_stack(struct forf_env *env) {
|
||||
struct forf_stack s = {0, 0, NULL};
|
||||
struct forf_value val;
|
||||
size_t depth = 1;
|
||||
size_t depth = 1;
|
||||
|
||||
if (! forf_stack_pop(env->data, &val)) {
|
||||
if (!forf_stack_pop(env->data, &val)) {
|
||||
env->error = forf_error_underflow;
|
||||
return s;
|
||||
}
|
||||
|
|
@ -198,7 +160,7 @@ forf_pop_stack(struct forf_env *env)
|
|||
s.size = -1;
|
||||
while (depth) {
|
||||
s.size += 1;
|
||||
if (! forf_stack_pop(env->data, &val)) {
|
||||
if (!forf_stack_pop(env->data, &val)) {
|
||||
/* You should never underflow here, there should at least be a
|
||||
stack begin marker. */
|
||||
env->error = forf_error_runtime;
|
||||
|
|
@ -206,14 +168,14 @@ forf_pop_stack(struct forf_env *env)
|
|||
return s;
|
||||
}
|
||||
switch (val.type) {
|
||||
case forf_type_stack_end:
|
||||
depth += 1;
|
||||
break;
|
||||
case forf_type_stack_begin:
|
||||
depth -= 1;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
case forf_type_stack_end:
|
||||
depth += 1;
|
||||
break;
|
||||
case forf_type_stack_begin:
|
||||
depth -= 1;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
s.top = s.size;
|
||||
|
|
@ -223,13 +185,11 @@ forf_pop_stack(struct forf_env *env)
|
|||
|
||||
/* Push an entire stack onto another stack.
|
||||
*/
|
||||
int
|
||||
forf_push_stack(struct forf_stack *dst, struct forf_stack *src)
|
||||
{
|
||||
int forf_push_stack(struct forf_stack *dst, struct forf_stack *src) {
|
||||
struct forf_value val;
|
||||
|
||||
while (forf_stack_pop(src, &val)) {
|
||||
if (! forf_stack_push(dst, &val)) {
|
||||
if (!forf_stack_push(dst, &val)) {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
|
@ -240,10 +200,8 @@ forf_push_stack(struct forf_stack *dst, struct forf_stack *src)
|
|||
*
|
||||
* This is meant to work with the return value from forf_pop_stack.
|
||||
*/
|
||||
int
|
||||
forf_push_to_command_stack(struct forf_env *env, struct forf_stack *src)
|
||||
{
|
||||
if (! forf_push_stack(env->command, src)) {
|
||||
int forf_push_to_command_stack(struct forf_env *env, struct forf_stack *src) {
|
||||
if (!forf_push_stack(env->command, src)) {
|
||||
env->error = forf_error_overflow;
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -259,24 +217,21 @@ forf_push_to_command_stack(struct forf_env *env, struct forf_stack *src)
|
|||
* always have "reversed" substacks, and everything else will have them
|
||||
* in the right order.
|
||||
*/
|
||||
int
|
||||
forf_stack_move_value(struct forf_env *env,
|
||||
struct forf_stack *dst,
|
||||
struct forf_stack *src)
|
||||
{
|
||||
int forf_stack_move_value(struct forf_env *env, struct forf_stack *dst,
|
||||
struct forf_stack *src) {
|
||||
struct forf_value val;
|
||||
size_t depth = 0;
|
||||
size_t depth = 0;
|
||||
|
||||
do {
|
||||
/* Pop from src */
|
||||
if (! forf_stack_pop(env->command, &val)) {
|
||||
if (!forf_stack_pop(env->command, &val)) {
|
||||
env->error = forf_error_underflow;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Push to dst (or discard if dst is NULL) */
|
||||
if (dst) {
|
||||
if (! forf_stack_push(env->data, &val)) {
|
||||
if (!forf_stack_push(env->data, &val)) {
|
||||
env->error = forf_error_overflow;
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -284,68 +239,49 @@ forf_stack_move_value(struct forf_env *env,
|
|||
|
||||
/* Deal with it being a substack marker */
|
||||
switch (val.type) {
|
||||
case forf_type_stack_begin:
|
||||
depth += 1;
|
||||
break;
|
||||
case forf_type_stack_end:
|
||||
depth -= 1;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
case forf_type_stack_begin:
|
||||
depth += 1;
|
||||
break;
|
||||
case forf_type_stack_end:
|
||||
depth -= 1;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
} while (depth > 0);
|
||||
|
||||
return 1;
|
||||
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
*
|
||||
* Procedures
|
||||
*
|
||||
*/
|
||||
|
||||
#define unproc(name, op) \
|
||||
static void \
|
||||
forf_proc_ ## name(struct forf_env *env) \
|
||||
{ \
|
||||
long a = forf_pop_num(env); \
|
||||
\
|
||||
forf_push_num(env, op a); \
|
||||
#define unproc(name, op) \
|
||||
static void forf_proc_##name(struct forf_env *env) { \
|
||||
long a = forf_pop_num(env); \
|
||||
\
|
||||
forf_push_num(env, op a); \
|
||||
}
|
||||
|
||||
unproc(inv, ~)
|
||||
unproc(not, !)
|
||||
unproc(inv, ~) unproc(not, !)
|
||||
|
||||
#define binproc(name, op) \
|
||||
static void \
|
||||
forf_proc_ ## name(struct forf_env *env) \
|
||||
{ \
|
||||
long a = forf_pop_num(env); \
|
||||
long b = forf_pop_num(env); \
|
||||
\
|
||||
forf_push_num(env, b op a); \
|
||||
#define binproc(name, op) \
|
||||
static void forf_proc_##name(struct forf_env *env) { \
|
||||
long a = forf_pop_num(env); \
|
||||
long b = forf_pop_num(env); \
|
||||
\
|
||||
forf_push_num(env, b op a); \
|
||||
}
|
||||
|
||||
binproc(add, +)
|
||||
binproc(sub, -)
|
||||
binproc(mul, *)
|
||||
binproc(and, &)
|
||||
binproc(or, |)
|
||||
binproc(xor, ^)
|
||||
binproc(lshift, <<)
|
||||
binproc(rshift, >>)
|
||||
binproc(gt, >)
|
||||
binproc(ge, >=)
|
||||
binproc(lt, <)
|
||||
binproc(le, <=)
|
||||
binproc(eq, ==)
|
||||
binproc(ne, !=)
|
||||
binproc(add, +) binproc(sub, -) binproc(mul, *) binproc(and, &)
|
||||
binproc(or, |) binproc(xor, ^) binproc(lshift, <<) binproc(rshift, >>)
|
||||
binproc(gt, >) binproc(ge, >=) binproc(lt, <) binproc(le, <=)
|
||||
binproc(eq, ==) binproc(ne, !=)
|
||||
|
||||
static void
|
||||
forf_proc_div(struct forf_env *env)
|
||||
{
|
||||
static void forf_proc_div(struct forf_env *env) {
|
||||
long a = forf_pop_num(env);
|
||||
long b = forf_pop_num(env);
|
||||
|
||||
|
|
@ -356,9 +292,7 @@ forf_proc_div(struct forf_env *env)
|
|||
forf_push_num(env, b / a);
|
||||
}
|
||||
|
||||
static void
|
||||
forf_proc_mod(struct forf_env *env)
|
||||
{
|
||||
static void forf_proc_mod(struct forf_env *env) {
|
||||
long a = forf_pop_num(env);
|
||||
long b = forf_pop_num(env);
|
||||
|
||||
|
|
@ -369,30 +303,20 @@ forf_proc_mod(struct forf_env *env)
|
|||
forf_push_num(env, b % a);
|
||||
}
|
||||
|
||||
static void
|
||||
forf_proc_abs(struct forf_env *env)
|
||||
{
|
||||
static void forf_proc_abs(struct forf_env *env) {
|
||||
forf_push_num(env, abs(forf_pop_num(env)));
|
||||
}
|
||||
|
||||
static void
|
||||
forf_proc_dup(struct forf_env *env)
|
||||
{
|
||||
static void forf_proc_dup(struct forf_env *env) {
|
||||
long a = forf_pop_num(env);
|
||||
|
||||
forf_push_num(env, a);
|
||||
forf_push_num(env, a);
|
||||
}
|
||||
|
||||
static void
|
||||
forf_proc_pop(struct forf_env *env)
|
||||
{
|
||||
forf_pop_num(env);
|
||||
}
|
||||
static void forf_proc_pop(struct forf_env *env) { forf_pop_num(env); }
|
||||
|
||||
static void
|
||||
forf_proc_exch(struct forf_env *env)
|
||||
{
|
||||
static void forf_proc_exch(struct forf_env *env) {
|
||||
long a = forf_pop_num(env);
|
||||
long b = forf_pop_num(env);
|
||||
|
||||
|
|
@ -400,23 +324,19 @@ forf_proc_exch(struct forf_env *env)
|
|||
forf_push_num(env, b);
|
||||
}
|
||||
|
||||
static void
|
||||
forf_proc_if(struct forf_env *env)
|
||||
{
|
||||
struct forf_stack ifclause = forf_pop_stack(env);
|
||||
long cond = forf_pop_num(env);
|
||||
static void forf_proc_if(struct forf_env *env) {
|
||||
struct forf_stack ifclause = forf_pop_stack(env);
|
||||
long cond = forf_pop_num(env);
|
||||
|
||||
if (cond) {
|
||||
forf_push_to_command_stack(env, &ifclause);
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
forf_proc_ifelse(struct forf_env *env)
|
||||
{
|
||||
static void forf_proc_ifelse(struct forf_env *env) {
|
||||
struct forf_stack elseclause = forf_pop_stack(env);
|
||||
struct forf_stack ifclause = forf_pop_stack(env);
|
||||
long cond = forf_pop_num(env);
|
||||
struct forf_stack ifclause = forf_pop_stack(env);
|
||||
long cond = forf_pop_num(env);
|
||||
|
||||
if (cond) {
|
||||
forf_push_to_command_stack(env, &ifclause);
|
||||
|
|
@ -425,11 +345,9 @@ forf_proc_ifelse(struct forf_env *env)
|
|||
}
|
||||
}
|
||||
|
||||
static void
|
||||
forf_proc_memset(struct forf_env *env)
|
||||
{
|
||||
static void forf_proc_memset(struct forf_env *env) {
|
||||
long pos = forf_pop_num(env);
|
||||
long a = forf_pop_num(env);
|
||||
long a = forf_pop_num(env);
|
||||
|
||||
if (pos >= env->memory->size) {
|
||||
env->error = forf_error_overflow;
|
||||
|
|
@ -439,9 +357,7 @@ forf_proc_memset(struct forf_env *env)
|
|||
env->memory->mem[pos] = a;
|
||||
}
|
||||
|
||||
static void
|
||||
forf_proc_memget(struct forf_env *env)
|
||||
{
|
||||
static void forf_proc_memget(struct forf_env *env) {
|
||||
long pos = forf_pop_num(env);
|
||||
|
||||
if (pos >= env->memory->size) {
|
||||
|
|
@ -457,70 +373,63 @@ forf_proc_memget(struct forf_env *env)
|
|||
* Lexical environment
|
||||
*
|
||||
*/
|
||||
struct forf_lexical_env forf_base_lexical_env[] = {
|
||||
{"~", forf_proc_inv},
|
||||
{"!", forf_proc_not},
|
||||
{"+", forf_proc_add},
|
||||
{"-", forf_proc_sub},
|
||||
{"*", forf_proc_mul},
|
||||
{"/", forf_proc_div},
|
||||
{"%", forf_proc_mod},
|
||||
{"&", forf_proc_and},
|
||||
{"|", forf_proc_or},
|
||||
{"^", forf_proc_xor},
|
||||
{"<<", forf_proc_lshift},
|
||||
{">>", forf_proc_rshift},
|
||||
{">", forf_proc_gt},
|
||||
{">=", forf_proc_ge},
|
||||
{"<", forf_proc_lt},
|
||||
{"<=", forf_proc_le},
|
||||
{"=", forf_proc_eq},
|
||||
{"<>", forf_proc_ne},
|
||||
{"abs", forf_proc_abs},
|
||||
{"dup", forf_proc_dup},
|
||||
{"pop", forf_proc_pop},
|
||||
{"exch", forf_proc_exch},
|
||||
{"if", forf_proc_if},
|
||||
{"ifelse", forf_proc_ifelse},
|
||||
{"mset", forf_proc_memset},
|
||||
{"mget", forf_proc_memget},
|
||||
{NULL, NULL}
|
||||
};
|
||||
struct forf_lexical_env forf_base_lexical_env[] = {{"~", forf_proc_inv},
|
||||
{"!", forf_proc_not},
|
||||
{"+", forf_proc_add},
|
||||
{"-", forf_proc_sub},
|
||||
{"*", forf_proc_mul},
|
||||
{"/", forf_proc_div},
|
||||
{"%", forf_proc_mod},
|
||||
{"&", forf_proc_and},
|
||||
{"|", forf_proc_or},
|
||||
{"^", forf_proc_xor},
|
||||
{"<<", forf_proc_lshift},
|
||||
{">>", forf_proc_rshift},
|
||||
{">", forf_proc_gt},
|
||||
{">=", forf_proc_ge},
|
||||
{"<", forf_proc_lt},
|
||||
{"<=", forf_proc_le},
|
||||
{"=", forf_proc_eq},
|
||||
{"<>", forf_proc_ne},
|
||||
{"abs", forf_proc_abs},
|
||||
{"dup", forf_proc_dup},
|
||||
{"pop", forf_proc_pop},
|
||||
{"exch", forf_proc_exch},
|
||||
{"if", forf_proc_if},
|
||||
{"ifelse", forf_proc_ifelse},
|
||||
{"mset", forf_proc_memset},
|
||||
{"mget", forf_proc_memget},
|
||||
{NULL, NULL}};
|
||||
|
||||
/** Extend a lexical environment */
|
||||
int
|
||||
forf_extend_lexical_env(struct forf_lexical_env *dest,
|
||||
struct forf_lexical_env *src,
|
||||
size_t size)
|
||||
{
|
||||
int forf_extend_lexical_env(struct forf_lexical_env *dest,
|
||||
struct forf_lexical_env *src, size_t size) {
|
||||
int base, i;
|
||||
|
||||
for (base = 0; dest[base].name; base += 1);
|
||||
for (i = 0; (base+i < size) && (src[i].name); i += 1) {
|
||||
dest[base+i] = src[i];
|
||||
for (base = 0; dest[base].name; base += 1)
|
||||
;
|
||||
for (i = 0; (base + i < size) && (src[i].name); i += 1) {
|
||||
dest[base + i] = src[i];
|
||||
}
|
||||
if (base + i == size) {
|
||||
/* Not enough room */
|
||||
return 0;
|
||||
}
|
||||
dest[base+i].name = NULL;
|
||||
dest[base+i].proc = NULL;
|
||||
dest[base + i].name = NULL;
|
||||
dest[base + i].proc = NULL;
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
*
|
||||
* Parsing
|
||||
*
|
||||
*/
|
||||
static int
|
||||
forf_push_token(struct forf_env *env, char *token, size_t tokenlen)
|
||||
{
|
||||
long i;
|
||||
char s[MAX_TOKEN_LEN + 1];
|
||||
char *endptr;
|
||||
struct forf_value val;
|
||||
static int forf_push_token(struct forf_env *env, char *token, size_t tokenlen) {
|
||||
long i;
|
||||
char s[MAX_TOKEN_LEN + 1];
|
||||
char *endptr;
|
||||
struct forf_value val;
|
||||
|
||||
/* Zero-length token yields int:0 from strtol */
|
||||
|
||||
|
|
@ -549,7 +458,7 @@ forf_push_token(struct forf_env *env, char *token, size_t tokenlen)
|
|||
}
|
||||
}
|
||||
|
||||
if (! forf_stack_push(env->command, &val)) {
|
||||
if (!forf_stack_push(env->command, &val)) {
|
||||
env->error = forf_error_overflow;
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -558,25 +467,23 @@ forf_push_token(struct forf_env *env, char *token, size_t tokenlen)
|
|||
}
|
||||
|
||||
/* Parse an input stream onto the command stack */
|
||||
int
|
||||
forf_parse_stream(struct forf_env *env,
|
||||
forf_getch_func *getch,
|
||||
void *datum)
|
||||
{
|
||||
int running = 1;
|
||||
long pos = 0;
|
||||
char token[MAX_TOKEN_LEN];
|
||||
size_t tokenlen = 0;
|
||||
int forf_parse_stream(struct forf_env *env, forf_getch_func *getch,
|
||||
void *datum) {
|
||||
int running = 1;
|
||||
long pos = 0;
|
||||
char token[MAX_TOKEN_LEN];
|
||||
size_t tokenlen = 0;
|
||||
struct forf_value val;
|
||||
size_t stack_depth = 0;
|
||||
int comment = 0;
|
||||
size_t stack_depth = 0;
|
||||
int comment = 0;
|
||||
|
||||
#define _tokenize() \
|
||||
do { \
|
||||
if (tokenlen) { \
|
||||
if (! forf_push_token(env, token, tokenlen)) return pos; \
|
||||
tokenlen = 0; \
|
||||
} \
|
||||
#define _tokenize() \
|
||||
do { \
|
||||
if (tokenlen) { \
|
||||
if (!forf_push_token(env, token, tokenlen)) \
|
||||
return pos; \
|
||||
tokenlen = 0; \
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
while (running) {
|
||||
|
|
@ -588,54 +495,54 @@ forf_parse_stream(struct forf_env *env,
|
|||
/* Handle comments */
|
||||
if (comment) {
|
||||
switch (c) {
|
||||
case EOF:
|
||||
env->error = forf_error_parse;
|
||||
return pos;
|
||||
case ')':
|
||||
comment = 0;
|
||||
break;
|
||||
case EOF:
|
||||
env->error = forf_error_parse;
|
||||
return pos;
|
||||
case ')':
|
||||
comment = 0;
|
||||
break;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
|
||||
switch (c) {
|
||||
case EOF:
|
||||
running = 0;
|
||||
break;
|
||||
case '(':
|
||||
comment = 1;
|
||||
break;
|
||||
case ' ':
|
||||
case '\f':
|
||||
case '\n':
|
||||
case '\r':
|
||||
case '\t':
|
||||
case '\v':
|
||||
_tokenize();
|
||||
break;
|
||||
case '{':
|
||||
_tokenize();
|
||||
val.type = forf_type_stack_begin;
|
||||
if (! forf_stack_push(env->command, &val)) {
|
||||
env->error = forf_error_overflow;
|
||||
return pos;
|
||||
}
|
||||
stack_depth += 1;
|
||||
break;
|
||||
case '}':
|
||||
_tokenize();
|
||||
val.type = forf_type_stack_end;
|
||||
if (! forf_stack_push(env->command, &val)) {
|
||||
env->error = forf_error_overflow;
|
||||
return pos;
|
||||
}
|
||||
stack_depth -= 1;
|
||||
break;
|
||||
default:
|
||||
if (tokenlen < sizeof(token)) {
|
||||
token[tokenlen++] = c;
|
||||
}
|
||||
break;
|
||||
case EOF:
|
||||
running = 0;
|
||||
break;
|
||||
case '(':
|
||||
comment = 1;
|
||||
break;
|
||||
case ' ':
|
||||
case '\f':
|
||||
case '\n':
|
||||
case '\r':
|
||||
case '\t':
|
||||
case '\v':
|
||||
_tokenize();
|
||||
break;
|
||||
case '{':
|
||||
_tokenize();
|
||||
val.type = forf_type_stack_begin;
|
||||
if (!forf_stack_push(env->command, &val)) {
|
||||
env->error = forf_error_overflow;
|
||||
return pos;
|
||||
}
|
||||
stack_depth += 1;
|
||||
break;
|
||||
case '}':
|
||||
_tokenize();
|
||||
val.type = forf_type_stack_end;
|
||||
if (!forf_stack_push(env->command, &val)) {
|
||||
env->error = forf_error_overflow;
|
||||
return pos;
|
||||
}
|
||||
stack_depth -= 1;
|
||||
break;
|
||||
default:
|
||||
if (tokenlen < sizeof(token)) {
|
||||
token[tokenlen++] = c;
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
_tokenize();
|
||||
|
|
@ -652,25 +559,19 @@ forf_parse_stream(struct forf_env *env,
|
|||
}
|
||||
|
||||
struct forf_char_stream {
|
||||
char *buf;
|
||||
size_t len;
|
||||
size_t pos;
|
||||
char *buf;
|
||||
size_t len;
|
||||
size_t pos;
|
||||
};
|
||||
|
||||
static int
|
||||
forf_string_getch(struct forf_char_stream *stream)
|
||||
{
|
||||
static int forf_string_getch(struct forf_char_stream *stream) {
|
||||
if (stream->pos >= stream->len) {
|
||||
return EOF;
|
||||
}
|
||||
return stream->buf[stream->pos++];
|
||||
}
|
||||
|
||||
int
|
||||
forf_parse_buffer(struct forf_env *env,
|
||||
char *buf,
|
||||
size_t len)
|
||||
{
|
||||
int forf_parse_buffer(struct forf_env *env, char *buf, size_t len) {
|
||||
struct forf_char_stream stream;
|
||||
|
||||
stream.buf = buf;
|
||||
|
|
@ -680,78 +581,62 @@ forf_parse_buffer(struct forf_env *env,
|
|||
return forf_parse_stream(env, (forf_getch_func *)forf_string_getch, &stream);
|
||||
}
|
||||
|
||||
int
|
||||
forf_parse_string(struct forf_env *env,
|
||||
char *str)
|
||||
{
|
||||
int forf_parse_string(struct forf_env *env, char *str) {
|
||||
return forf_parse_buffer(env, str, strlen(str));
|
||||
}
|
||||
|
||||
int
|
||||
forf_parse_file(struct forf_env *env,
|
||||
FILE *f)
|
||||
{
|
||||
int forf_parse_file(struct forf_env *env, FILE *f) {
|
||||
return forf_parse_stream(env, (forf_getch_func *)fgetc, f);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
*
|
||||
* Forf environment
|
||||
*
|
||||
*/
|
||||
|
||||
void
|
||||
forf_env_init(struct forf_env *env,
|
||||
struct forf_lexical_env *lenv,
|
||||
struct forf_stack *data,
|
||||
struct forf_stack *cmd,
|
||||
struct forf_memory *mem,
|
||||
void *udata)
|
||||
{
|
||||
env->lenv = lenv;
|
||||
env->data = data;
|
||||
void forf_env_init(struct forf_env *env, struct forf_lexical_env *lenv,
|
||||
struct forf_stack *data, struct forf_stack *cmd,
|
||||
struct forf_memory *mem, void *udata) {
|
||||
env->lenv = lenv;
|
||||
env->data = data;
|
||||
env->command = cmd;
|
||||
env->memory = mem;
|
||||
env->udata = udata;
|
||||
env->memory = mem;
|
||||
env->udata = udata;
|
||||
}
|
||||
|
||||
|
||||
int
|
||||
forf_eval_once(struct forf_env *env)
|
||||
{
|
||||
int forf_eval_once(struct forf_env *env) {
|
||||
struct forf_value val;
|
||||
|
||||
if (! forf_stack_pop(env->command, &val)) {
|
||||
if (!forf_stack_pop(env->command, &val)) {
|
||||
env->error = forf_error_underflow;
|
||||
return 0;
|
||||
}
|
||||
switch (val.type) {
|
||||
case forf_type_number:
|
||||
case forf_type_stack_begin:
|
||||
// Push back on command stack, then move it
|
||||
forf_stack_push(env->command, &val);
|
||||
if (! forf_stack_move_value(env, env->data, env->command)) return 0;
|
||||
break;
|
||||
case forf_type_proc:
|
||||
(val.v.p)(env);
|
||||
break;
|
||||
default:
|
||||
env->error = forf_error_runtime;
|
||||
case forf_type_number:
|
||||
case forf_type_stack_begin:
|
||||
// Push back on command stack, then move it
|
||||
forf_stack_push(env->command, &val);
|
||||
if (!forf_stack_move_value(env, env->data, env->command))
|
||||
return 0;
|
||||
break;
|
||||
case forf_type_proc:
|
||||
(val.v.p)(env);
|
||||
break;
|
||||
default:
|
||||
env->error = forf_error_runtime;
|
||||
return 0;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
int
|
||||
forf_eval(struct forf_env *env)
|
||||
{
|
||||
int forf_eval(struct forf_env *env) {
|
||||
int ret;
|
||||
|
||||
env->error = forf_error_none;
|
||||
while (env->command->top) {
|
||||
ret = forf_eval_once(env);
|
||||
if ((! ret) || (env->error)) {
|
||||
if ((!ret) || (env->error)) {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
73
forf.h
73
forf.h
|
|
@ -1,7 +1,7 @@
|
|||
#pragma once
|
||||
|
||||
#include <stdio.h>
|
||||
#include <inttypes.h>
|
||||
#include <stdio.h>
|
||||
|
||||
#define MAX_TOKEN_LEN 20
|
||||
#define MAX_CMDSTACK 200
|
||||
|
|
@ -28,42 +28,41 @@ enum forf_error_type {
|
|||
|
||||
extern char *forf_error_str[];
|
||||
|
||||
typedef void (forf_proc)(struct forf_env *);
|
||||
typedef void(forf_proc)(struct forf_env *);
|
||||
|
||||
struct forf_value {
|
||||
enum forf_value_type type;
|
||||
enum forf_value_type type;
|
||||
union {
|
||||
forf_proc *p;
|
||||
long i;
|
||||
forf_proc *p;
|
||||
long i;
|
||||
} v;
|
||||
};
|
||||
|
||||
struct forf_stack {
|
||||
size_t size;
|
||||
size_t top;
|
||||
size_t size;
|
||||
size_t top;
|
||||
struct forf_value *stack;
|
||||
};
|
||||
|
||||
struct forf_memory {
|
||||
size_t size;
|
||||
long *mem;
|
||||
size_t size;
|
||||
long *mem;
|
||||
};
|
||||
|
||||
struct forf_lexical_env {
|
||||
char *name;
|
||||
char *name;
|
||||
forf_proc *proc;
|
||||
};
|
||||
|
||||
struct forf_env {
|
||||
enum forf_error_type error;
|
||||
enum forf_error_type error;
|
||||
struct forf_lexical_env *lenv;
|
||||
struct forf_stack *data;
|
||||
struct forf_stack *command;
|
||||
struct forf_memory *memory;
|
||||
void *udata;
|
||||
struct forf_stack *data;
|
||||
struct forf_stack *command;
|
||||
struct forf_memory *memory;
|
||||
void *udata;
|
||||
};
|
||||
|
||||
|
||||
/*
|
||||
*
|
||||
* Main entry points
|
||||
|
|
@ -71,14 +70,11 @@ struct forf_env {
|
|||
*/
|
||||
|
||||
/** Initialize a memory structure, given an array of longs */
|
||||
void forf_memory_init(struct forf_memory *m,
|
||||
long *values,
|
||||
size_t size);
|
||||
void forf_memory_init(struct forf_memory *m, long *values, size_t size);
|
||||
|
||||
/** Initialize a stack, given an array of values */
|
||||
void forf_stack_init(struct forf_stack *s,
|
||||
struct forf_value *values,
|
||||
size_t size);
|
||||
void forf_stack_init(struct forf_stack *s, struct forf_value *values,
|
||||
size_t size);
|
||||
|
||||
void forf_stack_reset(struct forf_stack *s);
|
||||
void forf_stack_copy(struct forf_stack *dst, struct forf_stack *src);
|
||||
|
|
@ -94,51 +90,40 @@ void forf_push_num(struct forf_env *env, long i);
|
|||
/** Pop a whole stack */
|
||||
struct forf_stack forf_pop_stack(struct forf_env *env);
|
||||
|
||||
|
||||
/** The base lexical environment */
|
||||
extern struct forf_lexical_env forf_base_lexical_env[];
|
||||
|
||||
/** Extend a lexical environment */
|
||||
int
|
||||
forf_extend_lexical_env(struct forf_lexical_env *dest,
|
||||
struct forf_lexical_env *src,
|
||||
size_t size);
|
||||
int forf_extend_lexical_env(struct forf_lexical_env *dest,
|
||||
struct forf_lexical_env *src, size_t size);
|
||||
|
||||
/** Initialize a forf runtime environment.
|
||||
*
|
||||
* data, cmd, and mem should have already been initialized
|
||||
*/
|
||||
void forf_env_init(struct forf_env *env,
|
||||
struct forf_lexical_env *lenv,
|
||||
struct forf_stack *data,
|
||||
struct forf_stack *cmd,
|
||||
struct forf_memory *mem,
|
||||
void *udata);
|
||||
void forf_env_init(struct forf_env *env, struct forf_lexical_env *lenv,
|
||||
struct forf_stack *data, struct forf_stack *cmd,
|
||||
struct forf_memory *mem, void *udata);
|
||||
|
||||
/** The type of a getch function (used for parsing) */
|
||||
typedef int (forf_getch_func)(void *);
|
||||
typedef int(forf_getch_func)(void *);
|
||||
|
||||
/** Parse something by calling getch(datum)
|
||||
*
|
||||
* Returns the character at which an error was encountered, or
|
||||
* 0 for successful parse.
|
||||
*/
|
||||
int forf_parse_stream(struct forf_env *env,
|
||||
forf_getch_func *getch,
|
||||
void *datum);
|
||||
int forf_parse_stream(struct forf_env *env, forf_getch_func *getch,
|
||||
void *datum);
|
||||
|
||||
/** Parse a buffer */
|
||||
int forf_parse_buffer(struct forf_env *env,
|
||||
char *buf,
|
||||
size_t len);
|
||||
int forf_parse_buffer(struct forf_env *env, char *buf, size_t len);
|
||||
|
||||
/** Parse a string */
|
||||
int forf_parse_string(struct forf_env *env,
|
||||
char *str);
|
||||
int forf_parse_string(struct forf_env *env, char *str);
|
||||
|
||||
/** Parse a FILE * */
|
||||
int forf_parse_file(struct forf_env *env,
|
||||
FILE *f);
|
||||
int forf_parse_file(struct forf_env *env, FILE *f);
|
||||
|
||||
/** Evaluate the topmost value on the command stack */
|
||||
int forf_eval_once(struct forf_env *env);
|
||||
|
|
|
|||
317
forftanks.c
317
forftanks.c
|
|
@ -1,13 +1,13 @@
|
|||
#include <sys/types.h>
|
||||
#include <sys/stat.h>
|
||||
#include <unistd.h>
|
||||
#include <string.h>
|
||||
#include "ctanks.h"
|
||||
#include "dump.h"
|
||||
#include "forf.h"
|
||||
#include <math.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <math.h>
|
||||
#include "ctanks.h"
|
||||
#include "forf.h"
|
||||
#include "dump.h"
|
||||
#include <string.h>
|
||||
#include <sys/stat.h>
|
||||
#include <sys/types.h>
|
||||
#include <unistd.h>
|
||||
|
||||
#define MAX_TANKS 50
|
||||
#define ROUNDS 500
|
||||
|
|
@ -20,28 +20,25 @@
|
|||
#define MEMORY_SIZE 10
|
||||
|
||||
struct forftank {
|
||||
struct forf_env env;
|
||||
int error_pos;
|
||||
char color[8]; /* "#ff0088" */
|
||||
char name[50];
|
||||
char *path;
|
||||
struct forf_env env;
|
||||
int error_pos;
|
||||
char color[8]; /* "#ff0088" */
|
||||
char name[50];
|
||||
char *path;
|
||||
unsigned int uid;
|
||||
|
||||
struct forf_stack _prog;
|
||||
struct forf_value _progvals[CSTACK_SIZE];
|
||||
struct forf_stack _cmd;
|
||||
struct forf_value _cmdvals[CSTACK_SIZE];
|
||||
struct forf_stack _data;
|
||||
struct forf_value _datavals[DSTACK_SIZE];
|
||||
struct forf_stack _prog;
|
||||
struct forf_value _progvals[CSTACK_SIZE];
|
||||
struct forf_stack _cmd;
|
||||
struct forf_value _cmdvals[CSTACK_SIZE];
|
||||
struct forf_stack _data;
|
||||
struct forf_value _datavals[DSTACK_SIZE];
|
||||
struct forf_memory _mem;
|
||||
long _memvals[MEMORY_SIZE];
|
||||
long _memvals[MEMORY_SIZE];
|
||||
};
|
||||
|
||||
|
||||
#ifndef NODEBUG
|
||||
void
|
||||
forf_print_val(struct forf_value *val)
|
||||
{
|
||||
void forf_print_val(struct forf_value *val) {
|
||||
switch (val->type) {
|
||||
case forf_type_number:
|
||||
printf("%ld", val->v.i);
|
||||
|
|
@ -58,9 +55,7 @@ forf_print_val(struct forf_value *val)
|
|||
}
|
||||
}
|
||||
|
||||
void
|
||||
forf_print_stack(struct forf_stack *s)
|
||||
{
|
||||
void forf_print_stack(struct forf_stack *s) {
|
||||
size_t pos;
|
||||
|
||||
for (pos = 0; pos < s->top; pos += 1) {
|
||||
|
|
@ -69,9 +64,7 @@ forf_print_stack(struct forf_stack *s)
|
|||
}
|
||||
}
|
||||
|
||||
void
|
||||
forf_dump_stack(struct forf_stack *s)
|
||||
{
|
||||
void forf_dump_stack(struct forf_stack *s) {
|
||||
printf("Stack at %p: ", s);
|
||||
forf_print_stack(s);
|
||||
printf("\n");
|
||||
|
|
@ -85,80 +78,64 @@ forf_dump_stack(struct forf_stack *s)
|
|||
*/
|
||||
|
||||
/** Has the turret recharged? */
|
||||
void
|
||||
forf_tank_fire_ready(struct forf_env *env)
|
||||
{
|
||||
void forf_tank_fire_ready(struct forf_env *env) {
|
||||
struct tank *tank = (struct tank *)env->udata;
|
||||
|
||||
forf_push_num(env, tank_fire_ready(tank));
|
||||
}
|
||||
|
||||
/** Fire! */
|
||||
void
|
||||
forf_tank_fire(struct forf_env *env)
|
||||
{
|
||||
void forf_tank_fire(struct forf_env *env) {
|
||||
struct tank *tank = (struct tank *)env->udata;
|
||||
|
||||
tank_fire(tank);
|
||||
}
|
||||
|
||||
/** Set desired speed */
|
||||
void
|
||||
forf_tank_set_speed(struct forf_env *env)
|
||||
{
|
||||
struct tank *tank = (struct tank *)env->udata;
|
||||
long right = forf_pop_num(env);
|
||||
long left = forf_pop_num(env);
|
||||
void forf_tank_set_speed(struct forf_env *env) {
|
||||
struct tank *tank = (struct tank *)env->udata;
|
||||
long right = forf_pop_num(env);
|
||||
long left = forf_pop_num(env);
|
||||
|
||||
tank_set_speed(tank, left, right);
|
||||
}
|
||||
|
||||
/** Get the current turret angle */
|
||||
void
|
||||
forf_tank_get_turret(struct forf_env *env)
|
||||
{
|
||||
struct tank *tank = (struct tank *)env->udata;
|
||||
float angle = tank_get_turret(tank);
|
||||
void forf_tank_get_turret(struct forf_env *env) {
|
||||
struct tank *tank = (struct tank *)env->udata;
|
||||
float angle = tank_get_turret(tank);
|
||||
|
||||
forf_push_num(env, rad2deg(angle));
|
||||
}
|
||||
|
||||
/** Set the desired turret angle */
|
||||
void
|
||||
forf_tank_set_turret(struct forf_env *env)
|
||||
{
|
||||
struct tank *tank = (struct tank *)env->udata;
|
||||
long angle = forf_pop_num(env);
|
||||
void forf_tank_set_turret(struct forf_env *env) {
|
||||
struct tank *tank = (struct tank *)env->udata;
|
||||
long angle = forf_pop_num(env);
|
||||
|
||||
tank_set_turret(tank, deg2rad(angle));
|
||||
}
|
||||
|
||||
/** Is a sensor active? */
|
||||
void
|
||||
forf_tank_get_sensor(struct forf_env *env)
|
||||
{
|
||||
struct tank *tank = (struct tank *)env->udata;
|
||||
long sensor_num = forf_pop_num(env);
|
||||
void forf_tank_get_sensor(struct forf_env *env) {
|
||||
struct tank *tank = (struct tank *)env->udata;
|
||||
long sensor_num = forf_pop_num(env);
|
||||
|
||||
forf_push_num(env, tank_get_sensor(tank, sensor_num));
|
||||
}
|
||||
|
||||
/** Set the LED state */
|
||||
void
|
||||
forf_tank_set_led(struct forf_env *env)
|
||||
{
|
||||
struct tank *tank = (struct tank *)env->udata;
|
||||
long active = forf_pop_num(env);
|
||||
void forf_tank_set_led(struct forf_env *env) {
|
||||
struct tank *tank = (struct tank *)env->udata;
|
||||
long active = forf_pop_num(env);
|
||||
|
||||
tank_set_led(tank, active);
|
||||
}
|
||||
|
||||
/** Pick a random number */
|
||||
void
|
||||
forf_proc_random(struct forf_env *env)
|
||||
{
|
||||
void forf_proc_random(struct forf_env *env) {
|
||||
long max = forf_pop_num(env);
|
||||
|
||||
|
||||
if (max < 1) {
|
||||
forf_push_num(env, 0);
|
||||
return;
|
||||
|
|
@ -169,16 +146,15 @@ forf_proc_random(struct forf_env *env)
|
|||
|
||||
/* Tanks lexical environment */
|
||||
struct forf_lexical_env tanks_lenv_addons[] = {
|
||||
{"fire-ready?", forf_tank_fire_ready},
|
||||
{"fire!", forf_tank_fire},
|
||||
{"set-speed!", forf_tank_set_speed},
|
||||
{"get-turret", forf_tank_get_turret},
|
||||
{"set-turret!", forf_tank_set_turret},
|
||||
{"sensor?", forf_tank_get_sensor},
|
||||
{"set-led!", forf_tank_set_led},
|
||||
{"random", forf_proc_random},
|
||||
{NULL, NULL}
|
||||
};
|
||||
{"fire-ready?", forf_tank_fire_ready},
|
||||
{"fire!", forf_tank_fire},
|
||||
{"set-speed!", forf_tank_set_speed},
|
||||
{"get-turret", forf_tank_get_turret},
|
||||
{"set-turret!", forf_tank_set_turret},
|
||||
{"sensor?", forf_tank_get_sensor},
|
||||
{"set-led!", forf_tank_set_led},
|
||||
{"random", forf_proc_random},
|
||||
{NULL, NULL}};
|
||||
|
||||
/*
|
||||
*
|
||||
|
|
@ -186,68 +162,61 @@ struct forf_lexical_env tanks_lenv_addons[] = {
|
|||
*
|
||||
*/
|
||||
|
||||
int
|
||||
ft_read_file(char *ptr, size_t size, char *dir, char *fn)
|
||||
{
|
||||
char path[256];
|
||||
FILE *f = NULL;
|
||||
int ret;
|
||||
int success = 0;
|
||||
int ft_read_file(char *ptr, size_t size, char *dir, char *fn) {
|
||||
char path[256];
|
||||
FILE *f = NULL;
|
||||
int ret;
|
||||
int success = 0;
|
||||
|
||||
do {
|
||||
snprintf(path, sizeof(path), "%s/%s", dir, fn);
|
||||
f = fopen(path, "r");
|
||||
if (! f) break;
|
||||
if (!f)
|
||||
break;
|
||||
|
||||
ret = fread(ptr, 1, size - 1, f);
|
||||
ptr[ret] = '\0';
|
||||
if (! ret) break;
|
||||
if (!ret)
|
||||
break;
|
||||
|
||||
success = 1;
|
||||
} while (0);
|
||||
|
||||
if (f) fclose(f);
|
||||
if (! success) {
|
||||
if (f)
|
||||
fclose(f);
|
||||
if (!success) {
|
||||
return 0;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
void
|
||||
ft_bricked_tank(struct tank *tank, void *ignored)
|
||||
{
|
||||
void ft_bricked_tank(struct tank *tank, void *ignored) {
|
||||
/* Do nothing, the tank is comatose */
|
||||
}
|
||||
|
||||
void
|
||||
ft_run_tank(struct tank *tank, struct forftank *ftank)
|
||||
{
|
||||
void ft_run_tank(struct tank *tank, struct forftank *ftank) {
|
||||
int ret;
|
||||
|
||||
/* Copy program into command stack */
|
||||
forf_stack_copy(&ftank->_cmd, &ftank->_prog);
|
||||
forf_stack_reset(&ftank->_data);
|
||||
ret = forf_eval(&ftank->env);
|
||||
if (! ret) {
|
||||
fprintf(stderr, "Error in %s: %s\n",
|
||||
ftank->path,
|
||||
if (!ret) {
|
||||
fprintf(stderr, "Error in %s: %s\n", ftank->path,
|
||||
forf_error_str[ftank->env.error]);
|
||||
}
|
||||
}
|
||||
|
||||
int
|
||||
ft_read_program(struct forftank *ftank,
|
||||
struct tank *tank,
|
||||
struct forf_lexical_env *lenv,
|
||||
char *path)
|
||||
{
|
||||
char progpath[256];
|
||||
int ft_read_program(struct forftank *ftank, struct tank *tank,
|
||||
struct forf_lexical_env *lenv, char *path) {
|
||||
char progpath[256];
|
||||
FILE *f;
|
||||
|
||||
/* Open program */
|
||||
snprintf(progpath, sizeof(progpath), "%s/program", path);
|
||||
f = fopen(progpath, "r");
|
||||
if (! f) return 0;
|
||||
if (!f)
|
||||
return 0;
|
||||
|
||||
/* Parse program */
|
||||
ftank->error_pos = forf_parse_file(&ftank->env, f);
|
||||
|
|
@ -265,43 +234,33 @@ ft_read_program(struct forftank *ftank,
|
|||
return 1;
|
||||
}
|
||||
|
||||
void
|
||||
ft_tank_init(struct forftank *ftank,
|
||||
struct tank *tank,
|
||||
struct forf_lexical_env *lenv)
|
||||
{
|
||||
void ft_tank_init(struct forftank *ftank, struct tank *tank,
|
||||
struct forf_lexical_env *lenv) {
|
||||
/* Set up forf environment */
|
||||
forf_stack_init(&ftank->_prog, ftank->_progvals, CSTACK_SIZE);
|
||||
forf_stack_init(&ftank->_cmd, ftank->_cmdvals, CSTACK_SIZE);
|
||||
forf_stack_init(&ftank->_data, ftank->_datavals, DSTACK_SIZE);
|
||||
forf_memory_init(&ftank->_mem, ftank->_memvals, MEMORY_SIZE);
|
||||
forf_env_init(&ftank->env,
|
||||
lenv,
|
||||
&ftank->_data,
|
||||
&ftank->_cmd,
|
||||
&ftank->_mem,
|
||||
forf_env_init(&ftank->env, lenv, &ftank->_data, &ftank->_cmd, &ftank->_mem,
|
||||
tank);
|
||||
}
|
||||
|
||||
void
|
||||
ft_read_sensors(struct tank *tank,
|
||||
char *path)
|
||||
{
|
||||
void ft_read_sensors(struct tank *tank, char *path) {
|
||||
int i;
|
||||
|
||||
for (i = 0; i < TANK_MAX_SENSORS; i += 1) {
|
||||
int ret;
|
||||
char fn[10];
|
||||
char s[20];
|
||||
int ret;
|
||||
char fn[10];
|
||||
char s[20];
|
||||
char *p = s;
|
||||
long range;
|
||||
long angle;
|
||||
long width;
|
||||
long turret;
|
||||
long range;
|
||||
long angle;
|
||||
long width;
|
||||
long turret;
|
||||
|
||||
snprintf(fn, sizeof(fn), "sensor%d", i);
|
||||
ret = ft_read_file(s, sizeof(s), path, fn);
|
||||
if (! ret) {
|
||||
if (!ret) {
|
||||
s[0] = 0;
|
||||
}
|
||||
range = strtol(p, &p, 0);
|
||||
|
|
@ -316,12 +275,8 @@ ft_read_sensors(struct tank *tank,
|
|||
}
|
||||
}
|
||||
|
||||
int
|
||||
ft_read_tank(struct forftank *ftank,
|
||||
struct tank *tank,
|
||||
struct forf_lexical_env *lenv,
|
||||
char *path)
|
||||
{
|
||||
int ft_read_tank(struct forftank *ftank, struct tank *tank,
|
||||
struct forf_lexical_env *lenv, char *path) {
|
||||
int ret;
|
||||
|
||||
ftank->path = path;
|
||||
|
|
@ -338,7 +293,7 @@ ft_read_tank(struct forftank *ftank,
|
|||
|
||||
/* What is your name? */
|
||||
ret = ft_read_file(ftank->name, sizeof(ftank->name), path, "name");
|
||||
if (! ret) {
|
||||
if (!ret) {
|
||||
snprintf(ftank->name, sizeof(ftank->name), "i:%x", ftank->uid);
|
||||
}
|
||||
|
||||
|
|
@ -354,29 +309,21 @@ ft_read_tank(struct forftank *ftank,
|
|||
|
||||
/* What is your favorite color? */
|
||||
ret = ft_read_file(ftank->color, sizeof(ftank->color), path, "color");
|
||||
if (! ret) {
|
||||
if (!ret) {
|
||||
strncpy(ftank->color, "#808080", sizeof(ftank->color));
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
void
|
||||
print_header(FILE *f,
|
||||
struct tanks_game *game,
|
||||
int seed)
|
||||
{
|
||||
void print_header(FILE *f, struct tanks_game *game, int seed) {
|
||||
fprintf(f, "{\n");
|
||||
fprintf(f, " \"seed\": %d,\n", seed);
|
||||
fprintf(f, " \"field\": [%d,%d],\n", (int)game->size[0], (int)game->size[1]);
|
||||
}
|
||||
|
||||
void
|
||||
print_rounds(FILE *f,
|
||||
struct tanks_game *game,
|
||||
struct tank *tanks,
|
||||
int ntanks)
|
||||
{
|
||||
void print_rounds(FILE *f, struct tanks_game *game, struct tank *tanks,
|
||||
int ntanks) {
|
||||
int alive;
|
||||
|
||||
fprintf(f, " \"rounds\": [\n");
|
||||
|
|
@ -395,7 +342,7 @@ print_rounds(FILE *f,
|
|||
struct tank *t = &(tanks[j]);
|
||||
|
||||
int k;
|
||||
int flags = 0;
|
||||
int flags = 0;
|
||||
int sensors = 0;
|
||||
|
||||
if (j > 0) {
|
||||
|
|
@ -417,12 +364,8 @@ print_rounds(FILE *f,
|
|||
alive -= 1;
|
||||
flags |= 4;
|
||||
}
|
||||
fprintf(f, "[%d,%d,%.2f,%.2f,%d,%d]",
|
||||
(int)t->position[0],
|
||||
(int)(t->position[1]),
|
||||
t->angle,
|
||||
t->turret.current,
|
||||
flags,
|
||||
fprintf(f, "[%d,%d,%.2f,%.2f,%d,%d]", (int)t->position[0],
|
||||
(int)(t->position[1]), t->angle, t->turret.current, flags,
|
||||
sensors);
|
||||
}
|
||||
fprintf(f, "]");
|
||||
|
|
@ -431,12 +374,8 @@ print_rounds(FILE *f,
|
|||
fprintf(f, "\n ],\n");
|
||||
}
|
||||
|
||||
void
|
||||
print_standings(FILE *f,
|
||||
struct forftank *ftanks,
|
||||
struct tank *tanks,
|
||||
int ntanks)
|
||||
{
|
||||
void print_standings(FILE *f, struct forftank *ftanks, struct tank *tanks,
|
||||
int ntanks) {
|
||||
|
||||
fprintf(f, " \"tanks\": [\n");
|
||||
for (int i = 0; i < ntanks; i += 1) {
|
||||
|
|
@ -462,7 +401,8 @@ print_standings(FILE *f,
|
|||
fprintf(f, " \"killer\": %d,\n", killer);
|
||||
fprintf(f, " \"kills\": %d,\n", kills);
|
||||
fprintf(f, " \"errorPos\": %d,\n", ftanks[i].error_pos);
|
||||
fprintf(f, " \"error\": \"%s\",\n", forf_error_str[ftanks[i].env.error]);
|
||||
fprintf(f, " \"error\": \"%s\",\n",
|
||||
forf_error_str[ftanks[i].env.error]);
|
||||
fprintf(f, " \"sensors\": [\n");
|
||||
for (int j = 0; j < TANK_MAX_SENSORS; j += 1) {
|
||||
struct sensor *s = &(tanks[i].sensors[j]);
|
||||
|
|
@ -470,15 +410,15 @@ print_standings(FILE *f,
|
|||
if (j > 0) {
|
||||
fprintf(f, ",\n");
|
||||
}
|
||||
|
||||
if (! s->range) {
|
||||
|
||||
if (!s->range) {
|
||||
fprintf(f, " null");
|
||||
} else {
|
||||
fprintf(f, " {\"range\":%d,\"angle\":%.2f,\"width\":%.2f,\"turret\":%s}",
|
||||
(int)(s->range),
|
||||
s->angle,
|
||||
s->width,
|
||||
s->turret?"true":"false");
|
||||
fprintf(f,
|
||||
" "
|
||||
"{\"range\":%d,\"angle\":%.2f,\"width\":%.2f,\"turret\":%s}",
|
||||
(int)(s->range), s->angle, s->width,
|
||||
s->turret ? "true" : "false");
|
||||
}
|
||||
}
|
||||
fprintf(f, "\n ]");
|
||||
|
|
@ -488,39 +428,36 @@ print_standings(FILE *f,
|
|||
fprintf(f, "\n ],\n");
|
||||
}
|
||||
|
||||
void
|
||||
print_footer(FILE *f)
|
||||
{
|
||||
fprintf(f, " \"\": null\n"); // sentry, so everything prior can end with a comma
|
||||
void print_footer(FILE *f) {
|
||||
fprintf(f,
|
||||
" \"\": null\n"); // sentry, so everything prior can end with a comma
|
||||
fprintf(f, "}\n");
|
||||
}
|
||||
|
||||
int
|
||||
main(int argc, char *argv[])
|
||||
{
|
||||
struct tanks_game game;
|
||||
struct forftank myftanks[MAX_TANKS];
|
||||
struct tank mytanks[MAX_TANKS];
|
||||
int main(int argc, char *argv[]) {
|
||||
struct tanks_game game;
|
||||
struct forftank myftanks[MAX_TANKS];
|
||||
struct tank mytanks[MAX_TANKS];
|
||||
struct forf_lexical_env lenv[LENV_SIZE];
|
||||
int order[MAX_TANKS];
|
||||
int ntanks = 0;
|
||||
int i;
|
||||
int order[MAX_TANKS];
|
||||
int ntanks = 0;
|
||||
int i;
|
||||
int seed;
|
||||
|
||||
lenv[0].name = NULL;
|
||||
lenv[0].proc = NULL;
|
||||
if ((! forf_extend_lexical_env(lenv, forf_base_lexical_env, LENV_SIZE)) ||
|
||||
(! forf_extend_lexical_env(lenv, tanks_lenv_addons, LENV_SIZE))) {
|
||||
if ((!forf_extend_lexical_env(lenv, forf_base_lexical_env, LENV_SIZE)) ||
|
||||
(!forf_extend_lexical_env(lenv, tanks_lenv_addons, LENV_SIZE))) {
|
||||
fprintf(stderr, "Unable to initialize lexical environment.\n");
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* We only need slightly random numbers */
|
||||
{
|
||||
char *s = getenv("SEED");
|
||||
seed = atoi(s?s:"");
|
||||
char *s = getenv("SEED");
|
||||
seed = atoi(s ? s : "");
|
||||
|
||||
if (! seed) {
|
||||
if (!seed) {
|
||||
seed = getpid();
|
||||
}
|
||||
|
||||
|
|
@ -534,10 +471,7 @@ main(int argc, char *argv[])
|
|||
|
||||
/* Every argument is a tank directory */
|
||||
for (i = 1; ntanks < MAX_TANKS && i < argc; i += 1) {
|
||||
if (ft_read_tank(&myftanks[ntanks],
|
||||
&mytanks[ntanks],
|
||||
lenv,
|
||||
argv[i])) {
|
||||
if (ft_read_tank(&myftanks[ntanks], &mytanks[ntanks], lenv, argv[i])) {
|
||||
ntanks += 1;
|
||||
}
|
||||
}
|
||||
|
|
@ -546,7 +480,8 @@ main(int argc, char *argv[])
|
|||
{
|
||||
int x, y;
|
||||
|
||||
for (x = 1; x * x < ntanks; x += 1);
|
||||
for (x = 1; x * x < ntanks; x += 1)
|
||||
;
|
||||
y = ntanks / x;
|
||||
if (ntanks % x) {
|
||||
y += 1;
|
||||
|
|
@ -570,8 +505,8 @@ main(int argc, char *argv[])
|
|||
|
||||
/* Position tanks */
|
||||
{
|
||||
int x = SPACING/2;
|
||||
int y = SPACING/2;
|
||||
int x = SPACING / 2;
|
||||
int y = SPACING / 2;
|
||||
|
||||
for (i = 0; i < ntanks; i += 1) {
|
||||
mytanks[order[i]].position[0] = (float)x;
|
||||
|
|
|
|||
Loading…
Reference in New Issue