int parsing(t_env *data)
{
char *line;
int ret;
line = NULL;
while (!(data->ants))
get_ants(data, line);
while ((ret = get_next_line(0, &line)))
{
if (!check_line(&line, data))
{
if (!can_start(data))
parsing_error(data, line);
ft_strdel(&line);
ft_putchar('\n');
return (solve(data));
}
ft_putendl(line);
ft_strdel(&line);
}
if (ret == -1)
ft_error("read");
ft_putchar('\n');
if (!can_start(data))
parsing_error(data, line);
return (solve(data));
}
errval_t default_start_function(coreid_t where,
struct module_info* mi,
char* record)
{
assert(mi != NULL);
errval_t err = SYS_ERR_OK;
coreid_t core;
/*
* XXX: there may be more device using this driver, so starting it a second time
* may be needed.
*/
if (!can_start(mi)) {
return KALUGA_ERR_DRIVER_ALREADY_STARTED;
}
core = where + get_core_id_offset(mi);
if (!is_auto_driver(mi)) {
return KALUGA_ERR_DRIVER_NOT_AUTO;
}
// Construct additional command line arguments containing pci-id.
// We need one extra entry for the new argument.
uint64_t vendor_id, device_id, bus, dev, fun;
char **argv = mi->argv;
bool cleanup = false;
err = oct_read(record, "_ { bus: %d, device: %d, function: %d, vendor: %d, device_id: %d }",
&bus, &dev, &fun, &vendor_id, &device_id);
if (err_is_ok(err)) {
// We assume that we're starting a device if the query above succeeds
// and therefore append the pci vendor and device id to the argument
// list.
argv = malloc((mi->argc+1) * sizeof(char *));
memcpy(argv, mi->argv, mi->argc * sizeof(char *));
char *pci_id = malloc(26);
// Make sure pci vendor and device id fit into our argument
assert(vendor_id < 0x9999 && device_id < 0x9999);
snprintf(pci_id, 26, "%04"PRIx64":%04"PRIx64":%04"PRIx64":%04"
PRIx64":%04"PRIx64, vendor_id, device_id, bus, dev, fun);
argv[mi->argc] = pci_id;
argv[mi->argc+1] = NULL;
cleanup = true;
}
err = spawn_program(core, mi->path, argv,
environ, 0, get_did_ptr(mi));
if (err_is_fail(err)) {
DEBUG_ERR(err, "Spawning %s failed.", mi->path);
}
if (cleanup) {
// alloc'd string is the last of our array
free(argv[mi->argc]);
free(argv);
}
return err;
}
void start_game() {
if (!can_start()) {
fprintf(stderr, "Couldn't start the game (not all players are online)\n");
return;
}
save_state();
server_message_t msg = { 0, { GAME_START }};
broadcast_message(&msg);
printf("Game has started!\n");
start_resources_production();
}
void wait_for_player(t_ipc *my_ipc)
{
t_map *info;
printf("[console] You got 20 second to conect some player\n");
sleep(20);
while (!can_start(info))
{
printf("[console] You got 10 second to adjust the team\n");
printf("[console] there is %d players in team 1\n", info->nb_team1);
printf("[console] there is %d players in team 2\n", info->nb_team2);
sleep(10);
info = get_info(my_ipc);
}
printf("[console] game is ready to begin");
free(info);
}
/*
* Show CAN errors as text,
* in case of Bus-Off, try to recover
*/
static void displayerror(int device, canmsg_t *rx)
{
/* static int buffcnt = 0; */
fprintf(stderr, "Flags 0x%02x,", rx->flags);
if( 0 == (rx->flags & MSG_ERR_MASK)) {
fprintf(stderr, " CAN Error Free");
}
if( rx->flags & MSG_WARNING) {
fprintf(stderr, " CAN Warning Level,");
}
if( rx->flags & MSG_PASSIVE) {
fprintf(stderr, " CAN Error Passive,");
}
if( rx->flags & MSG_BUSOFF) {
fprintf(stderr, " CAN Bus Off,");
can_reset(fd[device]);
/* sleep 100ms */
usleep (100000);
can_start(fd[device]);
}
/* printf("\n"); */
}
LONG cop_init(LONG board, LPVOID param, BYTE baudrate)
{
// 1. Exit CAN if initialized or running
if((cop_error = can_exit()) != CANERR_NOERROR)
{
//return cop_error;
}
// 2. Init CAN, operation status = initialized
if((cop_error = can_init(board, param)) != CANERR_NOERROR)
{
can_exit(); // on error: exit CAN
return cop_error;
}
// 3. Start CAN, operation status = running
if((cop_error = can_start(baudrate)) != CANERR_NOERROR)
{
can_reset(); // on error: reset CAN
can_exit(); // exit CAN
return cop_error;
}
cop_baudrate = baudrate; // actual baudrate
return cop_error;
}
LONG cop_reset(BYTE baudrate)
{
// 1. Reset CAN, operation status = stopped
if((cop_error = can_reset()) != CANERR_NOERROR)
{
return cop_error;
}
// 2. Wait 100 milliseconds to continue
#if defined(_WIN32)
Sleep(100);
#elif defined(__linux__)
usleep(100000);
#else
can_start_timer(100); while(!can_is_timeout()) {}
#endif
// 3. Start CAN, operation status = running
if((cop_error = can_start(baudrate)) != CANERR_NOERROR)
{
can_reset(); // on error: reset CAN
return cop_error;
}
cop_baudrate = baudrate; // actual baudrate
return cop_error;
}
