void show_textfile(const char *file_name) { char *buf; unsigned int file_size; unsigned int line_count; unsigned int i; const char **lines; const char *start_line; buf = read_file(file_name, &file_size); if (!buf) return; line_count = 0; for (i = 0; i < file_size; ++i) line_count += buf[i] == '\n'; lines = ccalloc(line_count, sizeof *lines); line_count = 0; start_line = buf; for (i = 0; i < file_size; ++i) { if (buf[i] == '\n') { lines[line_count++] = start_line; buf[i] = '\0'; start_line = &buf[i + 1]; } if (buf[i] == '\t') buf[i] = ' '; } create_text_box(lines, line_count, file_name, attr_textbox); free(lines); free(buf); }
struct board *create_buffer_board(int width, int height) { // Create a dummy board to be used as a buffer for undo block actions struct board *src_board = ccalloc(1, sizeof(struct board)); int layer_size = width * height; src_board->board_width = width; src_board->board_height = height; src_board->robot_list = ccalloc(1, sizeof(struct robot *)); src_board->scroll_list = ccalloc(1, sizeof(struct scroll *)); src_board->sensor_list = ccalloc(1, sizeof(struct sensor *)); src_board->level_id = ccalloc(1, layer_size); src_board->level_color = ccalloc(1, layer_size); src_board->level_param = ccalloc(1, layer_size); src_board->level_under_id = ccalloc(1, layer_size); src_board->level_under_color = ccalloc(1, layer_size); src_board->level_under_param = ccalloc(1, layer_size); return src_board; }
static char *dup_current_name(void) { int rows, cols, max, i; char *s; if (form_driver(form, REQ_VALIDATION) == E_OK) { dynamic_field_info(fields[1], &rows, &cols, &max); s = ccalloc(1, cols + 1); memcpy(s, field_buffer(fields[1], 0), cols); for (i = strlen(s) - 1; i >= 0 && s[i] == ' '; --i) s[i] = '\0'; return s; } else { return cstrdup(""); } }
static void delete_hook(const char *file) { struct manifest_entry *new_entry; struct SHA256_ctx ctx; bool ret; FILE *f; new_entry = ccalloc(1, sizeof(struct manifest_entry)); if(!new_entry) goto err_out; if(delete_p) { delete_p->next = new_entry; delete_p = delete_p->next; } else delete_list = delete_p = new_entry; delete_p->name = cmalloc(strlen(file) + 1); if(!delete_p->name) goto err_delete_p; strcpy(delete_p->name, file); f = fopen_unsafe(file, "rb"); if(!f) goto err_delete_p_name; delete_p->size = (unsigned long)ftell_and_rewind(f); ret = manifest_compute_sha256(&ctx, f, delete_p->size); fclose(f); if(!ret) goto err_delete_p_name; memcpy(delete_p->sha256, ctx.H, sizeof(Uint32) * 8); return; err_delete_p_name: free(delete_p->name); err_delete_p: free(delete_p); delete_p = NULL; err_out: return; }
static void create_text_box(const char *const *lines, unsigned int count, const char *title_, int attrs) { unsigned int i; text_lines = ccalloc(count, sizeof *text_lines); for (i = 0; i < count; ++i) text_lines[i] = cstrdup(lines[i]); text_lines_count = count; max_line_width = get_max_mbs_width(lines, count); title = cstrdup(title_); widget_attrs = attrs; current_top = 0; current_left = 0; create(); }
struct host *host_accept(struct host *s) { struct sockaddr *addr; struct host *c = NULL; socklen_t addrlen; int newfd; switch(s->af) { #ifdef CONFIG_IPV6 case AF_INET6: addrlen = sizeof(struct sockaddr_in6); break; #endif default: addrlen = sizeof(struct sockaddr_in); break; } addr = cmalloc(addrlen); newfd = platform_accept(s->fd, addr, &addrlen); if(newfd >= 0) { assert(addr->sa_family == s->af); platform_socket_blocking(newfd, true); c = ccalloc(1, sizeof(struct host)); c->af = addr->sa_family; c->proto = s->proto; c->name = NULL; c->fd = newfd; } else { if(platform_last_error_fatal()) platform_perror("accept"); } free(addr); return c; }
int VariantFindFreePositionInFrame(DataStructure *dataStructure, VariantFrame *frame, int signalIndex, int startPosition) { int i, j, freeBytesInSequence, bestFoundOffset, last, currentFreeOffset; if ((frame->node != dataStructure->signalNodeIDs[signalIndex]) && (frame->node != -1)) return -1; char *messagePositions = (char *) ccalloc(dataStructure->slotLength, sizeof(char)); for (i = 0; i < (int) frame->signals.size(); i++) // For each signal in frame { for (j = dataStructure->signalInFrameOffsets[frame->signals[i]]; j < dataStructure->signalInFrameOffsets[frame->signals[i]] + dataStructure->signalLengths[frame->signals[i]]; j++) { messagePositions[j] = 1; } } bestFoundOffset = -1; freeBytesInSequence = 0; last = 1; currentFreeOffset = 0; for (i = startPosition; i < dataStructure->slotLength; i++) { if (messagePositions[i] == 1) { if (freeBytesInSequence >= dataStructure->signalLengths[signalIndex]) { bestFoundOffset = currentFreeOffset; break; } freeBytesInSequence = 0; last = 1; } else { if (last == 1) currentFreeOffset = i; freeBytesInSequence++; last = 0; } } if (freeBytesInSequence >= dataStructure->signalLengths[signalIndex] && bestFoundOffset == -1) { bestFoundOffset = currentFreeOffset; } ffree(messagePositions); return bestFoundOffset; }
static void create_blank_board(struct board *cur_board) { int size = 2000; cur_board->overlay_mode = 0; cur_board->board_width = 80; cur_board->board_height = 25; cur_board->level_id = ccalloc(1, size); cur_board->level_color = ccalloc(1, size); cur_board->level_param = ccalloc(1, size); cur_board->level_under_id = ccalloc(1, size); cur_board->level_under_color = ccalloc(1, size); cur_board->level_under_param = ccalloc(1, size); strcpy(cur_board->mod_playing, ""); cur_board->viewport_x = 0; cur_board->viewport_y = 0; cur_board->viewport_width = 80; cur_board->viewport_height = 25; cur_board->can_shoot = 0; cur_board->can_bomb = 0; cur_board->fire_burn_brown = 0; cur_board->fire_burn_space = 0; cur_board->fire_burn_fakes = 0; cur_board->fire_burn_trees = 0; cur_board->explosions_leave = 0; cur_board->save_mode = 1; cur_board->forest_becomes = 0; cur_board->collect_bombs = 0; cur_board->fire_burns = 0; cur_board->board_dir[0] = 0; cur_board->board_dir[1] = 0; cur_board->board_dir[2] = 0; cur_board->board_dir[3] = 0; cur_board->restart_if_zapped = 0; cur_board->time_limit = 0; cur_board->last_key = 0; cur_board->num_input = 0; cur_board->input_size = 0; strcpy(cur_board->input_string, ""); cur_board->player_last_dir = 0; strcpy(cur_board->bottom_mesg, ""); cur_board->b_mesg_timer = 0; cur_board->lazwall_start = 0; cur_board->b_mesg_row = 24; cur_board->b_mesg_col = -1; cur_board->scroll_x = 0; cur_board->scroll_y = 0; cur_board->locked_x = 0; cur_board->locked_y = 0; cur_board->player_ns_locked = 0; cur_board->player_ew_locked = 0; cur_board->player_attack_locked = 0; cur_board->volume = 0; cur_board->volume_inc = 0; cur_board->volume_target = 0; cur_board->num_robots = 0; cur_board->num_robots_active = 0; cur_board->num_robots_allocated = 0; cur_board->robot_list = ccalloc(1, sizeof(struct robot *)); cur_board->robot_list_name_sorted = ccalloc(1, sizeof(struct robot *)); cur_board->num_scrolls = 0; cur_board->num_scrolls_allocated = 0; cur_board->scroll_list = ccalloc(1, sizeof(struct scroll *)); cur_board->num_sensors = 0; cur_board->num_sensors_allocated = 0; cur_board->sensor_list = ccalloc(1, sizeof(struct sensor *)); }
__editor_maybe_static int load_board_direct(struct board *cur_board, FILE *fp, int data_size, int savegame, int version) { int num_robots, num_scrolls, num_sensors, num_robots_active; int overlay_mode, size, board_width, board_height, i; int viewport_x, viewport_y, viewport_width, viewport_height; int truncated = 0; struct robot *cur_robot; struct scroll *cur_scroll; struct sensor *cur_sensor; char *test_buffer; int board_location = ftell(fp); cur_board->num_robots = 0; cur_board->num_robots_allocated = 0; cur_board->num_robots_active = 0; cur_board->num_scrolls = 0; cur_board->num_scrolls_allocated = 0; cur_board->num_sensors = 0; cur_board->num_sensors_allocated = 0; cur_board->robot_list = NULL; cur_board->robot_list_name_sorted = NULL; cur_board->sensor_list = NULL; cur_board->scroll_list = NULL; // Initialize some fields that may no longer be loaded // from the board file itself.. cur_board->last_key = '?'; cur_board->num_input = 0; cur_board->input_size = 0; cur_board->input_string[0] = 0; cur_board->player_last_dir = 0x10; cur_board->bottom_mesg[0] = 0; cur_board->b_mesg_timer = 0; cur_board->lazwall_start = 7; cur_board->b_mesg_row = 24; cur_board->b_mesg_col = -1; cur_board->scroll_x = 0; cur_board->scroll_y = 0; cur_board->locked_x = -1; cur_board->locked_y = -1; cur_board->volume = 255; cur_board->volume_inc = 0; cur_board->volume_target = 255; // board_mode, unused if(fgetc(fp) == EOF) { val_error(WORLD_BOARD_MISSING, board_location); return VAL_MISSING; } overlay_mode = fgetc(fp); if(!overlay_mode) { int overlay_width; int overlay_height; overlay_mode = fgetc(fp); overlay_width = fgetw(fp); overlay_height = fgetw(fp); size = overlay_width * overlay_height; if((size < 1) || (size > MAX_BOARD_SIZE)) goto err_invalid; cur_board->overlay = cmalloc(size); cur_board->overlay_color = cmalloc(size); if(load_RLE2_plane(cur_board->overlay, fp, size)) goto err_freeoverlay; test_buffer = cmalloc(1024); free(test_buffer); // Skip sizes if(fseek(fp, 4, SEEK_CUR) || load_RLE2_plane(cur_board->overlay_color, fp, size)) goto err_freeoverlay; test_buffer = cmalloc(1024); free(test_buffer); } else { overlay_mode = 0; // Undo that last get fseek(fp, -1, SEEK_CUR); } cur_board->overlay_mode = overlay_mode; board_width = fgetw(fp); board_height = fgetw(fp); cur_board->board_width = board_width; cur_board->board_height = board_height; size = board_width * board_height; if((size < 1) || (size > MAX_BOARD_SIZE)) goto err_freeoverlay; cur_board->level_id = cmalloc(size); cur_board->level_color = cmalloc(size); cur_board->level_param = cmalloc(size); cur_board->level_under_id = cmalloc(size); cur_board->level_under_color = cmalloc(size); cur_board->level_under_param = cmalloc(size); if(load_RLE2_plane(cur_board->level_id, fp, size)) goto err_freeboard; if(fseek(fp, 4, SEEK_CUR) || load_RLE2_plane(cur_board->level_color, fp, size)) goto err_freeboard; if(fseek(fp, 4, SEEK_CUR) || load_RLE2_plane(cur_board->level_param, fp, size)) goto err_freeboard; if(fseek(fp, 4, SEEK_CUR) || load_RLE2_plane(cur_board->level_under_id, fp, size)) goto err_freeboard; if(fseek(fp, 4, SEEK_CUR) || load_RLE2_plane(cur_board->level_under_color, fp, size)) goto err_freeboard; if(fseek(fp, 4, SEEK_CUR) || load_RLE2_plane(cur_board->level_under_param, fp, size)) goto err_freeboard; // Load board parameters if(version < 0x0253) { fread(cur_board->mod_playing, LEGACY_MOD_FILENAME_MAX, 1, fp); cur_board->mod_playing[LEGACY_MOD_FILENAME_MAX] = 0; } else { size_t len = fgetw(fp); if(len >= MAX_PATH) len = MAX_PATH - 1; fread(cur_board->mod_playing, len, 1, fp); cur_board->mod_playing[len] = 0; } viewport_x = fgetc(fp); viewport_y = fgetc(fp); viewport_width = fgetc(fp); viewport_height = fgetc(fp); if( (viewport_x < 0) || (viewport_x > 79) || (viewport_y < 0) || (viewport_y > 24) || (viewport_width < 1) || (viewport_width > 80) || (viewport_height < 1) || (viewport_height > 25)) goto err_invalid; cur_board->viewport_x = viewport_x; cur_board->viewport_y = viewport_y; cur_board->viewport_width = viewport_width; cur_board->viewport_height = viewport_height; cur_board->can_shoot = fgetc(fp); cur_board->can_bomb = fgetc(fp); cur_board->fire_burn_brown = fgetc(fp); cur_board->fire_burn_space = fgetc(fp); cur_board->fire_burn_fakes = fgetc(fp); cur_board->fire_burn_trees = fgetc(fp); cur_board->explosions_leave = fgetc(fp); cur_board->save_mode = fgetc(fp); cur_board->forest_becomes = fgetc(fp); cur_board->collect_bombs = fgetc(fp); cur_board->fire_burns = fgetc(fp); for(i = 0; i < 4; i++) { cur_board->board_dir[i] = fgetc(fp); } cur_board->restart_if_zapped = fgetc(fp); cur_board->time_limit = fgetw(fp); if(version < 0x0253) { cur_board->last_key = fgetc(fp); cur_board->num_input = fgetw(fp); cur_board->input_size = fgetc(fp); fread(cur_board->input_string, LEGACY_INPUT_STRING_MAX + 1, 1, fp); cur_board->input_string[LEGACY_INPUT_STRING_MAX] = 0; cur_board->player_last_dir = fgetc(fp); fread(cur_board->bottom_mesg, LEGACY_BOTTOM_MESG_MAX + 1, 1, fp); cur_board->bottom_mesg[LEGACY_BOTTOM_MESG_MAX] = 0; cur_board->b_mesg_timer = fgetc(fp); cur_board->lazwall_start = fgetc(fp); cur_board->b_mesg_row = fgetc(fp); cur_board->b_mesg_col = (signed char)fgetc(fp); cur_board->scroll_x = (signed short)fgetw(fp); cur_board->scroll_y = (signed short)fgetw(fp); cur_board->locked_x = (signed short)fgetw(fp); cur_board->locked_y = (signed short)fgetw(fp); } else if(savegame) { size_t len; cur_board->last_key = fgetc(fp); cur_board->num_input = fgetw(fp); cur_board->input_size = fgetw(fp); len = fgetw(fp); if(len >= ROBOT_MAX_TR) len = ROBOT_MAX_TR - 1; fread(cur_board->input_string, len, 1, fp); cur_board->input_string[len] = 0; cur_board->player_last_dir = fgetc(fp); len = fgetw(fp); if(len >= ROBOT_MAX_TR) len = ROBOT_MAX_TR - 1; fread(cur_board->bottom_mesg, len, 1, fp); cur_board->bottom_mesg[len] = 0; cur_board->b_mesg_timer = fgetc(fp); cur_board->lazwall_start = fgetc(fp); cur_board->b_mesg_row = fgetc(fp); cur_board->b_mesg_col = (signed char)fgetc(fp); cur_board->scroll_x = (signed short)fgetw(fp); cur_board->scroll_y = (signed short)fgetw(fp); cur_board->locked_x = (signed short)fgetw(fp); cur_board->locked_y = (signed short)fgetw(fp); } cur_board->player_ns_locked = fgetc(fp); cur_board->player_ew_locked = fgetc(fp); cur_board->player_attack_locked = fgetc(fp); if(version < 0x0253 || savegame) { cur_board->volume = fgetc(fp); cur_board->volume_inc = fgetc(fp); cur_board->volume_target = fgetc(fp); } /***************/ /* Load robots */ /***************/ num_robots = fgetc(fp); num_robots_active = 0; if(num_robots == EOF) truncated = 1; // EOF/crazy value check if((num_robots < 0) || (num_robots > 255) || (num_robots > size)) goto board_scan; cur_board->robot_list = ccalloc(num_robots + 1, sizeof(struct robot *)); // Also allocate for name sorted list cur_board->robot_list_name_sorted = ccalloc(num_robots, sizeof(struct robot *)); // Any null objects being placed will later be optimized out if(num_robots) { for(i = 1; i <= num_robots; i++) { // Make sure there's robots to load here int length_check = fgetw(fp); fseek(fp, -2, SEEK_CUR); if(length_check < 0) { // Send off the error and then tell validation to shut up for now val_error(WORLD_ROBOT_MISSING, ftell(fp)); set_validation_suppression(1); truncated = 1; } cur_robot = load_robot_allocate(fp, savegame, version); if(cur_robot->used) { cur_board->robot_list[i] = cur_robot; cur_board->robot_list_name_sorted[num_robots_active] = cur_robot; num_robots_active++; } else { // We don't need no null robot clear_robot(cur_robot); cur_board->robot_list[i] = NULL; } } } set_validation_suppression(-1); if(num_robots_active > 0) { if(num_robots_active != num_robots) { cur_board->robot_list_name_sorted = crealloc(cur_board->robot_list_name_sorted, sizeof(struct robot *) * num_robots_active); } qsort(cur_board->robot_list_name_sorted, num_robots_active, sizeof(struct robot *), cmp_robots); } else { free(cur_board->robot_list_name_sorted); cur_board->robot_list_name_sorted = NULL; } cur_board->num_robots = num_robots; cur_board->num_robots_allocated = num_robots; cur_board->num_robots_active = num_robots_active; /****************/ /* Load scrolls */ /****************/ num_scrolls = fgetc(fp); if(num_scrolls == EOF) truncated = 1; if((num_scrolls < 0) || (num_scrolls > 255) || (num_robots + num_scrolls > size)) goto board_scan; cur_board->scroll_list = ccalloc(num_scrolls + 1, sizeof(struct scroll *)); if(num_scrolls) { for(i = 1; i <= num_scrolls; i++) { cur_scroll = load_scroll_allocate(fp); if(cur_scroll->used) cur_board->scroll_list[i] = cur_scroll; else clear_scroll(cur_scroll); } } cur_board->num_scrolls = num_scrolls; cur_board->num_scrolls_allocated = num_scrolls; /****************/ /* Load sensors */ /****************/ num_sensors = fgetc(fp); if(num_sensors == EOF) truncated = 1; if((num_sensors < 0) || (num_sensors > 255) || (num_scrolls + num_sensors + num_robots > size)) goto board_scan; cur_board->sensor_list = ccalloc(num_sensors + 1, sizeof(struct sensor *)); if(num_sensors) { for(i = 1; i <= num_sensors; i++) { cur_sensor = load_sensor_allocate(fp); if(cur_sensor->used) cur_board->sensor_list[i] = cur_sensor; else clear_sensor(cur_sensor); } } cur_board->num_sensors = num_sensors; cur_board->num_sensors_allocated = num_sensors; board_scan: // Now do a board scan to make sure there aren't more than the data told us. { int robot_count = 0, scroll_count = 0, sensor_count = 0; char err_mesg[80] = { 0 }; for(i = 0; i < (board_width * board_height); i++) { if(cur_board->level_id[i] > 127) cur_board->level_id[i] = CUSTOM_BLOCK; if(cur_board->level_under_id[i] > 127) cur_board->level_under_id[i] = CUSTOM_FLOOR; switch(cur_board->level_id[i]) { case ROBOT: case ROBOT_PUSHABLE: { robot_count++; if(robot_count > cur_board->num_robots) { cur_board->level_id[i] = CUSTOM_BLOCK; cur_board->level_param[i] = 'R'; cur_board->level_color[i] = 0xCF; } break; } case SIGN: case SCROLL: { scroll_count++; if(scroll_count > cur_board->num_scrolls) { cur_board->level_id[i] = CUSTOM_BLOCK; cur_board->level_param[i] = 'S'; cur_board->level_color[i] = 0xCF; } } case SENSOR: { // Wait, I forgot. Nobody cares about sensors. //sensor_count++; if(sensor_count > cur_board->num_sensors) { cur_board->level_id[i] = CUSTOM_FLOOR; cur_board->level_param[i] = 'S'; cur_board->level_color[i] = 0xDF; } } } } if(robot_count > cur_board->num_robots) { snprintf(err_mesg, 80, "Board @ %Xh: found %i robots; expected %i", board_location, robot_count, cur_board->num_robots); error(err_mesg, 1, 8, 0); } if(scroll_count > cur_board->num_scrolls) { snprintf(err_mesg, 80, "Board @ %Xh: found %i scrolls/signs; expected %i", board_location, scroll_count, cur_board->num_scrolls); error(err_mesg, 1, 8, 0); } // This won't be reached but I'll leave it anyway. if(sensor_count > cur_board->num_sensors) { snprintf(err_mesg, 80, "Board @ %Xh: found %i sensors; expected %i", board_location, sensor_count, cur_board->num_sensors); error(err_mesg, 1, 8, 0); } if(err_mesg[0]) error("Any extra robots/scrolls/signs were replaced", 1, 8, 0); } if(truncated == 1) val_error(WORLD_BOARD_TRUNCATED_SAFE, board_location); return VAL_SUCCESS; err_freeboard: free(cur_board->level_id); free(cur_board->level_color); free(cur_board->level_param); free(cur_board->level_under_id); free(cur_board->level_under_color); free(cur_board->level_under_param); err_freeoverlay: if(overlay_mode) { free(cur_board->overlay); free(cur_board->overlay_color); } err_invalid: val_error(WORLD_BOARD_CORRUPT, board_location); return VAL_INVALID; }
struct host *host_create(enum host_type type, enum host_family fam) { struct linger linger = { 1, 30 }; const uint32_t on = 1; int err, fd, af, proto; struct host *h; switch(fam) { #ifdef CONFIG_IPV6 case HOST_FAMILY_IPV6: af = AF_INET6; break; #endif default: af = AF_INET; break; } switch(type) { case HOST_TYPE_UDP: fd = platform_socket(af, SOCK_DGRAM, IPPROTO_UDP); proto = IPPROTO_UDP; break; default: fd = platform_socket(af, SOCK_STREAM, IPPROTO_TCP); proto = IPPROTO_TCP; break; } if(fd < 0) { platform_perror("socket"); return NULL; } #if defined(CONFIG_IPV6) && defined(IPV6_V6ONLY) if(af == AF_INET6) { const uint32_t off = 0; err = platform_setsockopt(fd, IPPROTO_IPV6, IPV6_V6ONLY, (void *)&off, 4); if(err < 0) { platform_perror("setsockopt(IPV6_V6ONLY)"); return NULL; } } #endif /* We need to turn off bind address checking, allowing * port numbers to be reused; otherwise, TIME_WAIT will * delay binding to these ports for 2 * MSL seconds. */ err = platform_setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (void *)&on, 4); if(err < 0) { platform_perror("setsockopt(SO_REUSEADDR)"); return NULL; } /* When connection is closed, we want to "linger" to * make sure everything is transmitted. Enable this * feature here. However, we can only do this on TCP * sockets, as some platforms (winsock) don't like * modifying linger on UDP sockets. */ if(proto == IPPROTO_TCP) { err = platform_setsockopt(fd, SOL_SOCKET, SO_LINGER, (void *)&linger, sizeof(struct linger)); if(err < 0) { platform_perror("setsockopt(SO_LINGER)"); return NULL; } } // Initially the socket is blocking platform_socket_blocking(fd, true); // Create our "host" abstraction (latterly augmented) h = ccalloc(1, sizeof(struct host)); h->proto = proto; h->af = af; h->fd = fd; h->timeout_ms = HOST_TIMEOUT_DEFAULT; return h; }
void init_event(void) { input.buffer = ccalloc(num_buffered_events, sizeof(struct buffered_status)); input.load_offset = num_buffered_events - 1; input.store_offset = 0; }
struct manifest_entry *manifest_list_create(FILE *f) { struct manifest_entry *head = NULL, *e = NULL, *next_e; char buffer[LINE_BUF_LEN]; // Walk the manifest line by line while(true) { char *m = buffer, *line; size_t line_len; // Grab a single line from the manifest if(!fgets(buffer, LINE_BUF_LEN, f)) break; next_e = ccalloc(1, sizeof(struct manifest_entry)); if(head) { e->next = next_e; e = e->next; } else head = e = next_e; // Grab the sha256 token line = strsep(&m, " "); if(!line) goto err_invalid_manifest; /* Break the 64 character (8x8) hex string down into * eight constituent 32bit SHA result registers (32*8=256). */ if(!manifest_parse_sha256(line, e->sha256)) goto err_invalid_manifest; // Grab the size token line = strsep(&m, " "); if(!line) goto err_invalid_manifest; // Validate and parse it if(!manifest_parse_size(line, &e->size)) goto err_invalid_manifest; // Grab the filename token line = strsep(&m, "\n"); if(!line) goto err_invalid_manifest; line_len = strlen(line); e->name = cmalloc(line_len + 1); strncpy(e->name, line, line_len); e->name[line_len] = 0; } if(e) e->next = NULL; return head; err_invalid_manifest: warn("Malformed manifest file.\n"); manifest_list_free(&head); return head; }
__editor_maybe_static void load_board_direct(struct board *cur_board, FILE *fp, int savegame, int version) { int num_robots, num_scrolls, num_sensors, num_robots_active; int overlay_mode, size, board_width, board_height, i; struct robot *cur_robot; struct scroll *cur_scroll; struct sensor *cur_sensor; char *test_buffer; // Initialize some fields that may no longer be loaded // from the board file itself.. cur_board->last_key = '?'; cur_board->num_input = 0; cur_board->input_size = 0; cur_board->input_string[0] = 0; cur_board->player_last_dir = 0x10; cur_board->bottom_mesg[0] = 0; cur_board->b_mesg_timer = 0; cur_board->lazwall_start = 7; cur_board->b_mesg_row = 24; cur_board->b_mesg_col = -1; cur_board->scroll_x = 0; cur_board->scroll_y = 0; cur_board->locked_x = -1; cur_board->locked_y = -1; cur_board->volume = 255; cur_board->volume_inc = 0; cur_board->volume_target = 255; // board_mode, unused fgetc(fp); overlay_mode = fgetc(fp); if(!overlay_mode) { int overlay_width; int overlay_height; overlay_mode = fgetc(fp); overlay_width = fgetw(fp); overlay_height = fgetw(fp); size = overlay_width * overlay_height; cur_board->overlay = cmalloc(size); cur_board->overlay_color = cmalloc(size); load_RLE2_plane(cur_board->overlay, fp, size); test_buffer = cmalloc(1024); free(test_buffer); // Skip sizes fseek(fp, 4, SEEK_CUR); load_RLE2_plane(cur_board->overlay_color, fp, size); test_buffer = cmalloc(1024); free(test_buffer); } else { overlay_mode = 0; // Undo that last get fseek(fp, -1, SEEK_CUR); } cur_board->overlay_mode = overlay_mode; board_width = fgetw(fp); board_height = fgetw(fp); cur_board->board_width = board_width; cur_board->board_height = board_height; size = board_width * board_height; cur_board->level_id = cmalloc(size); cur_board->level_color = cmalloc(size); cur_board->level_param = cmalloc(size); cur_board->level_under_id = cmalloc(size); cur_board->level_under_color = cmalloc(size); cur_board->level_under_param = cmalloc(size); load_RLE2_plane(cur_board->level_id, fp, size); fseek(fp, 4, SEEK_CUR); load_RLE2_plane(cur_board->level_color, fp, size); fseek(fp, 4, SEEK_CUR); load_RLE2_plane(cur_board->level_param, fp, size); fseek(fp, 4, SEEK_CUR); load_RLE2_plane(cur_board->level_under_id, fp, size); fseek(fp, 4, SEEK_CUR); load_RLE2_plane(cur_board->level_under_color, fp, size); fseek(fp, 4, SEEK_CUR); load_RLE2_plane(cur_board->level_under_param, fp, size); // Load board parameters if(version < 0x0253) { fread(cur_board->mod_playing, LEGACY_MOD_FILENAME_MAX, 1, fp); cur_board->mod_playing[LEGACY_MOD_FILENAME_MAX] = 0; } else { size_t len = fgetw(fp); if(len >= MAX_PATH) len = MAX_PATH - 1; fread(cur_board->mod_playing, len, 1, fp); cur_board->mod_playing[len] = 0; } cur_board->viewport_x = fgetc(fp); cur_board->viewport_y = fgetc(fp); cur_board->viewport_width = fgetc(fp); cur_board->viewport_height = fgetc(fp); cur_board->can_shoot = fgetc(fp); cur_board->can_bomb = fgetc(fp); cur_board->fire_burn_brown = fgetc(fp); cur_board->fire_burn_space = fgetc(fp); cur_board->fire_burn_fakes = fgetc(fp); cur_board->fire_burn_trees = fgetc(fp); cur_board->explosions_leave = fgetc(fp); cur_board->save_mode = fgetc(fp); cur_board->forest_becomes = fgetc(fp); cur_board->collect_bombs = fgetc(fp); cur_board->fire_burns = fgetc(fp); for(i = 0; i < 4; i++) { cur_board->board_dir[i] = fgetc(fp); } cur_board->restart_if_zapped = fgetc(fp); cur_board->time_limit = fgetw(fp); if(version < 0x0253) { cur_board->last_key = fgetc(fp); cur_board->num_input = fgetw(fp); cur_board->input_size = fgetc(fp); fread(cur_board->input_string, LEGACY_INPUT_STRING_MAX + 1, 1, fp); cur_board->input_string[LEGACY_INPUT_STRING_MAX] = 0; cur_board->player_last_dir = fgetc(fp); fread(cur_board->bottom_mesg, LEGACY_BOTTOM_MESG_MAX + 1, 1, fp); cur_board->bottom_mesg[LEGACY_BOTTOM_MESG_MAX] = 0; cur_board->b_mesg_timer = fgetc(fp); cur_board->lazwall_start = fgetc(fp); cur_board->b_mesg_row = fgetc(fp); cur_board->b_mesg_col = (signed char)fgetc(fp); cur_board->scroll_x = (signed short)fgetw(fp); cur_board->scroll_y = (signed short)fgetw(fp); cur_board->locked_x = (signed short)fgetw(fp); cur_board->locked_y = (signed short)fgetw(fp); } else if(savegame) { size_t len; cur_board->last_key = fgetc(fp); cur_board->num_input = fgetw(fp); cur_board->input_size = fgetw(fp); len = fgetw(fp); if(len >= ROBOT_MAX_TR) len = ROBOT_MAX_TR - 1; fread(cur_board->input_string, len, 1, fp); cur_board->input_string[len] = 0; cur_board->player_last_dir = fgetc(fp); len = fgetw(fp); if(len >= ROBOT_MAX_TR) len = ROBOT_MAX_TR - 1; fread(cur_board->bottom_mesg, len, 1, fp); cur_board->bottom_mesg[len] = 0; cur_board->b_mesg_timer = fgetc(fp); cur_board->lazwall_start = fgetc(fp); cur_board->b_mesg_row = fgetc(fp); cur_board->b_mesg_col = (signed char)fgetc(fp); cur_board->scroll_x = (signed short)fgetw(fp); cur_board->scroll_y = (signed short)fgetw(fp); cur_board->locked_x = (signed short)fgetw(fp); cur_board->locked_y = (signed short)fgetw(fp); } cur_board->player_ns_locked = fgetc(fp); cur_board->player_ew_locked = fgetc(fp); cur_board->player_attack_locked = fgetc(fp); if(version < 0x0253 || savegame) { cur_board->volume = fgetc(fp); cur_board->volume_inc = fgetc(fp); cur_board->volume_target = fgetc(fp); } // Load robots num_robots = fgetc(fp); num_robots_active = 0; cur_board->robot_list = ccalloc(num_robots + 1, sizeof(struct robot *)); // Also allocate for name sorted list cur_board->robot_list_name_sorted = ccalloc(num_robots, sizeof(struct robot *)); // Any null objects being placed will later be optimized out if(num_robots) { for(i = 1; i <= num_robots; i++) { cur_robot = load_robot_allocate(fp, savegame, version); if(cur_robot->used) { cur_board->robot_list[i] = cur_robot; cur_board->robot_list_name_sorted[num_robots_active] = cur_robot; num_robots_active++; } else { // We don't need no null robot clear_robot(cur_robot); cur_board->robot_list[i] = NULL; } } } if(num_robots_active) { if(num_robots_active != num_robots) { cur_board->robot_list_name_sorted = crealloc(cur_board->robot_list_name_sorted, sizeof(struct robot *) * num_robots_active); } qsort(cur_board->robot_list_name_sorted, num_robots_active, sizeof(struct robot *), cmp_robots); } else { free(cur_board->robot_list_name_sorted); cur_board->robot_list_name_sorted = NULL; } cur_board->num_robots = num_robots; cur_board->num_robots_allocated = num_robots; cur_board->num_robots_active = num_robots_active; // Load scrolls num_scrolls = fgetc(fp); cur_board->scroll_list = ccalloc(num_scrolls + 1, sizeof(struct scroll *)); if(num_scrolls) { for(i = 1; i <= num_scrolls; i++) { cur_scroll = load_scroll_allocate(fp); if(cur_scroll->used) cur_board->scroll_list[i] = cur_scroll; else clear_scroll(cur_scroll); } } cur_board->num_scrolls = num_scrolls; cur_board->num_scrolls_allocated = num_scrolls; // Load sensors num_sensors = fgetc(fp); cur_board->sensor_list = ccalloc(num_sensors + 1, sizeof(struct sensor *)); if(num_sensors) { for(i = 1; i <= num_sensors; i++) { cur_sensor = load_sensor_allocate(fp); if(cur_sensor->used) cur_board->sensor_list[i] = cur_sensor; else clear_sensor(cur_sensor); } } cur_board->num_sensors = num_sensors; cur_board->num_sensors_allocated = num_sensors; }