Shape create_rounded_rectangle(CSize size, float radius, int round_count, const vec4 color)
{
int real_vertex_count = size_of_rounded_rectangle_in_vertices(round_count);
Params params = default_params();
params.const_params.datasize = sizeof(CPoint)*real_vertex_count*2;
params.const_params.round_count=round_count;
params.const_params.triangle_mode = GL_TRIANGLE_FAN;
params.var_params.size=size;
params.var_params.radius=radius;
CPoint *data = malloc(params.const_params.datasize);
gen_rounded_rectangle(data, params.var_params.size, params.var_params.radius, params.const_params.round_count);
/*
char str[150];
sprintf(str, "rounded_rectangle_data_size(%d) = %d", real_vertex_count, rounded_rectangle_data_size(real_vertex_count));
DEBUG_LOG_WRITE_D("fps>",str);
*/
return (Shape) { {color[0], color[1], color[2], color[3]},
data,
create_vbo(params.const_params.datasize, data, GL_DYNAMIC_DRAW),
real_vertex_count,
params
};
}
int main(int argc, char *argv[])
{
char buf[128];
key = ftok("server.c", 888);
default_params(¶ms);
parse_cmdline(argc, argv, ¶ms);
fifo = open(params.fifo_path, O_RDWR);
if (fifo < 0)
die("open");
sem = semget(key, 0, 0);
if (sem < 0)
die("semget");
sem_op(0, -1);
snprintf(buf, 128, "%s", params.message);
write(fifo, buf, strlen(buf) + 1);
sem_op(1, 0);
sem_op(-1, -1);
read(fifo, buf, 128);
printf("Read from server: '%s'\n", buf);
sem_op(0, 1);
return 0;
}
static void decode_params(game_params *params, char const *string)
{
char const *p = string;
game_params *defs = default_params();
*params = *defs; free_params(defs);
while (*p) {
switch (*p++) {
case 'w':
params->w = atoi(p);
while (*p && isdigit((unsigned char)*p)) p++;
break;
case 'h':
params->h = atoi(p);
while (*p && isdigit((unsigned char)*p)) p++;
break;
case 'm':
params->minballs = atoi(p);
while (*p && isdigit((unsigned char)*p)) p++;
break;
case 'M':
params->maxballs = atoi(p);
while (*p && isdigit((unsigned char)*p)) p++;
break;
default:
;
}
}
}
/*@T
*
* The [[get_params]] function uses the [[getopt]] package
* to handle the actual argument processing. Note that
* [[getopt]] is {\em not} thread-safe! You will need to
* do some synchronization if you want to use this function
* safely with threaded code.
*@c*/
int get_params(int argc, char** argv, sim_param_t* params)
{
extern char* optarg;
const char* optstring = "ho:F:f:t:s:d:k:v:g:";
int c;
#define get_int_arg(c, field) \
case c: params->field = atoi(optarg); break
#define get_flt_arg(c, field) \
case c: params->field = (float) atof(optarg); break
default_params(params);
while ((c = getopt(argc, argv, optstring)) != -1) {
switch (c) {
case 'h':
print_usage();
return -1;
case 'o':
strcpy(params->fname = malloc(strlen(optarg)+1), optarg);
break;
get_int_arg('F', nframes);
get_int_arg('f', npframe);
get_flt_arg('t', dt);
get_flt_arg('s', h);
get_flt_arg('d', rho0);
get_flt_arg('k', k);
get_flt_arg('v', mu);
get_flt_arg('g', g);
default:
fprintf(stderr, "Unknown option\n");
return -1;
}
}
return 0;
}
int main(int argc, char *argv[])
{
struct sigaction sigact;
atexit(clean_up);
if (log_init() < 0) {
fprintf(stderr, "Log system failed to start, aborting\n");
exit (-1);
}
default_params(¶ms);
parse_cmdline(argc, argv, ¶ms);
if (strcmp(params.log_file_path, "-") == 0)
params.log_file = 2; //stderr
else
params.log_file = open(params.log_file_path, O_CREAT | O_TRUNC | O_RDWR, 0640);
if (params.log_file < 0) {
perror("open()");
params.log_file = 1; //stdout
logit(L_WARNING "Failed to open log file for writing, logging to stdout...");
}
logit(L_DEBUG "Command line parameters:\n"
"\tverb_level:\t%d\n"
"\tdaemonize:\t%d\n"
"\tlog_file_path:\t%s\n"
"\tmax_clients:\t%d\n"
"\tserver_port:\t%d\n",
params.verb_level, params.daemonize, params.log_file_path,
params.max_clients, params.server_port);
clients = calloc(params.max_clients, sizeof(struct client*));
if (clients == NULL) {
perror("calloc");
exit(-3);
}
sigemptyset(&sigact.sa_mask);
sigact.sa_flags = SA_SIGINFO;
sigact.sa_sigaction = signal_handler;
sigaction(SIGINT, &sigact, NULL);
sigaction(SIGTERM, &sigact, NULL);
sigaction(SIGCHLD, &sigact, NULL);
logit(L_INFO "Starting server");
start_server(¶ms);
clean_up();
return 0;
}
static int game_fetch_preset(int i, char **name, game_params **params)
{
if (i == 0) {
*params = default_params();
*name = dupstr("4x4");
return TRUE;
}
return FALSE;
}
void create::initialize_()
{
auto params = default_params({{"name", name_}});
auto result_ob = slack_private::get(this, "channels.create", params);
if(this->success())
{
if (result_ob["channel"].isObject()) channel = slack::channel{result_ob["channel"]};
}
}
void update::initialize_()
{
auto params = default_params({
{"ts", ts_},
{"channel", channel_},
{"text", text_}
});
//optional parameters
if (parse_)
{
std::string parse_val{"none"};
switch (*parse_)
{
case parameter::parse::none:
parse_val = "none";
break;
case parameter::parse::full:
parse_val = "full";
break;
}
params.emplace("parse", parse_val);
}
if (link_names_)
{
params.emplace("link_names", (*link_names_ ? "true" : "false"));
}
if (attachments_)
{
//TODO this is ugly, but we need json strings.
Json::Value root;
for (auto &a : *attachments_)
{
root.append(a);
}
//TODO there is probably a better way?
std::stringstream ss;
ss << root;
params.emplace("attachments", ss.str());
}
auto result_ob = slack_private::get(this, "chat.update", params);
if(this->success())
{
if (result_ob["channel"].isString()) channel = slack::channel_id{result_ob["channel"].asString()};
if (result_ob["ts"].isString()) ts = slack::ts{result_ob["ts"].asString()};
if (result_ob["text"].isString()) text = result_ob["text"].asString();
}
}
static void decode_params(game_params *params, char const *string)
{
char const *p = string;
game_params *defs = default_params();
*params = *defs; free_params(defs);
while (*p) {
switch (*p++) {
case 'c':
params->ncolours = atoi(p);
while (*p && isdigit((unsigned char)*p)) p++;
break;
case 'p':
params->npegs = atoi(p);
while (*p && isdigit((unsigned char)*p)) p++;
break;
case 'g':
params->nguesses = atoi(p);
while (*p && isdigit((unsigned char)*p)) p++;
break;
case 'b':
params->allow_blank = true;
break;
case 'B':
params->allow_blank = false;
break;
case 'm':
params->allow_multiple = true;
break;
case 'M':
params->allow_multiple = false;
break;
default:
;
}
}
}
Shape create_rectangle(CSize size, const vec4 color)
{
int real_vertex_count = 4;
Params params = default_params();
params.const_params.datasize = sizeof(CPoint)*real_vertex_count;
params.const_params.triangle_mode = GL_TRIANGLE_STRIP;
CPoint *data = malloc(params.const_params.datasize);
gen_rectangle(data, size);
return (Shape) { {color[0], color[1], color[2], color[3]},
data,
create_vbo(params.const_params.datasize, data, GL_DYNAMIC_DRAW),
real_vertex_count,
params
};
}
int main(int argc, const char* argv[]){
/*
*
*/
//bool *passive;
//float **catalogue;
struct Params p;
struct Catalogue cat;
gsl_rng *rng;
// Initialise RNG
gsl_rng_env_setup();
rng = gsl_rng_alloc( gsl_rng_default );
// Set default values of model parameters
default_params(&p);
// Load halo catalogue
// malloc: mhalo, z
load_halos_from_file("test.dat", &cat);
// Allocate arrays for catalogue variables
cat.mstar = (float*)malloc(sizeof(float) * (cat.nhalos));
cat.sfr = (float*)malloc(sizeof(float) * (cat.nhalos));
cat.passive = (bool*)malloc(sizeof(bool) * (cat.nhalos));
// Realise all variables in catalogue
realise_physical_properties(&cat, p, rng);
// Output catalogue to file
save_catalogue("mock.dat", &cat);
// Free halo catalogue arrays
free(cat.mhalo);
free(cat.z);
free(cat.mstar);
free(cat.sfr);
free(cat.passive);
// Free GSL RNG objects
gsl_rng_free(rng);
return 0;
}
TexturedShape create_textured_rectangle(CSize size, GLuint texture)
{
int real_vertex_count = 4;
Params params = default_params();
params.const_params.datasize = sizeof(CPoint) * real_vertex_count * 2;
params.const_params.triangle_mode = GL_TRIANGLE_STRIP;
CPoint *data = malloc(params.const_params.datasize);
gen_textured_rectangle(data, size);
return (TexturedShape) {
texture,
data,
create_vbo(params.const_params.datasize, data, GL_STATIC_DRAW),
real_vertex_count,
params
};
}
TexturedShape create_segmented_square(float side_length, float start_angle, float end_angle, GLuint texture)
{
int real_vertex_count = size_of_segmented_square_in_vertices();
Params params = default_params();
params.const_params.datasize = sizeof(CPoint) * real_vertex_count * 2 * 2;
params.const_params.triangle_mode = GL_TRIANGLE_FAN;
CPoint *data = malloc(params.const_params.datasize);
gen_segmented_square(data, side_length, start_angle, end_angle);
return (TexturedShape) {
texture,
data,
create_vbo(params.const_params.datasize, data, GL_DYNAMIC_DRAW),
real_vertex_count,
params
};
}
Shape create_segmented_circle(float radius, int vertex_count, float start_angle, float angle, const vec4 color)
{
int real_vertex_count = size_of_segmented_circle_in_vertices(vertex_count);
Params params=default_params();
params.const_params.datasize = sizeof(CPoint)*real_vertex_count;
params.const_params.triangle_mode=GL_TRIANGLE_FAN;
params.const_params.round_count=vertex_count;
CPoint *data = malloc(params.const_params.datasize);
gen_segmented_circle(data, radius, start_angle, angle, vertex_count);
return (Shape) { {color[0], color[1], color[2], color[3]},
data,
create_vbo(params.const_params.datasize, data, GL_DYNAMIC_DRAW),
real_vertex_count,
params
};
}
static void print_usage()
{
sim_param_t param;
default_params(¶m);
fprintf(stderr,
"nbody\n"
"\t-h: print this message\n"
"\t-o: output file name (%s)\n"
"\t-F: number of frames (%d)\n"
"\t-f: steps per frame (%d)\n"
"\t-t: time step (%e)\n"
"\t-s: particle size (%e)\n"
"\t-d: reference density (%g)\n"
"\t-k: bulk modulus (%g)\n"
"\t-v: dynamic viscosity (%g)\n"
"\t-g: gravitational strength (%g)\n",
param.fname, param.nframes, param.npframe,
param.dt, param.h, param.rho0,
param.k, param.mu, param.g);
}
Shape create_ribbon(float length, const vec4 color)
{
int real_vertex_count = 4;
Params params=default_params();
params.const_params.datasize = sizeof(CPoint)*real_vertex_count;
params.const_params.triangle_mode = GL_TRIANGLE_STRIP;
params.var_params.side_length=length;
CPoint *data = malloc(params.const_params.datasize);
gen_ribbon(data, length);
return (Shape) { {color[0], color[1], color[2], color[3]},
data,
create_vbo(params.const_params.datasize, data, GL_DYNAMIC_DRAW),
real_vertex_count,
params
};
}
int main(int argc, char *argv[])
{
int cmd = 0;
char *buf;
key = ftok("server.c", 113);
default_params(¶ms);
parse_cmdline(argc, argv, ¶ms);
sem = semget(key, 0, 0);
if (sem < 0)
die("semget");
shm = shmget(key, params.shm_size, 0);
if (shm < 0)
die("shmget");
shm_data = shmat(shm, NULL, 0);
sem_op(0, -1);
if (!strcmp(params.message, "exit"))
cmd = -1;
((int*)shm_data)[0] = cmd;
buf = shm_data + sizeof(int);
snprintf(buf, params.shm_size, "%s", params.message);
sem_op(1, 0);
sem_op(-1, -1);
if (cmd >= 0)
printf("Read from server: '%s'\n", buf);
sem_op(0, 1);
return 0;
}
Shape create_infinity(float width, float angle, int segment_count, const vec4 color)
{
int real_vertex_count = size_of_infinity_in_vertices(segment_count);
Params params=default_params();
params.const_params.datasize = sizeof(CPoint)*real_vertex_count;
params.const_params.triangle_mode=GL_TRIANGLE_STRIP;
params.const_params.round_count=segment_count;
params.var_params.width = width;
params.var_params.angle = angle;
CPoint *data = malloc(params.const_params.datasize);
gen_infinity(data, width, angle, segment_count);
return (Shape) { {color[0], color[1], color[2], color[3]},
data,
create_vbo(params.const_params.datasize, data, GL_DYNAMIC_DRAW),
real_vertex_count,
params
};
}
Shape create_rounded_rectangle_stroked(CSize size, float radius, float stroke_width, int round_count, const vec4 color)
{
// round_count == 10 : polygons fall out
int real_vertex_count = size_of_rounded_rectangle_stroked_in_vertices(round_count);
Params params = default_params();
params.const_params.round_count=round_count;
params.const_params.datasize = sizeof(CPoint)*real_vertex_count*2;
params.var_params.size=size;
params.var_params.radius=radius;
params.var_params.width=stroke_width;
CPoint *data = malloc(params.const_params.datasize);
gen_rounded_rectangle_stroked(data, params.var_params.size, params.var_params.radius, params.var_params.width, params.const_params.round_count);
params.const_params.triangle_mode = GL_TRIANGLE_STRIP;
return (Shape) { {color[0], color[1], color[2], color[3]},
data,
create_vbo(params.const_params.datasize, data, GL_DYNAMIC_DRAW),
real_vertex_count,
params
};
}
int main(int argc, FAR char *argv[]) {
#else
int pwm_test_main(int argc, char *argv[]) {
#endif
struct device *dev;
struct pwm_app_info *info = NULL;
uint16_t count;
uint32_t ret = 0;
int i;
info = zalloc(sizeof(struct pwm_app_info));
if (!info) {
printf("pwm_test: App initialization failed!\n");
return EXIT_FAILURE;
}
default_params(info);
if (comm_parse(info, argc, argv)) {
print_usage();
goto err_free_info;
}
dev = device_open(DEVICE_TYPE_PWM_HW, 0);
if (!dev) {
printf("pwm_test: Open PWM controller driver failure!\n");
ret = EXIT_FAILURE;
goto err_free_info;
}
device_pwm_get_count(dev, &count);
if (info->index > count) {
printf("pwm_test: pwm%u > maximum supported number %u\n", info->index,
count);
print_usage();
ret = EXIT_FAILURE;
goto err_out;
}
if (!info->is_mode_test) {
ret = pwm_configure(dev, info, false);
if (ret) {
printf("pwm_test: Failed to enabled PWM%u \n", info->index);
goto err_out;
}
} else {
switch (info->mode_num) {
case PWM_PULSECOUNT_MODE:
if (info->param < 1) {
printf("pwm_test: mode 0 of -a must > 0\n");
print_usage();
ret = EXIT_FAILURE;
goto err_out;
}
info->secs = ((info->period/1000000000) * info->param) < 1 ? 1 :
(info->period/1000000000) * info->param;
ret = pwm_configure(dev, info, true);
if (ret) {
printf("pwm_test: mode 0, set generator(%u) in mode(%u) has "
"failed\n", info->index, info->mode_num);
goto err_out;
}
break;
case PWM_STOP_LEVEL_MODE:
ret = pwm_configure(dev, info, true);
if (ret) {
printf("pwm_test: mode1, set generator(%u) in mode(%u) has "
"failed\n", info->index, info->mode_num);
goto err_out;
}
break;
case PWM_SYNC_MODE:
/**
* This case will test all supported generstors to output waveform
* at sametime that have same period configuration.
*/
info->param = 1;
for (i = 0; i < count; i++) {
ret = device_pwm_activate(dev, i);
if (ret) {
printf("pwm_test: mode2, active generator(%d) return "
"error(%x)\n", i, ret);
break;
}
ret = device_pwm_config(dev, i, info->period /(2+i),
info->period);
if (ret) {
printf("pwm_test: mode2, config generator(%d) return "
"error(%x)\n", i, ret);
break;
}
ret = device_pwm_set_mode(dev, i, info->mode_num, &info->param);
if (ret) {
printf("pwm_test: mode 2, set generator(%d) of SELENB bit "
"return error(%x)\n", i, ret);
break;
}
}
if (ret) {
/**
* Make sure already activated pwm can be deactivated if has
* error.
*/
for (; i >= 0; i--) {
device_pwm_deactivate(dev, i);
}
goto err_out;
}
device_pwm_sync_output(dev, true);
break;
default:
print_usage();
ret = EXIT_FAILURE;
goto err_out;
}
}
dump_params(info);
printf("pwm_test: Enabled PWM%u for a duration of %u seconds\n",
info->index, info->secs);
sleep((unsigned int)info->secs);
if (info->is_mode_test && (info->mode_num == PWM_PULSECOUNT_MODE)) {
printf("pwm_test: test completed, callback interrupt value "
"= %u and error value = %u\n", val_int, val_err);
} else {
printf("pwm_test: test completed\n");
}
err_out:
device_close(dev);
err_free_info:
free(info);
return ret;
}
int main(int argc, char **argv)
{
game_params *p;
game_state *s;
char *id = NULL, *desc, *err;
int grade = FALSE;
int ret, diff, really_show_working = FALSE;
while (--argc > 0) {
char *p = *++argv;
if (!strcmp(p, "-v")) {
really_show_working = TRUE;
} else if (!strcmp(p, "-g")) {
grade = TRUE;
} else if (*p == '-') {
fprintf(stderr, "%s: unrecognised option `%s'\n", argv[0], p);
return 1;
} else {
id = p;
}
}
if (!id) {
fprintf(stderr, "usage: %s [-g | -v] <game_id>\n", argv[0]);
return 1;
}
desc = strchr(id, ':');
if (!desc) {
fprintf(stderr, "%s: game id expects a colon in it\n", argv[0]);
return 1;
}
*desc++ = '\0';
p = default_params();
decode_params(p, id);
err = validate_desc(p, desc);
if (err) {
fprintf(stderr, "%s: %s\n", argv[0], err);
return 1;
}
s = new_game(NULL, p, desc);
/*
* When solving an Easy puzzle, we don't want to bother the
* user with Hard-level deductions. For this reason, we grade
* the puzzle internally before doing anything else.
*/
ret = -1; /* placate optimiser */
solver_show_working = FALSE;
for (diff = 0; diff < DIFFCOUNT; diff++) {
memcpy(s->grid, s->clues->immutable, p->w * p->w);
ret = solver(p->w, s->clues->clues, s->grid, diff);
if (ret <= diff)
break;
}
if (diff == DIFFCOUNT) {
if (grade)
printf("Difficulty rating: ambiguous\n");
else
printf("Unable to find a unique solution\n");
} else {
if (grade) {
if (ret == diff_impossible)
printf("Difficulty rating: impossible (no solution exists)\n");
else
printf("Difficulty rating: %s\n", towers_diffnames[ret]);
} else {
solver_show_working = really_show_working;
memcpy(s->grid, s->clues->immutable, p->w * p->w);
ret = solver(p->w, s->clues->clues, s->grid, diff);
if (ret != diff)
printf("Puzzle is inconsistent\n");
else
fputs(game_text_format(s), stdout);
}
}
return 0;
}
