void sparc_cpu_list(FILE *f, fprintf_function cpu_fprintf)
{
unsigned int i;
for (i = 0; i < ARRAY_SIZE(sparc_defs); i++) {
(*cpu_fprintf)(f, "Sparc %16s IU " TARGET_FMT_lx
" FPU %08x MMU %08x NWINS %d ",
sparc_defs[i].name,
sparc_defs[i].iu_version,
sparc_defs[i].fpu_version,
sparc_defs[i].mmu_version,
sparc_defs[i].nwindows);
print_features(f, cpu_fprintf, CPU_DEFAULT_FEATURES &
~sparc_defs[i].features, "-");
print_features(f, cpu_fprintf, ~CPU_DEFAULT_FEATURES &
sparc_defs[i].features, "+");
(*cpu_fprintf)(f, "\n");
}
(*cpu_fprintf)(f, "Default CPU feature flags (use '-' to remove): ");
print_features(f, cpu_fprintf, CPU_DEFAULT_FEATURES, NULL);
(*cpu_fprintf)(f, "\n");
(*cpu_fprintf)(f, "Available CPU feature flags (use '+' to add): ");
print_features(f, cpu_fprintf, ~CPU_DEFAULT_FEATURES, NULL);
(*cpu_fprintf)(f, "\n");
(*cpu_fprintf)(f, "Numerical features (use '=' to set): iu_version "
"fpu_version mmu_version nwindows\n");
}
static void read_controller_features_rsp(const void *data, uint8_t size)
{
uint8_t status = get_u8(data);
print_status(status);
print_features(data + 1);
}
void
select_feature_test()
{
struct event_config *config = event_config_new();
event_config_avoid_method (config, "poll");
event_config_avoid_method (config, "epoll");
struct event_base *base = event_base_new_with_config (config);
print_features(base);
event_base_free(base);
}
/* EAX = 8000 0001 | EAX = 0000 0001 */
void handle_features(struct cpu_regs_t *regs, struct cpuid_state_t *state)
{
if (state->last_leaf.eax == 0x00000001) {
struct std1_ebx_t
{
uint8_t brandid;
uint8_t clflushsz;
uint8_t logicalcount;
uint8_t localapicid;
};
uint32_t model;
struct std1_ebx_t *ebx = (struct std1_ebx_t *)®s->ebx;
*(uint32_t *)(&state->sig) = regs->eax;
/* Model is calculated differently on Intel/AMD. */
model = state->sig.model;
if (state->vendor & VENDOR_INTEL) {
model += ((state->sig.family == 0xf || state->sig.family == 0x6) ? state->sig.extmodel << 4 : 0);
} else if (state->vendor & VENDOR_AMD) {
model += (model == 0xf ? state->sig.extmodel << 4 : 0);
}
printf("Signature: 0x%08x\n"
" Family: 0x%02x (%d)\n"
" Model: 0x%02x (%d)\n"
" Stepping: 0x%02x (%d)\n\n",
*(uint32_t *)&state->sig,
state->sig.family + state->sig.extfamily,
state->sig.family + state->sig.extfamily,
model,
model,
state->sig.stepping,
state->sig.stepping);
printf("Local APIC: %d\n"
"Logical processor count: %d\n"
"CLFLUSH size: %d\n"
"Brand ID: %d\n\n",
ebx->localapicid,
ebx->logicalcount,
ebx->clflushsz << 3,
ebx->brandid);
}
print_features(regs, state);
printf("\n");
}
void feature_test ()
{
/* supported async */
const char ** methods = event_get_supported_methods();
if (methods) {
int i = 0;
while(methods[i]) {
printf ("method %d : <%s>\n", i+1, methods[i]);
i++;
}
}
/* get the default async method */
base = event_base_new();
const char * bb = event_base_get_method(base);
printf("default method is <%s>\n", bb); /* epoll */
print_features(base);
event_base_free(base);
}
void list_super2(struct ext2_super_block * sb, FILE *f)
{
int inode_blocks_per_group;
char buf[80], *str;
time_t tm;
inode_blocks_per_group = (((sb->s_inodes_per_group *
EXT2_INODE_SIZE(sb)) +
EXT2_BLOCK_SIZE(sb) - 1) /
EXT2_BLOCK_SIZE(sb));
if (sb->s_volume_name[0]) {
memset(buf, 0, sizeof(buf));
strncpy(buf, sb->s_volume_name, sizeof(sb->s_volume_name));
} else
strcpy(buf, "<none>");
fprintf(f, "Filesystem volume name: %s\n", buf);
if (sb->s_last_mounted[0]) {
memset(buf, 0, sizeof(buf));
strncpy(buf, sb->s_last_mounted, sizeof(sb->s_last_mounted));
} else
strcpy(buf, "<not available>");
fprintf(f, "Last mounted on: %s\n", buf);
fprintf(f, "Filesystem UUID: %s\n", e2p_uuid2str(sb->s_uuid));
fprintf(f, "Filesystem magic number: 0x%04X\n", sb->s_magic);
fprintf(f, "Filesystem revision #: %d", sb->s_rev_level);
if (sb->s_rev_level == EXT2_GOOD_OLD_REV) {
fprintf(f, " (original)\n");
#ifdef EXT2_DYNAMIC_REV
} else if (sb->s_rev_level == EXT2_DYNAMIC_REV) {
fprintf(f, " (dynamic)\n");
#endif
} else
fprintf(f, " (unknown)\n");
print_features(sb, f);
print_super_flags(sb, f);
print_mntopts(sb, f);
fprintf(f, "Filesystem state: ");
print_fs_state (f, sb->s_state);
fprintf(f, "\n");
fprintf(f, "Errors behavior: ");
print_fs_errors(f, sb->s_errors);
fprintf(f, "\n");
str = e2p_os2string(sb->s_creator_os);
fprintf(f, "Filesystem OS type: %s\n", str);
free(str);
fprintf(f, "Inode count: %u\n", sb->s_inodes_count);
fprintf(f, "Block count: %u\n", sb->s_blocks_count);
fprintf(f, "Reserved block count: %u\n", sb->s_r_blocks_count);
fprintf(f, "Free blocks: %u\n", sb->s_free_blocks_count);
fprintf(f, "Free inodes: %u\n", sb->s_free_inodes_count);
fprintf(f, "First block: %u\n", sb->s_first_data_block);
fprintf(f, "Block size: %u\n", EXT2_BLOCK_SIZE(sb));
fprintf(f, "Fragment size: %u\n", EXT2_FRAG_SIZE(sb));
if (sb->s_reserved_gdt_blocks)
fprintf(f, "Reserved GDT blocks: %u\n",
sb->s_reserved_gdt_blocks);
fprintf(f, "Blocks per group: %u\n", sb->s_blocks_per_group);
fprintf(f, "Fragments per group: %u\n", sb->s_frags_per_group);
fprintf(f, "Inodes per group: %u\n", sb->s_inodes_per_group);
fprintf(f, "Inode blocks per group: %u\n", inode_blocks_per_group);
if (sb->s_raid_stride)
fprintf(f, "RAID stride: %u\n",
sb->s_raid_stride);
if (sb->s_raid_stripe_width)
fprintf(f, "RAID stripe width: %u\n",
sb->s_raid_stripe_width);
if (sb->s_first_meta_bg)
fprintf(f, "First meta block group: %u\n",
sb->s_first_meta_bg);
if (sb->s_log_groups_per_flex)
fprintf(f, "Flex block group size: %u\n",
1 << sb->s_log_groups_per_flex);
if (sb->s_mkfs_time) {
tm = sb->s_mkfs_time;
fprintf(f, "Filesystem created: %s", ctime(&tm));
}
tm = sb->s_mtime;
fprintf(f, "Last mount time: %s",
sb->s_mtime ? ctime(&tm) : "n/a\n");
tm = sb->s_wtime;
fprintf(f, "Last write time: %s", ctime(&tm));
fprintf(f, "Mount count: %u\n", sb->s_mnt_count);
fprintf(f, "Maximum mount count: %d\n", sb->s_max_mnt_count);
tm = sb->s_lastcheck;
fprintf(f, "Last checked: %s", ctime(&tm));
fprintf(f, "Check interval: %u (%s)\n", sb->s_checkinterval,
interval_string(sb->s_checkinterval));
if (sb->s_checkinterval)
{
time_t next;
next = sb->s_lastcheck + sb->s_checkinterval;
fprintf(f, "Next check after: %s", ctime(&next));
}
fprintf(f, "Reserved blocks uid: ");
print_user(sb->s_def_resuid, f);
fprintf(f, "Reserved blocks gid: ");
print_group(sb->s_def_resgid, f);
if (sb->s_rev_level >= EXT2_DYNAMIC_REV) {
fprintf(f, "First inode: %d\n", sb->s_first_ino);
fprintf(f, "Inode size: %d\n", sb->s_inode_size);
if (sb->s_min_extra_isize)
fprintf(f, "Required extra isize: %d\n",
sb->s_min_extra_isize);
if (sb->s_want_extra_isize)
fprintf(f, "Desired extra isize: %d\n",
sb->s_want_extra_isize);
}
if (!e2p_is_null_uuid(sb->s_journal_uuid))
fprintf(f, "Journal UUID: %s\n",
e2p_uuid2str(sb->s_journal_uuid));
if (sb->s_journal_inum)
fprintf(f, "Journal inode: %u\n",
sb->s_journal_inum);
if (sb->s_journal_dev)
fprintf(f, "Journal device: 0x%04x\n",
sb->s_journal_dev);
if (sb->s_last_orphan)
fprintf(f, "First orphan inode: %u\n",
sb->s_last_orphan);
if ((sb->s_feature_compat & EXT2_FEATURE_COMPAT_DIR_INDEX) ||
sb->s_def_hash_version)
fprintf(f, "Default directory hash: %s\n",
e2p_hash2string(sb->s_def_hash_version));
if (!e2p_is_null_uuid(sb->s_hash_seed))
fprintf(f, "Directory Hash Seed: %s\n",
e2p_uuid2str(sb->s_hash_seed));
if (sb->s_jnl_backup_type) {
fprintf(f, "Journal backup: ");
switch (sb->s_jnl_backup_type) {
case 1:
fprintf(f, "inode blocks\n");
break;
default:
fprintf(f, "type %u\n", sb->s_jnl_backup_type);
}
}
}
static int cpu_sparc_find_by_name(sparc_def_t *cpu_def, const char *cpu_model)
{
unsigned int i;
const sparc_def_t *def = NULL;
char *s = g_strdup(cpu_model);
char *featurestr, *name = strtok(s, ",");
uint32_t plus_features = 0;
uint32_t minus_features = 0;
uint64_t iu_version;
uint32_t fpu_version, mmu_version, nwindows;
for (i = 0; i < ARRAY_SIZE(sparc_defs); i++) {
if (strcasecmp(name, sparc_defs[i].name) == 0) {
def = &sparc_defs[i];
}
}
if (!def) {
goto error;
}
memcpy(cpu_def, def, sizeof(*def));
featurestr = strtok(NULL, ",");
while (featurestr) {
char *val;
if (featurestr[0] == '+') {
add_flagname_to_bitmaps(featurestr + 1, &plus_features);
} else if (featurestr[0] == '-') {
add_flagname_to_bitmaps(featurestr + 1, &minus_features);
} else if ((val = strchr(featurestr, '='))) {
*val = 0; val++;
if (!strcmp(featurestr, "iu_version")) {
char *err;
iu_version = strtoll(val, &err, 0);
if (!*val || *err) {
fprintf(stderr, "bad numerical value %s\n", val);
goto error;
}
cpu_def->iu_version = iu_version;
#ifdef DEBUG_FEATURES
fprintf(stderr, "iu_version %" PRIx64 "\n", iu_version);
#endif
} else if (!strcmp(featurestr, "fpu_version")) {
char *err;
fpu_version = strtol(val, &err, 0);
if (!*val || *err) {
fprintf(stderr, "bad numerical value %s\n", val);
goto error;
}
cpu_def->fpu_version = fpu_version;
#ifdef DEBUG_FEATURES
fprintf(stderr, "fpu_version %x\n", fpu_version);
#endif
} else if (!strcmp(featurestr, "mmu_version")) {
char *err;
mmu_version = strtol(val, &err, 0);
if (!*val || *err) {
fprintf(stderr, "bad numerical value %s\n", val);
goto error;
}
cpu_def->mmu_version = mmu_version;
#ifdef DEBUG_FEATURES
fprintf(stderr, "mmu_version %x\n", mmu_version);
#endif
} else if (!strcmp(featurestr, "nwindows")) {
char *err;
nwindows = strtol(val, &err, 0);
if (!*val || *err || nwindows > MAX_NWINDOWS ||
nwindows < MIN_NWINDOWS) {
fprintf(stderr, "bad numerical value %s\n", val);
goto error;
}
cpu_def->nwindows = nwindows;
#ifdef DEBUG_FEATURES
fprintf(stderr, "nwindows %d\n", nwindows);
#endif
} else {
fprintf(stderr, "unrecognized feature %s\n", featurestr);
goto error;
}
} else {
fprintf(stderr, "feature string `%s' not in format "
"(+feature|-feature|feature=xyz)\n", featurestr);
goto error;
}
featurestr = strtok(NULL, ",");
}
cpu_def->features |= plus_features;
cpu_def->features &= ~minus_features;
#ifdef DEBUG_FEATURES
print_features(stderr, fprintf, cpu_def->features, NULL);
#endif
g_free(s);
return 0;
error:
free(s);
return -1;
}
static void sparc_cpu_parse_features(CPUState *cs, char *features,
Error **errp)
{
SPARCCPU *cpu = SPARC_CPU(cs);
sparc_def_t *cpu_def = cpu->env.def;
char *featurestr;
uint32_t plus_features = 0;
uint32_t minus_features = 0;
uint64_t iu_version;
uint32_t fpu_version, mmu_version, nwindows;
featurestr = features ? strtok(features, ",") : NULL;
while (featurestr) {
char *val;
if (featurestr[0] == '+') {
add_flagname_to_bitmaps(featurestr + 1, &plus_features);
} else if (featurestr[0] == '-') {
add_flagname_to_bitmaps(featurestr + 1, &minus_features);
} else if ((val = strchr(featurestr, '='))) {
*val = 0; val++;
if (!strcmp(featurestr, "iu_version")) {
char *err;
iu_version = strtoll(val, &err, 0);
if (!*val || *err) {
error_setg(errp, "bad numerical value %s", val);
return;
}
cpu_def->iu_version = iu_version;
#ifdef DEBUG_FEATURES
fprintf(stderr, "iu_version %" PRIx64 "\n", iu_version);
#endif
} else if (!strcmp(featurestr, "fpu_version")) {
char *err;
fpu_version = strtol(val, &err, 0);
if (!*val || *err) {
error_setg(errp, "bad numerical value %s", val);
return;
}
cpu_def->fpu_version = fpu_version;
#ifdef DEBUG_FEATURES
fprintf(stderr, "fpu_version %x\n", fpu_version);
#endif
} else if (!strcmp(featurestr, "mmu_version")) {
char *err;
mmu_version = strtol(val, &err, 0);
if (!*val || *err) {
error_setg(errp, "bad numerical value %s", val);
return;
}
cpu_def->mmu_version = mmu_version;
#ifdef DEBUG_FEATURES
fprintf(stderr, "mmu_version %x\n", mmu_version);
#endif
} else if (!strcmp(featurestr, "nwindows")) {
char *err;
nwindows = strtol(val, &err, 0);
if (!*val || *err || nwindows > MAX_NWINDOWS ||
nwindows < MIN_NWINDOWS) {
error_setg(errp, "bad numerical value %s", val);
return;
}
cpu_def->nwindows = nwindows;
#ifdef DEBUG_FEATURES
fprintf(stderr, "nwindows %d\n", nwindows);
#endif
} else {
error_setg(errp, "unrecognized feature %s", featurestr);
return;
}
} else {
error_setg(errp, "feature string `%s' not in format "
"(+feature|-feature|feature=xyz)", featurestr);
return;
}
featurestr = strtok(NULL, ",");
}
cpu_def->features |= plus_features;
cpu_def->features &= ~minus_features;
#ifdef DEBUG_FEATURES
print_features(stderr, fprintf, cpu_def->features, NULL);
#endif
}
/**
* parse_input:
* @argc : Count of (commandline) arguments.
* @argv : (Commandline) arguments.
*
* Parses (commandline) arguments passed to RetroArch.
*
**/
static void parse_input(int argc, char *argv[])
{
runloop_t *runloop = rarch_main_get_ptr();
global_t *global = global_get_ptr();
global->libretro_no_content = false;
global->libretro_dummy = false;
global->has_set_save_path = false;
global->has_set_state_path = false;
global->has_set_libretro = false;
global->has_set_libretro_directory = false;
global->has_set_verbosity = false;
global->has_set_netplay_mode = false;
global->has_set_username = false;
global->has_set_netplay_ip_address = false;
global->has_set_netplay_delay_frames = false;
global->has_set_netplay_ip_port = false;
global->has_set_ups_pref = false;
global->has_set_bps_pref = false;
global->has_set_ips_pref = false;
global->ups_pref = false;
global->bps_pref = false;
global->ips_pref = false;
*global->ups_name = '\0';
*global->bps_name = '\0';
*global->ips_name = '\0';
*global->subsystem = '\0';
global->overrides_active = false;
if (argc < 2)
{
global->libretro_dummy = true;
return;
}
/* Make sure we can call parse_input several times ... */
optind = 0;
int val = 0;
const struct option opts[] = {
#ifdef HAVE_DYNAMIC
{ "libretro", 1, NULL, 'L' },
#endif
{ "menu", 0, &val, 'M' },
{ "help", 0, NULL, 'h' },
{ "save", 1, NULL, 's' },
{ "fullscreen", 0, NULL, 'f' },
{ "record", 1, NULL, 'r' },
{ "recordconfig", 1, &val, 'R' },
{ "size", 1, &val, 's' },
{ "verbose", 0, NULL, 'v' },
{ "config", 1, NULL, 'c' },
{ "appendconfig", 1, &val, 'C' },
{ "nodevice", 1, NULL, 'N' },
{ "dualanalog", 1, NULL, 'A' },
{ "device", 1, NULL, 'd' },
{ "savestate", 1, NULL, 'S' },
{ "bsvplay", 1, NULL, 'P' },
{ "bsvrecord", 1, NULL, 'R' },
{ "sram-mode", 1, NULL, 'M' },
#ifdef HAVE_NETPLAY
{ "host", 0, NULL, 'H' },
{ "connect", 1, NULL, 'C' },
{ "frames", 1, NULL, 'F' },
{ "port", 1, &val, 'p' },
{ "spectate", 0, &val, 'S' },
#endif
{ "nick", 1, &val, 'N' },
#if defined(HAVE_NETWORK_CMD) && defined(HAVE_NETPLAY)
{ "command", 1, &val, 'c' },
#endif
{ "ups", 1, NULL, 'U' },
{ "bps", 1, &val, 'B' },
{ "ips", 1, &val, 'I' },
{ "no-patch", 0, &val, 'n' },
{ "detach", 0, NULL, 'D' },
{ "features", 0, &val, 'f' },
{ "subsystem", 1, NULL, 'Z' },
{ "max-frames", 1, NULL, 'm' },
{ "eof-exit", 0, &val, 'e' },
{ NULL, 0, NULL, 0 }
};
#define FFMPEG_RECORD_ARG "r:"
#ifdef HAVE_DYNAMIC
#define DYNAMIC_ARG "L:"
#else
#define DYNAMIC_ARG
#endif
#ifdef HAVE_NETPLAY
#define NETPLAY_ARG "HC:F:"
#else
#define NETPLAY_ARG
#endif
#define BSV_MOVIE_ARG "P:R:M:"
const char *optstring = "hs:fvS:A:c:U:DN:d:" BSV_MOVIE_ARG NETPLAY_ARG DYNAMIC_ARG FFMPEG_RECORD_ARG;
settings_t *settings = config_get_ptr();
for (;;)
{
int port;
val = 0;
int c = getopt_long(argc, argv, optstring, opts, NULL);
if (c == -1)
break;
switch (c)
{
case 'h':
print_help();
exit(0);
case 'Z':
strlcpy(global->subsystem, optarg, sizeof(global->subsystem));
break;
case 'd':
{
unsigned id = 0;
struct string_list *list = string_split(optarg, ":");
port = 0;
if (list && list->size == 2)
{
port = strtol(list->elems[0].data, NULL, 0);
id = strtoul(list->elems[1].data, NULL, 0);
}
string_list_free(list);
if (port < 1 || port > MAX_USERS)
{
RARCH_ERR("Connect device to a valid port.\n");
print_help();
rarch_fail(1, "parse_input()");
}
settings->input.libretro_device[port - 1] = id;
global->has_set_libretro_device[port - 1] = true;
break;
}
case 'A':
port = strtol(optarg, NULL, 0);
if (port < 1 || port > MAX_USERS)
{
RARCH_ERR("Connect dualanalog to a valid port.\n");
print_help();
rarch_fail(1, "parse_input()");
}
settings->input.libretro_device[port - 1] = RETRO_DEVICE_ANALOG;
global->has_set_libretro_device[port - 1] = true;
break;
case 's':
strlcpy(global->savefile_name, optarg,
sizeof(global->savefile_name));
global->has_set_save_path = true;
break;
case 'f':
global->force_fullscreen = true;
break;
case 'S':
strlcpy(global->savestate_name, optarg,
sizeof(global->savestate_name));
global->has_set_state_path = true;
break;
case 'v':
global->verbosity = true;
global->has_set_verbosity = true;
break;
case 'N':
port = strtol(optarg, NULL, 0);
if (port < 1 || port > MAX_USERS)
{
RARCH_ERR("Disconnect device from a valid port.\n");
print_help();
rarch_fail(1, "parse_input()");
}
settings->input.libretro_device[port - 1] = RETRO_DEVICE_NONE;
global->has_set_libretro_device[port - 1] = true;
break;
case 'c':
strlcpy(global->config_path, optarg,
sizeof(global->config_path));
break;
case 'r':
strlcpy(global->record.path, optarg,
sizeof(global->record.path));
global->record.enable = true;
break;
#ifdef HAVE_DYNAMIC
case 'L':
if (path_is_directory(optarg))
{
*settings->libretro = '\0';
strlcpy(settings->libretro_directory, optarg,
sizeof(settings->libretro_directory));
global->has_set_libretro = true;
global->has_set_libretro_directory = true;
RARCH_WARN("Using old --libretro behavior. Setting libretro_directory to \"%s\" instead.\n", optarg);
}
else
{
strlcpy(settings->libretro, optarg,
sizeof(settings->libretro));
global->has_set_libretro = true;
}
break;
#endif
case 'P':
case 'R':
strlcpy(global->bsv.movie_start_path, optarg,
sizeof(global->bsv.movie_start_path));
global->bsv.movie_start_playback = (c == 'P');
global->bsv.movie_start_recording = (c == 'R');
break;
case 'M':
if (strcmp(optarg, "noload-nosave") == 0)
{
global->sram_load_disable = true;
global->sram_save_disable = true;
}
else if (strcmp(optarg, "noload-save") == 0)
global->sram_load_disable = true;
else if (strcmp(optarg, "load-nosave") == 0)
global->sram_save_disable = true;
else if (strcmp(optarg, "load-save") != 0)
{
RARCH_ERR("Invalid argument in --sram-mode.\n");
print_help();
rarch_fail(1, "parse_input()");
}
break;
#ifdef HAVE_NETPLAY
case 'H':
global->has_set_netplay_ip_address = true;
global->netplay_enable = true;
*global->netplay_server = '\0';
break;
case 'C':
global->has_set_netplay_ip_address = true;
global->netplay_enable = true;
strlcpy(global->netplay_server, optarg,
sizeof(global->netplay_server));
break;
case 'F':
global->netplay_sync_frames = strtol(optarg, NULL, 0);
global->has_set_netplay_delay_frames = true;
break;
#endif
case 'U':
strlcpy(global->ups_name, optarg,
sizeof(global->ups_name));
global->ups_pref = true;
global->has_set_ups_pref = true;
break;
case 'D':
#if defined(_WIN32) && !defined(_XBOX)
FreeConsole();
#endif
break;
case 'm':
runloop->frames.video.max = strtoul(optarg, NULL, 10);
break;
case 0:
switch (val)
{
case 'M':
global->libretro_dummy = true;
break;
#ifdef HAVE_NETPLAY
case 'p':
global->has_set_netplay_ip_port = true;
global->netplay_port = strtoul(optarg, NULL, 0);
break;
case 'S':
global->has_set_netplay_mode = true;
global->netplay_is_spectate = true;
break;
#endif
case 'N':
global->has_set_username = true;
strlcpy(settings->username, optarg,
sizeof(settings->username));
break;
#if defined(HAVE_NETWORK_CMD) && defined(HAVE_NETPLAY)
case 'c':
if (network_cmd_send(optarg))
exit(0);
else
rarch_fail(1, "network_cmd_send()");
break;
#endif
case 'C':
strlcpy(global->append_config_path, optarg,
sizeof(global->append_config_path));
break;
case 'B':
strlcpy(global->bps_name, optarg,
sizeof(global->bps_name));
global->bps_pref = true;
global->has_set_bps_pref = true;
break;
case 'I':
strlcpy(global->ips_name, optarg,
sizeof(global->ips_name));
global->ips_pref = true;
global->has_set_ips_pref = true;
break;
case 'n':
global->block_patch = true;
break;
case 's':
{
if (sscanf(optarg, "%ux%u", &global->record.width,
&global->record.height) != 2)
{
RARCH_ERR("Wrong format for --size.\n");
print_help();
rarch_fail(1, "parse_input()");
}
break;
}
case 'R':
strlcpy(global->record.config, optarg,
sizeof(global->record.config));
break;
case 'f':
print_features();
exit(0);
case 'e':
global->bsv.eof_exit = true;
break;
default:
break;
}
break;
case '?':
print_help();
rarch_fail(1, "parse_input()");
default:
RARCH_ERR("Error parsing arguments.\n");
rarch_fail(1, "parse_input()");
}
}
if (global->libretro_dummy)
{
if (optind < argc)
{
RARCH_ERR("--menu was used, but content file was passed as well.\n");
rarch_fail(1, "parse_input()");
}
}
else if (!*global->subsystem && optind < argc)
rarch_set_paths(argv[optind]);
else if (*global->subsystem && optind < argc)
set_special_paths(argv + optind, argc - optind);
else
global->libretro_no_content = true;
/* Copy SRM/state dirs used, so they can be reused on reentrancy. */
if (global->has_set_save_path &&
path_is_directory(global->savefile_name))
strlcpy(global->savefile_dir, global->savefile_name,
sizeof(global->savefile_dir));
if (global->has_set_state_path &&
path_is_directory(global->savestate_name))
strlcpy(global->savestate_dir, global->savestate_name,
sizeof(global->savestate_dir));
}
/// The status builtin. Gives various status information on fish.
int builtin_status(parser_t &parser, io_streams_t &streams, wchar_t **argv) {
wchar_t *cmd = argv[0];
int argc = builtin_count_args(argv);
status_cmd_opts_t opts;
int optind;
int retval = parse_cmd_opts(opts, &optind, argc, argv, parser, streams);
if (retval != STATUS_CMD_OK) return retval;
if (opts.print_help) {
builtin_print_help(parser, streams, cmd, streams.out);
return STATUS_CMD_OK;
}
// If a status command hasn't already been specified via a flag check the first word.
// Note that this can be simplified after we eliminate allowing subcommands as flags.
if (optind < argc) {
status_cmd_t subcmd = str_to_enum(argv[optind], status_enum_map, status_enum_map_len);
if (subcmd != STATUS_UNDEF) {
if (!set_status_cmd(cmd, opts, subcmd, streams)) {
return STATUS_CMD_ERROR;
}
optind++;
} else {
streams.err.append_format(BUILTIN_ERR_INVALID_SUBCMD, cmd, argv[1]);
return STATUS_INVALID_ARGS;
}
}
// Every argument that we haven't consumed already is an argument for a subcommand.
const wcstring_list_t args(argv + optind, argv + argc);
switch (opts.status_cmd) {
case STATUS_UNDEF: {
CHECK_FOR_UNEXPECTED_STATUS_ARGS(opts.status_cmd)
if (is_login) {
streams.out.append_format(_(L"This is a login shell\n"));
} else {
streams.out.append_format(_(L"This is not a login shell\n"));
}
streams.out.append_format(
_(L"Job control: %ls\n"),
job_control_mode == JOB_CONTROL_INTERACTIVE
? _(L"Only on interactive jobs")
: (job_control_mode == JOB_CONTROL_NONE ? _(L"Never") : _(L"Always")));
streams.out.append(parser.stack_trace());
break;
}
case STATUS_SET_JOB_CONTROL: {
if (opts.new_job_control_mode != -1) {
// Flag form was used.
CHECK_FOR_UNEXPECTED_STATUS_ARGS(opts.status_cmd)
} else {
if (args.size() != 1) {
const wchar_t *subcmd_str = enum_to_str(opts.status_cmd, status_enum_map);
streams.err.append_format(BUILTIN_ERR_ARG_COUNT2, cmd, subcmd_str, 1,
args.size());
return STATUS_INVALID_ARGS;
}
opts.new_job_control_mode = job_control_str_to_mode(args[0].c_str(), cmd, streams);
if (opts.new_job_control_mode == -1) {
return STATUS_CMD_ERROR;
}
}
job_control_mode = opts.new_job_control_mode;
break;
}
case STATUS_FEATURES: {
print_features(streams);
break;
}
case STATUS_TEST_FEATURE: {
if (args.size() != 1) {
const wchar_t *subcmd_str = enum_to_str(opts.status_cmd, status_enum_map);
streams.err.append_format(BUILTIN_ERR_ARG_COUNT2, cmd, subcmd_str, 1, args.size());
return STATUS_INVALID_ARGS;
}
const auto *metadata = features_t::metadata_for(args.front().c_str());
if (!metadata) {
retval = TEST_FEATURE_NOT_RECOGNIZED;
} else {
retval = feature_test(metadata->flag) ? TEST_FEATURE_ON : TEST_FEATURE_OFF;
}
break;
}
case STATUS_FILENAME: {
CHECK_FOR_UNEXPECTED_STATUS_ARGS(opts.status_cmd)
const wchar_t *fn = parser.current_filename();
if (!fn) fn = _(L"Standard input");
streams.out.append_format(L"%ls\n", fn);
break;
}
case STATUS_FUNCTION: {
CHECK_FOR_UNEXPECTED_STATUS_ARGS(opts.status_cmd)
const wchar_t *fn = parser.get_function_name(opts.level);
if (!fn) fn = _(L"Not a function");
streams.out.append_format(L"%ls\n", fn);
break;
}
case STATUS_LINE_NUMBER: {
CHECK_FOR_UNEXPECTED_STATUS_ARGS(opts.status_cmd)
// TBD is how to interpret the level argument when fetching the line number.
// See issue #4161.
// streams.out.append_format(L"%d\n", parser.get_lineno(opts.level));
streams.out.append_format(L"%d\n", parser.get_lineno());
break;
}
case STATUS_IS_INTERACTIVE: {
CHECK_FOR_UNEXPECTED_STATUS_ARGS(opts.status_cmd)
retval = !is_interactive_session;
break;
}
case STATUS_IS_COMMAND_SUB: {
CHECK_FOR_UNEXPECTED_STATUS_ARGS(opts.status_cmd)
retval = !is_subshell;
break;
}
case STATUS_IS_BLOCK: {
CHECK_FOR_UNEXPECTED_STATUS_ARGS(opts.status_cmd)
retval = !is_block;
break;
}
case STATUS_IS_BREAKPOINT: {
CHECK_FOR_UNEXPECTED_STATUS_ARGS(opts.status_cmd)
retval = !is_breakpoint;
break;
}
case STATUS_IS_LOGIN: {
CHECK_FOR_UNEXPECTED_STATUS_ARGS(opts.status_cmd)
retval = !is_login;
break;
}
case STATUS_IS_FULL_JOB_CTRL: {
CHECK_FOR_UNEXPECTED_STATUS_ARGS(opts.status_cmd)
retval = job_control_mode != JOB_CONTROL_ALL;
break;
}
case STATUS_IS_INTERACTIVE_JOB_CTRL: {
CHECK_FOR_UNEXPECTED_STATUS_ARGS(opts.status_cmd)
retval = job_control_mode != JOB_CONTROL_INTERACTIVE;
break;
}
case STATUS_IS_NO_JOB_CTRL: {
CHECK_FOR_UNEXPECTED_STATUS_ARGS(opts.status_cmd)
retval = job_control_mode != JOB_CONTROL_NONE;
break;
}
case STATUS_STACK_TRACE: {
CHECK_FOR_UNEXPECTED_STATUS_ARGS(opts.status_cmd)
streams.out.append(parser.stack_trace());
break;
}
case STATUS_CURRENT_CMD: {
CHECK_FOR_UNEXPECTED_STATUS_ARGS(opts.status_cmd)
// HACK: Go via the deprecated variable to get the command.
const auto var = env_get(L"_");
if (!var.missing_or_empty()) {
streams.out.append(var->as_string());
streams.out.push_back(L'\n');
} else {
streams.out.append(program_name);
streams.out.push_back(L'\n');
}
break;
}
case STATUS_FISH_PATH: {
CHECK_FOR_UNEXPECTED_STATUS_ARGS(opts.status_cmd)
streams.out.append(str2wcstring(get_executable_path("fish")));
streams.out.push_back(L'\n');
break;
}
}
return retval;
}
/**
* parse_input:
* @argc : Count of (commandline) arguments.
* @argv : (Commandline) arguments.
*
* Parses (commandline) arguments passed to program.
*
**/
static void parse_input(int argc, char *argv[])
{
const char *optstring = NULL;
global_t *global = global_get_ptr();
settings_t *settings = config_get_ptr();
const struct option opts[] = {
#ifdef HAVE_DYNAMIC
{ "libretro", 1, NULL, 'L' },
#endif
{ "menu", 0, NULL, RA_OPT_MENU },
{ "help", 0, NULL, 'h' },
{ "save", 1, NULL, 's' },
{ "fullscreen", 0, NULL, 'f' },
{ "record", 1, NULL, 'r' },
{ "recordconfig", 1, NULL, RA_OPT_RECORDCONFIG },
{ "size", 1, NULL, RA_OPT_SIZE },
{ "verbose", 0, NULL, 'v' },
{ "config", 1, NULL, 'c' },
{ "appendconfig", 1, NULL, RA_OPT_APPENDCONFIG },
{ "nodevice", 1, NULL, 'N' },
{ "dualanalog", 1, NULL, 'A' },
{ "device", 1, NULL, 'd' },
{ "savestate", 1, NULL, 'S' },
{ "bsvplay", 1, NULL, 'P' },
{ "bsvrecord", 1, NULL, 'R' },
{ "sram-mode", 1, NULL, 'M' },
#ifdef HAVE_NETPLAY
{ "host", 0, NULL, 'H' },
{ "connect", 1, NULL, 'C' },
{ "frames", 1, NULL, 'F' },
{ "port", 1, NULL, RA_OPT_PORT },
{ "spectate", 0, NULL, RA_OPT_SPECTATE },
#endif
{ "nick", 1, NULL, RA_OPT_NICK },
#if defined(HAVE_NETWORK_CMD) && defined(HAVE_NETPLAY)
{ "command", 1, NULL, RA_OPT_COMMAND },
#endif
{ "ups", 1, NULL, 'U' },
{ "bps", 1, NULL, RA_OPT_BPS },
{ "ips", 1, NULL, RA_OPT_IPS },
{ "no-patch", 0, NULL, RA_OPT_NO_PATCH },
{ "detach", 0, NULL, 'D' },
{ "features", 0, NULL, RA_OPT_FEATURES },
{ "subsystem", 1, NULL, RA_OPT_SUBSYSTEM },
{ "max-frames", 1, NULL, RA_OPT_MAX_FRAMES },
{ "eof-exit", 0, NULL, RA_OPT_EOF_EXIT },
{ "version", 0, NULL, RA_OPT_VERSION },
#ifdef HAVE_FILE_LOGGER
{ "log-file", 1, NULL, RA_OPT_LOG_FILE },
#endif
{ NULL, 0, NULL, 0 }
};
global->inited.core.no_content = false;
global->inited.core.type = CORE_TYPE_PLAIN;
*global->subsystem = '\0';
global->has_set.save_path = false;
global->has_set.state_path = false;
global->has_set.libretro = false;
global->has_set.libretro_directory = false;
global->has_set.verbosity = false;
global->has_set.netplay_mode = false;
global->has_set.username = false;
global->has_set.netplay_ip_address = false;
global->has_set.netplay_delay_frames = false;
global->has_set.netplay_ip_port = false;
global->has_set.ups_pref = false;
global->has_set.bps_pref = false;
global->has_set.ips_pref = false;
global->patch.ups_pref = false;
global->patch.bps_pref = false;
global->patch.ips_pref = false;
*global->name.ups = '\0';
*global->name.bps = '\0';
*global->name.ips = '\0';
global->overrides_active = false;
if (argc < 2)
{
global->inited.core.type = CORE_TYPE_DUMMY;
return;
}
/* Make sure we can call parse_input several times ... */
optind = 0;
optstring = "hs:fvS:A:c:U:DN:d:" BSV_MOVIE_ARG NETPLAY_ARG DYNAMIC_ARG FFMPEG_RECORD_ARG;
for (;;)
{
int port;
int c = getopt_long(argc, argv, optstring, opts, NULL);
if (c == -1)
break;
switch (c)
{
case 'h':
print_help(argv[0]);
exit(0);
case 'd':
{
unsigned id = 0;
struct string_list *list = string_split(optarg, ":");
port = 0;
if (list && list->size == 2)
{
port = strtol(list->elems[0].data, NULL, 0);
id = strtoul(list->elems[1].data, NULL, 0);
}
string_list_free(list);
if (port < 1 || port > MAX_USERS)
{
RARCH_ERR("Connect device to a valid port.\n");
print_help(argv[0]);
rarch_fail(1, "parse_input()");
}
settings->input.libretro_device[port - 1] = id;
global->has_set.libretro_device[port - 1] = true;
break;
}
case 'A':
port = strtol(optarg, NULL, 0);
if (port < 1 || port > MAX_USERS)
{
RARCH_ERR("Connect dualanalog to a valid port.\n");
print_help(argv[0]);
rarch_fail(1, "parse_input()");
}
settings->input.libretro_device[port - 1] = RETRO_DEVICE_ANALOG;
global->has_set.libretro_device[port - 1] = true;
break;
case 's':
strlcpy(global->name.savefile, optarg,
sizeof(global->name.savefile));
global->has_set.save_path = true;
break;
case 'f':
global->force_fullscreen = true;
break;
case 'S':
strlcpy(global->name.savestate, optarg,
sizeof(global->name.savestate));
global->has_set.state_path = true;
break;
case 'v':
global->verbosity = true;
global->has_set.verbosity = true;
break;
case 'N':
port = strtol(optarg, NULL, 0);
if (port < 1 || port > MAX_USERS)
{
RARCH_ERR("Disconnect device from a valid port.\n");
print_help(argv[0]);
rarch_fail(1, "parse_input()");
}
settings->input.libretro_device[port - 1] = RETRO_DEVICE_NONE;
global->has_set.libretro_device[port - 1] = true;
break;
case 'c':
strlcpy(global->path.config, optarg,
sizeof(global->path.config));
break;
case 'r':
strlcpy(global->record.path, optarg,
sizeof(global->record.path));
global->record.enable = true;
break;
#ifdef HAVE_DYNAMIC
case 'L':
if (path_is_directory(optarg))
{
*settings->libretro = '\0';
strlcpy(settings->libretro_directory, optarg,
sizeof(settings->libretro_directory));
global->has_set.libretro = true;
global->has_set.libretro_directory = true;
RARCH_WARN("Using old --libretro behavior. Setting libretro_directory to \"%s\" instead.\n", optarg);
}
else
{
strlcpy(settings->libretro, optarg,
sizeof(settings->libretro));
global->has_set.libretro = true;
}
break;
#endif
case 'P':
case 'R':
strlcpy(global->bsv.movie_start_path, optarg,
sizeof(global->bsv.movie_start_path));
global->bsv.movie_start_playback = (c == 'P');
global->bsv.movie_start_recording = (c == 'R');
break;
case 'M':
if (!strcmp(optarg, "noload-nosave"))
{
global->sram.load_disable = true;
global->sram.save_disable = true;
}
else if (!strcmp(optarg, "noload-save"))
global->sram.load_disable = true;
else if (!strcmp(optarg, "load-nosave"))
global->sram.save_disable = true;
else if (strcmp(optarg, "load-save") != 0)
{
RARCH_ERR("Invalid argument in --sram-mode.\n");
print_help(argv[0]);
rarch_fail(1, "parse_input()");
}
break;
#ifdef HAVE_NETPLAY
case 'H':
global->has_set.netplay_ip_address = true;
global->netplay.enable = true;
*global->netplay.server = '\0';
break;
case 'C':
global->has_set.netplay_ip_address = true;
global->netplay.enable = true;
strlcpy(global->netplay.server, optarg,
sizeof(global->netplay.server));
break;
case 'F':
global->netplay.sync_frames = strtol(optarg, NULL, 0);
global->has_set.netplay_delay_frames = true;
break;
#endif
case RA_OPT_BPS:
strlcpy(global->name.bps, optarg,
sizeof(global->name.bps));
global->patch.bps_pref = true;
global->has_set.bps_pref = true;
break;
case 'U':
strlcpy(global->name.ups, optarg,
sizeof(global->name.ups));
global->patch.ups_pref = true;
global->has_set.ups_pref = true;
break;
case RA_OPT_IPS:
strlcpy(global->name.ips, optarg,
sizeof(global->name.ips));
global->patch.ips_pref = true;
global->has_set.ips_pref = true;
break;
case RA_OPT_NO_PATCH:
global->patch.block_patch = true;
break;
case 'D':
#if defined(_WIN32) && !defined(_XBOX)
FreeConsole();
#endif
break;
case RA_OPT_MENU:
global->inited.core.type = CORE_TYPE_DUMMY;
break;
#ifdef HAVE_NETPLAY
case RA_OPT_PORT:
global->has_set.netplay_ip_port = true;
global->netplay.port = strtoul(optarg, NULL, 0);
break;
case RA_OPT_SPECTATE:
global->has_set.netplay_mode = true;
global->netplay.is_spectate = true;
break;
#endif
case RA_OPT_NICK:
global->has_set.username = true;
strlcpy(settings->username, optarg,
sizeof(settings->username));
break;
#if defined(HAVE_NETWORK_CMD) && defined(HAVE_NETPLAY)
case RA_OPT_COMMAND:
if (network_cmd_send(optarg))
exit(0);
else
rarch_fail(1, "network_cmd_send()");
break;
#endif
case RA_OPT_APPENDCONFIG:
strlcpy(global->path.append_config, optarg,
sizeof(global->path.append_config));
break;
case RA_OPT_SIZE:
{
if (sscanf(optarg, "%ux%u", &global->record.width,
&global->record.height) != 2)
{
RARCH_ERR("Wrong format for --size.\n");
print_help(argv[0]);
rarch_fail(1, "parse_input()");
}
break;
}
case RA_OPT_RECORDCONFIG:
strlcpy(global->record.config, optarg,
sizeof(global->record.config));
break;
case RA_OPT_MAX_FRAMES:
{
unsigned max_frames = strtoul(optarg, NULL, 10);
rarch_main_ctl(RARCH_MAIN_CTL_SET_MAX_FRAMES, &max_frames);
}
break;
case RA_OPT_SUBSYSTEM:
strlcpy(global->subsystem, optarg, sizeof(global->subsystem));
break;
case RA_OPT_FEATURES:
print_features();
exit(0);
case RA_OPT_EOF_EXIT:
global->bsv.eof_exit = true;
break;
case RA_OPT_VERSION:
print_version();
exit(0);
#ifdef HAVE_FILE_LOGGER
case RA_OPT_LOG_FILE:
global->log_file = fopen(optarg, "wb");
break;
#endif
case '?':
print_help(argv[0]);
rarch_fail(1, "parse_input()");
default:
RARCH_ERR("Error parsing arguments.\n");
rarch_fail(1, "parse_input()");
}
}
if (global->inited.core.type == CORE_TYPE_DUMMY)
{
if (optind < argc)
{
RARCH_ERR("--menu was used, but content file was passed as well.\n");
rarch_fail(1, "parse_input()");
}
}
else if (!*global->subsystem && optind < argc)
rarch_set_paths(argv[optind]);
else if (*global->subsystem && optind < argc)
set_special_paths(argv + optind, argc - optind);
else
global->inited.core.no_content = true;
/* Copy SRM/state dirs used, so they can be reused on reentrancy. */
if (global->has_set.save_path &&
path_is_directory(global->name.savefile))
strlcpy(global->dir.savefile, global->name.savefile,
sizeof(global->dir.savefile));
if (global->has_set.state_path &&
path_is_directory(global->name.savestate))
strlcpy(global->dir.savestate, global->name.savestate,
sizeof(global->dir.savestate));
}
