type stringclasses 5
values | content stringlengths 9 163k |
|---|---|
defines | #define GOVERNMENT_SECTION_PREFIX "government_" |
defines | #define NATION_GROUP_SECTION_PREFIX "ngroup" /* without underscore? */ |
defines | #define NATION_SET_SECTION_PREFIX "nset" /* without underscore? */ |
defines | #define NATION_SECTION_PREFIX "nation" /* without underscore? */ |
defines | #define RESOURCE_SECTION_PREFIX "resource_" |
defines | #define BASE_SECTION_PREFIX "base_" |
defines | #define SPECIALIST_SECTION_PREFIX "specialist_" |
defines | #define TERRAIN_SECTION_PREFIX "terrain_" |
defines | #define UNIT_CLASS_SECTION_PREFIX "unitclass_" |
defines | #define UNIT_SECTION_PREFIX "unit_" |
defines |
#define check_name(name) (check_strlen(name, MAX_LEN_NAME, NULL)) |
defines | #define MAX_SECTION_LABEL 64 |
defines | #define section_strlcpy(dst, src) \ |
defines | #define ruleset_error(level, format, ...) \ |
defines |
#define rs_sanity_veteran(_path, _entry, _i, _condition, _action) \ |
functions | void ruleset_error_real(const char *file, const char *function,
int line, enum log_level level,
const char *format, ...)
{
va_list args;
va_start(args, format);
vdo_log(file, function, line, FALSE, level, format, args);
va_end(args);
if (LOG_FATA... |
functions | void openload_script_file(const char *whichset)
{
const char *dfilename = valid_ruleset_filename(game.server.rulesetdir,
whichset, SCRIPT_SUFFIX);
if (!script_server_do_file(NULL, dfilename)) {
ruleset_error(LOG_FATAL, "\"%s\": could not load ruleset script.",
... |
functions | void lookup_unit_list(struct section_file *file, const char *prefix,
const char *entry, int loglevel,
struct unit_type **output,
const char *filename)
{
const char **slist;
size_t nval;
int i;
/* pre-fill with NULL: */
fo... |
functions | void lookup_tech_list(struct section_file *file, const char *prefix,
const char *entry, int *output,
const char *filename)
{
const char **slist;
size_t nval;
int i;
/* pre-fill with A_LAST: */
for(i=0; i<MAX_NUM_TECH_LIST; i++) {
output[i] = A_LAS... |
functions | void lookup_building_list(struct section_file *file,
const char *prefix, const char *entry,
int *output, const char *filename)
{
const char **slist;
size_t nval;
int i;
/* pre-fill with B_LAST: */
for (i = 0; i < MAX_NUM_BUILDING_LIST; i++) {
... |
functions | unit_move_type lookup_move_type(struct section_file *file,
const char *entry,
const char *filename)
{
const char *sval;
enum unit_move_type mt;
sval = secfile_lookup_str_default(file, NULL, "%s", entry);
if (sval == NULL) {
return unit_move_type_invalid();
} |
functions | void ruleset_load_names(struct name_translation *pname,
struct section_file *file,
const char *sec_name)
{
const char *name = secfile_lookup_str(file, "%s.name", sec_name);
const char *rule_name = secfile_lookup_str(file, "%s.rule_name", sec_name);
if... |
functions | void load_tech_names(struct section_file *file)
{
struct section_list *sec;
/* Number of techs in the ruleset (means without A_NONE). */
int num_techs = 0;
int i;
const char *filename = secfile_name(file);
(void) secfile_entry_by_path(file, "datafile.description"); /* unused */
/* The names: */
sec ... |
functions | void load_ruleset_techs(struct section_file *file)
{
struct section_list *sec;
int i;
struct advance *a_none = advance_by_number(A_NONE);
const char *filename = secfile_name(file);
(void) check_ruleset_capabilities(file, RULESET_CAPABILITIES, filename);
sec = secfile_sections_by_name_prefix(file, ADVANCE... |
functions | void load_unit_names(struct section_file *file)
{
struct section_list *sec;
int nval = 0;
size_t user_flags;
const char **flaglist;
int i;
const char *filename = secfile_name(file);
(void) secfile_entry_by_path(file, "datafile.description"); /* unused */
/* User unit flag names */
flaglist = secfi... |
functions | bool load_ruleset_veteran(struct section_file *file,
const char *path,
struct veteran_system **vsystem, char *err,
size_t err_len)
{
const char **vlist_name;
int *vlist_power, *vlist_raise, *vlist_wraise, *vlist_move;... |
functions | else if (count_name != count_power
|| count_name != count_raise
|| count_name != count_wraise
|| count_name != count_move) {
ret = FALSE;
fc_snprintf(err, err_len, "\"%s\": Different lengths for the veteran "
"settings in section '%s'", secfil... |
functions | else if (count_name == 0) {
/* Nothing defined. */
*vsystem = NULL;
} |
functions | else if (i == count_name - 1) {
/* Last element. */
rs_sanity_veteran(path, "veteran_power_fact", i,
(vlist_power[i] < vlist_power[i - 1]),
vlist_power[i] = vlist_power[i - 1]);
rs_sanity_veteran(path, "veteran_raise_chance", i,
... |
functions | void load_ruleset_units(struct section_file *file)
{
struct unit_type *u;
int j, ival;
size_t nval;
struct section_list *sec, *csec;
const char *sval, **slist;
const char *filename = secfile_name(file);
char msg[MAX_LEN_MSG];
(void) check_ruleset_capabilities(file, RULESET_CAPABILITIES, filename);
i... |
functions | else if (sea_moving) {
uc->move_type = UMT_SEA;
} |
functions | else if (uc->move_type == UMT_SEA) {
/* Explicitly given SEA_MOVING */
if (uclass_has_flag(uc, UCF_RIVER_NATIVE)) {
log_error("\"%s\" unit_class \"%s\": cannot give RiverNative "
"flag to sea moving unit",
filename, uclass_rule_name(uc));
BV_CLR(uc->flags,... |
functions | void load_building_names(struct section_file *file)
{
struct section_list *sec;
int i, nval = 0;
const char *filename = secfile_name(file);
(void) secfile_entry_by_path(file, "datafile.description"); /* unused */
/* The names: */
sec = secfile_sections_by_name_prefix(file, BUILDING_SECTION_PREFIX);
if... |
functions | void load_ruleset_buildings(struct section_file *file)
{
struct section_list *sec;
const char *item;
int i, nval;
const char *filename = secfile_name(file);
(void) check_ruleset_capabilities(file, RULESET_CAPABILITIES, filename);
sec = secfile_sections_by_name_prefix(file, BUILDING_SECTION_PREFIX);
nval... |
functions | void load_terrain_names(struct section_file *file)
{
int nval = 0;
struct section_list *sec;
const char *filename = secfile_name(file);
(void) secfile_entry_by_path(file, "datafile.description"); /* unused */
/* terrain names */
sec = secfile_sections_by_name_prefix(file, TERRAIN_SECTION_PREFIX);
if ... |
functions | void load_ruleset_terrain(struct section_file *file)
{
struct strvec *psv;
size_t nval;
int j;
const char **res;
const char *filename = secfile_name(file);
/* char *datafile_options = */ (void)
check_ruleset_capabilities(file, RULESET_CAPABILITIES, filename);
/* options */
terrain_control.may_road ... |
functions | void load_government_names(struct section_file *file)
{
int nval = 0;
struct section_list *sec;
const char *filename = secfile_name(file);
(void) secfile_entry_by_path(file, "datafile.description"); /* unused */
sec = secfile_sections_by_name_prefix(file, GOVERNMENT_SECTION_PREFIX);
if (NULL == sec || 0... |
functions | else if(nval > G_MAGIC) {
/* upper limit is really about 255 for 8-bit id values, but
use G_MAGIC elsewhere as a sanity check, and should be plenty
big enough --dwp */
ruleset_error(LOG_FATAL, "\"%s\": Too many governments (%d, max %d)",
filename, nval, G_MAGIC);
} |
functions | void load_ruleset_governments(struct section_file *file)
{
struct section_list *sec;
const char *filename = secfile_name(file);
(void) check_ruleset_capabilities(file, RULESET_CAPABILITIES, filename);
sec = secfile_sections_by_name_prefix(file, GOVERNMENT_SECTION_PREFIX);
game.government_during_revolution
... |
functions | void send_ruleset_control(struct conn_list *dest)
{
struct packet_ruleset_control packet;
packet = game.control;
lsend_packet_ruleset_control(dest, &packet);
} |
functions | void load_nation_names(struct section_file *file)
{
struct section_list *sec;
int j;
(void) secfile_entry_by_path(file, "datafile.description"); /* unused */
sec = secfile_sections_by_name_prefix(file, NATION_SECTION_PREFIX);
if (NULL == sec) {
ruleset_error(LOG_FATAL, "No available nations in this ru... |
functions | void load_city_name_list(struct section_file *file,
struct nation_type *pnation,
const char *secfile_str1,
const char *secfile_str2)
{
size_t dim, j;
const char **cities = secfile_lookup_str_vec(file, &dim, "%s.%s",
... |
functions | void load_ruleset_nations(struct section_file *file)
{
struct government *gov;
int j;
size_t dim;
char temp_name[MAX_LEN_NAME];
const char **vec;
const char *name, *bad_leader;
int barb_land_count = 0;
int barb_sea_count = 0;
bool warn_city_style;
const char *sval;
struct government *default_gover... |
functions | else if (NULL != pconflict) {
nation_list_append(pnation->server.conflicts_with, pconflict);
} |
functions | else if (0 == j) {
ruleset_error(LOG_FATAL,
"Nation %s: no leaders; at least one is required.",
nation_rule_name(pnation));
} |
functions | else if (NULL != male && NULL != female) {
(void) government_ruler_title_new(gov, pnation, male, female);
} |
functions | else if (NULL != pconflict) {
nation_list_append(pnation->server.civilwar_nations, pconflict);
nation_list_append(pconflict->server.parent_nations, pnation);
} |
functions | void load_citystyle_names(struct section_file *file)
{
struct section_list *styles;
int i = 0;
(void) secfile_entry_by_path(file, "datafile.description"); /* unused */
/* The sections: */
styles = secfile_sections_by_name_prefix(file, CITYSTYLE_SECTION_PREFIX);
if (NULL != styles) {
city_styles_allo... |
functions | void load_ruleset_cities(struct section_file *file)
{
const char *replacement;
int i;
const char *filename = secfile_name(file);
const char *item;
struct section_list *sec;
(void) check_ruleset_capabilities(file, RULESET_CAPABILITIES, filename);
/* Specialist options */
sec = secfile_sections_by_name_... |
functions | void load_ruleset_effects(struct section_file *file)
{
struct section_list *sec;
const char *type;
const char *filename;
filename = secfile_name(file);
(void) check_ruleset_capabilities(file, RULESET_CAPABILITIES, filename);
(void) secfile_entry_by_path(file, "datafile.description"); /* unused */
/* P... |
functions | int secfile_lookup_int_default_min_max(struct section_file *file,
int def, int min, int max,
const char *path, ...)
{
char fullpath[256];
int ival;
va_list args;
va_start(args, path);
fc_vsnprintf(fullpath, sizeof(ful... |
functions | void load_ruleset_game(void)
{
struct section_file *file;
const char *sval, **svec;
const char *filename;
int *food_ini;
int i;
size_t teams;
const char *text;
size_t gni_tmp;
file = openload_ruleset_file("game");
filename = secfile_name(file);
/* section: datafile */
(void) check_ruleset_capa... |
functions | else if (game.info.granary_num_inis == 0) {
log_error("No values for granary_food_ini. Using default "
"value %d.", RS_DEFAULT_GRANARY_FOOD_INI);
game.info.granary_num_inis = 1;
game.info.granary_food_ini[0] = RS_DEFAULT_GRANARY_FOOD_INI;
} |
functions | void send_ruleset_unit_classes(struct conn_list *dest)
{
struct packet_ruleset_unit_class packet;
unit_class_iterate(c) {
packet.id = uclass_number(c);
sz_strlcpy(packet.name, untranslated_name(&c->name));
sz_strlcpy(packet.rule_name, rule_name(&c->name));
packet.move_type = c->move_type;
packe... |
functions | void send_ruleset_units(struct conn_list *dest)
{
struct packet_ruleset_unit packet;
int i;
unit_type_iterate(u) {
packet.id = utype_number(u);
sz_strlcpy(packet.name, untranslated_name(&u->name));
sz_strlcpy(packet.rule_name, rule_name(&u->name));
sz_strlcpy(packet.sound_move, u->sound_move);
... |
functions | void send_ruleset_specialists(struct conn_list *dest)
{
struct packet_ruleset_specialist packet;
specialist_type_iterate(spec_id) {
struct specialist *s = specialist_by_number(spec_id);
int j;
packet.id = spec_id;
sz_strlcpy(packet.plural_name, untranslated_name(&s->name));
sz_strlcpy(packet.r... |
functions | void send_ruleset_techs(struct conn_list *dest)
{
struct packet_ruleset_tech packet;
advance_iterate(A_NONE, a) {
packet.id = advance_number(a);
sz_strlcpy(packet.name, untranslated_name(&a->name));
sz_strlcpy(packet.rule_name, rule_name(&a->name));
sz_strlcpy(packet.graphic_str, a->graphic_str);
... |
functions | void send_ruleset_buildings(struct conn_list *dest)
{
improvement_iterate(b) {
struct packet_ruleset_building packet;
int j;
packet.id = improvement_number(b);
packet.genus = b->genus;
sz_strlcpy(packet.name, untranslated_name(&b->name));
sz_strlcpy(packet.rule_name, rule_name(&b->name));
... |
functions | void send_ruleset_terrain(struct conn_list *dest)
{
struct packet_ruleset_terrain packet;
lsend_packet_ruleset_terrain_control(dest, &terrain_control);
terrain_type_iterate(pterrain) {
struct resource **r;
packet.id = terrain_number(pterrain);
packet.native_to = pterrain->native_to;
sz_strlcpy... |
functions | void send_ruleset_resources(struct conn_list *dest)
{
struct packet_ruleset_resource packet;
resource_type_iterate (presource) {
packet.id = resource_number(presource);
sz_strlcpy(packet.name, untranslated_name(&presource->name));
sz_strlcpy(packet.rule_name, rule_name(&presource->name));
sz_strlc... |
functions | void send_ruleset_bases(struct conn_list *dest)
{
struct packet_ruleset_base packet;
base_type_iterate(b) {
int j;
packet.id = base_number(b);
sz_strlcpy(packet.name, untranslated_name(&b->name));
sz_strlcpy(packet.rule_name, rule_name(&b->name));
sz_strlcpy(packet.graphic_str, b->graphic_str)... |
functions | void send_ruleset_governments(struct conn_list *dest)
{
struct packet_ruleset_government gov;
struct packet_ruleset_government_ruler_title title;
int j;
governments_iterate(g) {
/* send one packet_government */
gov.id = government_number(g);
j = 0;
requirement_vector_iterate(&g->reqs, preq) {
... |
functions | void send_ruleset_nations(struct conn_list *dest)
{
struct packet_ruleset_nation packet;
struct packet_ruleset_nation_groups groups_packet;
int i;
groups_packet.ngroups = nation_group_count();
i = 0;
nation_groups_iterate(pgroup) {
sz_strlcpy(groups_packet.groups[i++],
nation_group_untra... |
functions | void send_ruleset_cities(struct conn_list *dest)
{
struct packet_ruleset_city city_p;
int k, j;
for (k = 0; k < game.control.styles_count; k++) {
city_p.style_id = k;
city_p.replaced_by = city_styles[k].replaced_by;
j = 0;
requirement_vector_iterate(&city_styles[k].reqs, preq) {
city_p.req... |
functions | void send_ruleset_game(struct conn_list *dest)
{
struct packet_ruleset_game misc_p;
int i;
fc_assert_ret(game.veteran != NULL);
/* Per unit veteran system definition. */
misc_p.veteran_levels = game.veteran->levels;
for (i = 0; i < misc_p.veteran_levels; i++) {
const struct veteran_level *vlevel = ga... |
functions | void send_ruleset_team_names(struct conn_list *dest)
{
struct packet_team_name_info team_name_info_p;
team_slots_iterate(tslot) {
const char *name = team_slot_defined_name(tslot);
if (NULL == name) {
/* End of defined names. */
break;
} |
functions | void load_rulesets(void)
{
struct section_file *techfile, *unitfile, *buildfile, *govfile, *terrfile;
struct section_file *cityfile, *nationfile, *effectfile;
log_normal(_("Loading rulesets."));
game_ruleset_free();
/* Reset the list of available player colors. */
playercolor_free();
playercolor_init();... |
functions | void reload_rulesets_settings(void)
{
struct section_file *file;
file = openload_ruleset_file("game");
settings_ruleset(file, "settings");
secfile_destroy(file);
} |
functions | void send_rulesets(struct conn_list *dest)
{
conn_list_compression_freeze(dest);
/* ruleset_control also indicates to client that ruleset sending starts. */
send_ruleset_control(dest);
send_ruleset_game(dest);
send_ruleset_team_names(dest);
send_ruleset_techs(dest);
send_ruleset_governments(dest);
sen... |
functions | bool nation_has_initial_tech(struct nation_type *pnation,
struct advance *tech)
{
int i;
/* See if it's given as global init tech */
for (i = 0; i < MAX_NUM_TECH_LIST
&& game.rgame.global_init_techs[i] != A_LAST; i++) {
if (game.rgame.global_init_techs[i] == advance... |
functions | bool sanity_check_req_set(int reqs_of_type[], int local_reqs_of_type[],
struct requirement *preq,
int max_tiles, const char *list_for)
{
int rc;
fc_assert_ret_val(universals_n_is_valid(preq->source.kind), FALSE);
/* Add to counter */
reqs_of_ty... |
functions | bool sanity_check_req_list(const struct requirement_list *preqs,
int max_tiles,
const char *list_for)
{
int reqs_of_type[VUT_COUNT];
int local_reqs_of_type[VUT_COUNT];
/* Initialize requirement counters */
memset(reqs_of_type, 0, sizeof(reqs_o... |
functions | bool sanity_check_req_vec(const struct requirement_vector *preqs,
int max_tiles,
const char *list_for)
{
int reqs_of_type[VUT_COUNT];
int local_reqs_of_type[VUT_COUNT];
/* Initialize requirement counters */
memset(reqs_of_type, 0, sizeof(reqs_of... |
functions | bool sanity_check_req_nreq_list(const struct requirement_list *preqs,
const struct requirement_list *pnreqs,
int one_tile,
const char *list_for)
{
/* Check internal sanity of requirement list */
if (... |
functions | bool effect_list_sanity_cb(const struct effect *peffect)
{
int one_tile = -1; /* TODO: Determine correct value from effect.
* -1 disables checking */
return sanity_check_req_nreq_list(peffect->reqs, peffect->nreqs, one_tile,
effect_type_name(peffect->... |
functions | bool sanity_check_ruleset_data(void)
{
int num_utypes;
int i;
bool ok = TRUE; /* Store failures to variable instead of returning
* immediately so all errors get printed, not just first
* one. */
/* Check that all players can have their initial techs */
nations_iterate(pn... |
includes |
#include <linux/init.h> |
includes | #include <linux/ioport.h> |
includes | #include <linux/platform_device.h> |
includes | #include <linux/bootmem.h> |
includes | #include <asm/mach-types.h> |
includes | #include <mach/msm_bus_board.h> |
includes | #include <mach/msm_memtypes.h> |
includes | #include <mach/board.h> |
includes | #include <mach/gpio.h> |
includes | #include <mach/gpiomux.h> |
includes | #include <linux/ion.h> |
includes | #include <mach/ion.h> |
includes |
#include <linux/fb.h> |
includes |
#include <mach/board_lge.h> |
defines | #define MSM_FB_PRIM_BUF_SIZE (LCD_RESOLUTION_X * LCD_RESOLUTION_Y * 4 * 3) |
defines | #define MSM_FB_PRIM_BUF_SIZE (LCD_RESOLUTION_X * LCD_RESOLUTION_Y * 4 * 2) |
defines | #define MSM_FB_EXT_BUF_SIZE (1920 * 1088 * 2 * 1) /* 2 bpp x 1 page */ |
defines | #define MSM_FB_EXT_BUF_SIZE (720 * 576 * 2 * 2) /* 2 bpp x 2 pages */ |
defines | #define MSM_FB_EXT_BUF_SIZE 0 |
defines | #define MSM_FB_SIZE roundup(MSM_FB_PRIM_BUF_SIZE + MSM_FB_EXT_BUF_SIZE, 4096) |
defines | #define MSM_FB_OVERLAY0_WRITEBACK_SIZE roundup((LCD_RESOLUTION_X * LCD_RESOLUTION_Y * 3 * 2), 4096) |
defines | #define MSM_FB_OVERLAY0_WRITEBACK_SIZE (0) |
defines | #define MSM_FB_OVERLAY1_WRITEBACK_SIZE roundup((1920 * 1088 * 3 * 2), 4096) |
defines | #define MSM_FB_OVERLAY1_WRITEBACK_SIZE (0) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.