int
param_main(int argc, char *argv[])
{
if (argc >= 2) {
if (!strcmp(argv[1], "save")) {
if (argc >= 3) {
do_save(argv[2]);
} else {
do_save(param_get_default_file());
}
}
if (!strcmp(argv[1], "load")) {
if (argc >= 3) {
do_load(argv[2]);
} else {
do_load(param_get_default_file());
}
}
if (!strcmp(argv[1], "import")) {
if (argc >= 3) {
do_import(argv[2]);
} else {
do_import(param_get_default_file());
}
}
if (!strcmp(argv[1], "select")) {
if (argc >= 3) {
param_set_default_file(argv[2]);
} else {
param_set_default_file(NULL);
}
warnx("selected parameter default file %s", param_get_default_file());
exit(0);
}
if (!strcmp(argv[1], "show"))
if (argc >= 3) {
do_show(argv[2]);
} else {
do_show(NULL);
}
}
errx(1, "expected a command, try 'load', 'import', 'show', 'select' or 'save'");
}
static void event_handler(switch_event_t *event)
{
if (globals.auto_reload) {
do_load();
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "PocketSphinx Reloaded\n");
}
}
static dbus_bool_t
check_loader_oom_func (void *data)
{
LoaderOomData *d = data;
return do_load (d->full_path, d->validity, TRUE);
}
void BaseTextureLoader::into(Loadable& resource, const LoaderOptions& options) {
Loadable* res_ptr = &resource;
Texture* tex = dynamic_cast<Texture*>(res_ptr);
assert(tex && "You passed a Resource that is not a texture to the texture loader");
std::vector<unsigned char> buffer(
(std::istreambuf_iterator<char>(*this->data_)),
std::istreambuf_iterator<char>()
);
auto result = do_load(buffer);
/* Respect the auto_upload option if it exists*/
bool auto_upload = true;
if(options.count("auto_upload")) {
auto_upload = smlt::any_cast<bool>(options.at("auto_upload"));
}
if (result.data.empty()) {
L_ERROR(_F("Unable to load texture with name: {0}").format(filename_));
throw std::runtime_error("Couldn't load the file: " + filename_.encode());
} else {
tex->set_source(filename_);
tex->set_format(result.format, result.texel_type);
tex->resize(result.width, result.height);
tex->data().assign(result.data.begin(), result.data.end());
tex->set_auto_upload(auto_upload);
if(format_stored_upside_down()) {
tex->flip_vertically();
}
}
}
void G1PreBarrierStub::emit_code(LIR_Assembler* ce) {
// At this point we know that marking is in progress.
// If do_load() is true then we have to emit the
// load of the previous value; otherwise it has already
// been loaded into _pre_val.
__ bind(_entry);
assert(pre_val()->is_register(), "Precondition.");
Register pre_val_reg = pre_val()->as_register();
if (do_load()) {
ce->mem2reg(addr(), pre_val(), T_OBJECT, patch_code(), info(), false /*wide*/, false /*unaligned*/);
}
if (__ is_in_wdisp16_range(_continuation)) {
__ br_null(pre_val_reg, /*annul*/false, Assembler::pt, _continuation);
} else {
__ cmp(pre_val_reg, G0);
__ brx(Assembler::equal, false, Assembler::pn, _continuation);
}
__ delayed()->nop();
__ call(Runtime1::entry_for(Runtime1::Runtime1::g1_pre_barrier_slow_id));
__ delayed()->mov(pre_val_reg, G4);
__ br(Assembler::always, false, Assembler::pt, _continuation);
__ delayed()->nop();
}
select_world::select_world(editor_world_ptr w, QWidget* parent)
: QDialog(parent)
, world_(w)
{
setWindowTitle("Load the world");
setWindowIcon(QIcon(":/core/life.png"));
setFixedSize(200, 150);
setModal(true);
QGridLayout* l = new QGridLayout(this);
// World id
l->addWidget(new QLabel("Id: ", this), 0, 0);
world_id_ = new QLineEdit(this);
world_id_->setText(QString::number(world_->id()));
l->addWidget(world_id_, 0, 1, 1, 2);
// Buttons
QPushButton* btn_cancel = new QPushButton("Cancel", this);
btn_cancel->setMaximumWidth(80);
l->addWidget(btn_cancel, 1, 1);
connect(btn_cancel, SIGNAL(clicked()), SLOT(do_cancel()));
QPushButton* btn_load = new QPushButton("Load", this);
btn_load->setMaximumWidth(80);
l->addWidget(btn_load, 1, 2);
connect(btn_load, SIGNAL(clicked()), SLOT(do_load()));
}
int main (int argc, char ** argv)
{
uint64_t * p0;
const char * source_fname;
size_t embed_minimum_size;
if (argc < 2) {
fputs ("Usage: winloader.exe <program.prg> [args...]\n", stderr);
return 1;
}
source_fname = argv[1];
embed_minimum_size = init_load (source_fname);
p0 = VirtualAlloc (NULL, embed_minimum_size + MAX_HEAP_SIZE,
MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
assert (p0 != NULL);
printf ("p0 = %p\n", p0);
init_syscall
((((uint64_t) p0) + embed_minimum_size),
(((uint64_t) p0) + embed_minimum_size + MAX_HEAP_SIZE));
do_load (p0, syscall_shim, source_fname);
printf ("launch = %p\n\n\n\n", p0);
go_shim (p0, argc - 1, &argv[1]);
/* failure...! */
return 1;
}
int setfont_main(int argc UNUSED_PARAM, char **argv)
{
size_t len;
struct psf_header *psfhdr;
char *mapfilename;
int fd;
opt_complementary = "=1";
getopt32(argv, "m:", &mapfilename);
argv += optind;
// load font
len = 32*1024; // can't be larger
psfhdr = (struct psf_header *) xmalloc_open_zipped_read_close(*argv, &len);
fd = get_console_fd_or_die();
do_load(fd, psfhdr, len);
// load the screen map, if any
if (option_mask32 & 1) { // -m
void *map = xmalloc_open_zipped_read_close(mapfilename, &len);
if (len == E_TABSZ || len == 2*E_TABSZ) {
xioctl(fd, (len == 2*E_TABSZ) ? PIO_UNISCRNMAP : PIO_SCRNMAP, map);
}
}
return EXIT_SUCCESS;
}
static void event_handler(switch_event_t *event)
{
switch_mutex_lock(MUTEX);
do_unload();
do_load();
switch_mutex_unlock(MUTEX);
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Number Translations Reloaded\n");
}
/**
* @param file_path Путь к файлу документа
* @param params Параметры загрузки документа
* @param loc Локализация документа
* @throw SyntaxError Ошибка синтаксиса в документе
* @throw MacroError Ошибка при обработке макрокоманды
*/
inline
Document::Document( const Path_t & file_path
, const LoadParams & params /*= default_load_params()*/
, const std::locale & loc /*= std::locale()*/
)
{
do_load( file_path , params , loc );
}
int main(void)
{
OCI_Connection *con = NULL;
if (!OCI_Initialize(NULL, NULL, OCI_ENV_DEFAULT))
{
return EXIT_FAILURE;
}
con = OCI_ConnectionCreate("db", "usr", "pwd", OCI_SESSION_DEFAULT);
/* Nominal test */
do_load(con, FALSE, FALSE, FALSE, FALSE, "TEST BASE - DEFAULT MODE");
/* insufficient stream buffer size tests */
do_load(con, FALSE, FALSE, TRUE, FALSE, "TEST SMALL BUFFER - DEFAULT MODE");
do_load(con, FALSE, FALSE, TRUE, TRUE, "TEST SMALL BUFFER - FORCE MODE");
/* conversion error tests */
do_load(con, TRUE, FALSE, FALSE, FALSE, "TEST CONV ERROR - DEFAULT MODE");
do_load(con, TRUE, FALSE, FALSE, TRUE, "TEST CONV ERROR - FORCE MODE");
/* loading error tests */
if (partionning_enabled)
{
do_load(con, FALSE, TRUE, FALSE, FALSE, "TEST LOAD ERROR - DEFAULT MODE");
do_load(con, FALSE, TRUE, FALSE, TRUE, "TEST LOAD ERROR - FORCE MODE");
}
OCI_ConnectionFree(con);
OCI_Cleanup();
return EXIT_SUCCESS;
}
/**
* @param [in,out] is Поток ввода для загрузки документа
* @param params Параметры загрузки документа
* @throw SyntaxError Ошибка синтаксиса в документе
* @throw MacroError Ошибка при обработке макрокоманды
*/
inline
void
Document::load( InStream_t & is
, const LoadParams & params /*= default_load_params()*/
)
{
clear();
do_load( is , params );
}
static void event_handler(switch_event_t *event)
{
if (globals.auto_reload) {
switch_mutex_lock(MUTEX);
do_load();
switch_mutex_unlock(MUTEX);
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "ENUM Reloaded\n");
}
}
static GwyContainer*
hitachi_load(const gchar *filename,
G_GNUC_UNUSED GwyRunType mode,
GError **error,
const gchar *name)
{
GwyContainer *container = NULL;
guchar *buffer = NULL;
gsize size = 0;
GError *err = NULL;
GwyDataField *dfield = NULL;
GwyDataField *(*do_load)(const guchar*, guint, GError**);
guint header_size;
if (gwy_strequal(name, "hitachi-afm")) {
do_load = &read_data_field;
header_size = HEADER_SIZE;
}
else if (gwy_strequal(name, "hitachi-afm-old")) {
do_load = &read_data_field_old;
header_size = HEADER_SIZE_OLD;
}
else {
g_set_error(error, GWY_MODULE_FILE_ERROR,
GWY_MODULE_FILE_ERROR_UNIMPLEMENTED,
_("Hitachi-AFM has not registered file type `%s'."), name);
return NULL;
}
if (!gwy_file_get_contents(filename, &buffer, &size, &err)) {
err_GET_FILE_CONTENTS(error, &err);
return NULL;
}
if (size < header_size + 2) {
err_TOO_SHORT(error);
gwy_file_abandon_contents(buffer, size, NULL);
return NULL;
}
dfield = do_load(buffer, size, error);
gwy_file_abandon_contents(buffer, size, NULL);
if (!dfield)
return NULL;
container = gwy_container_new();
gwy_container_set_object_by_name(container, "/0/data", dfield);
g_object_unref(dfield);
gwy_container_set_string_by_name(container, "/0/data/title",
g_strdup("Topography"));
gwy_app_channel_check_nonsquare(container, 0);
gwy_file_channel_import_log_add(container, 0, NULL, filename);
return container;
}
void json_item_substitution::load( JsonObject &jo )
{
if( !jo.has_array( "substitutions" ) ) {
jo.throw_error( "No `substitutions` array found." );
}
JsonArray outer_arr = jo.get_array( "substitutions" );
while( outer_arr.has_more() ) {
JsonObject subobj = outer_arr.next_object();
do_load( subobj );
}
}
int main(int argc, char * const *argv) {
int opt = 0;
// getopt treats argv interstingly
while ((opt = getopt(argc, argv, "b:p:")) != -1) {
switch (opt) {
case 'b':
baud = optarg;
break;
case 'p':
port = optarg;
break;
default:
usage();
break;
}
}
int baudi = atoi(baud);
int bval = lookup_baud(baudi);
if (bval <= 0) {
fprintf(stderr, "Not a recognized baud rate: %s\n", baud);
exit(EXIT_FAILURE);
}
if (optind >= argc) {
usage();
}
command = argv[optind++];
if (optind < argc) {
filename = argv[optind++];
}
if (optind < argc) {
usage();
}
openport(bval);
if (!strcmp(command, "dump")) {
do_dump();
}
else if (!strcmp(command, "load")) {
do_load();
}
else {
fprintf(stderr, "unknown command '%s'\n", command);
usage();
}
return EXIT_SUCCESS;
}
static
void read_keypress()
{
// Get keypress
int c = fgetc( stdin );
// Ignore EOF (e.g. when stdin is /dev/null)
if (c == EOF) return;
switch(c) {
// Pause/Play
case 'p':
if (get_state() == MADJACK_STATE_PLAYING) {
do_pause();
} else {
do_play();
}
break;
// Load
case 'l': {
char* filepath = read_filepath();
do_load( filepath );
free( filepath );
break;
}
case 'e': do_eject(); break;
case 's': do_stop(); break;
case 'q': do_quit(); break;
case 'c': do_cue(0.0f); break;
case 'C': {
float cuepoint = read_cuepoint();
do_cue( cuepoint );
break;
}
default:
printf( "Unknown command '%c'.\n", (char)c );
case 'h':
case '?':
display_keyhelp();
break;
// Ignore return and enter
case 13:
case 10:
break;
}
}
static
int load_handler(const char *path, const char *types, lo_arg **argv, int argc,
lo_message msg, void *user_data)
{
// Double check arguments
if (argc!=1 || types[0] != LO_STRING) {
fprintf(stderr, "Error: was expecting single string argument to /deck/load\n");
return -1;
}
// Load the requested track
do_load( &argv[0]->s );
return 0;
}
/* use_egg:
* Reads an EGG script from a block of memory.
*/
EGG *use_egg(void *data, int length, char *error)
{
EGG *egg;
egg_data = data;
egg_data_length = length;
egg = do_load(error);
egg_data = NULL;
egg_data_length = 0;
return egg;
}
int
param_main(int argc, char *argv[])
{
if (argc >= 2) {
if (!strcmp(argv[1], "save")) {
if (argc >= 3) {
do_save(argv[2]);
} else {
do_save(param_file_name_default);
}
}
if (!strcmp(argv[1], "load")) {
if (argc >= 3) {
do_load(argv[2]);
} else {
do_load(param_file_name_default);
}
}
if (!strcmp(argv[1], "import")) {
if (argc >= 3) {
do_import(argv[2]);
} else {
do_import(param_file_name_default);
}
}
if (!strcmp(argv[1], "show")) {
do_show();
}
}
errx(1, "expected a command, try 'load', 'import', 'show' or 'save'\n");
}
int
param_main(int argc, char *argv[])
{
if (argc >= 2) {
if (!strcmp(argv[1], "save"))
do_save();
if (!strcmp(argv[1], "load"))
do_load();
if (!strcmp(argv[1], "import"))
do_import();
if (!strcmp(argv[1], "show"))
do_show();
}
errx(1, "expected a command, try 'load', 'import', 'show' or 'save'\n");
}
/* load_egg:
* Reads an EGG script from a disk file.
*/
EGG *load_egg(char *filename, char *error)
{
EGG *egg;
egg_file = pack_fopen(filename, F_READ);
if (!egg_file) {
strcpy(error, "File not found");
return NULL;
}
egg = do_load(error);
pack_fclose(egg_file);
egg_file = NULL;
return egg;
}
void G1PreBarrierStub::emit_code(LIR_Assembler* ce) {
// At this point we know that marking is in progress.
// If do_load() is true then we have to emit the
// load of the previous value; otherwise it has already
// been loaded into _pre_val.
__ bind(_entry);
assert(pre_val()->is_register(), "Precondition.");
Register pre_val_reg = pre_val()->as_register();
if (do_load()) {
ce->mem2reg(addr(), pre_val(), T_OBJECT, patch_code(), info(), false /*wide*/, false /*unaligned*/);
}
__ cbz(pre_val_reg, _continuation);
ce->store_parameter(pre_val()->as_register(), 0);
__ far_call(RuntimeAddress(Runtime1::entry_for(Runtime1::g1_pre_barrier_slow_id)));
__ b(_continuation);
}
static symtab_t load_symtab(char *filename) {
int fd;
symtab_t symtab;
symtab = (symtab_t) xmalloc(sizeof(*symtab));
memset(symtab, 0, sizeof(*symtab));
fd = open(filename, O_RDONLY);
if (0 > fd) {
ALOGE("%s open\n", __func__);
return NULL;
}
if (0 > do_load(fd, symtab)) {
ALOGE("Error ELF parsing %s\n", filename);
free(symtab);
symtab = NULL;
}
close(fd);
return symtab;
}
int ConfigImpl::load(string cfg_file)
{
int rv = 0;
reset();
_cfg_file = cfg_file;
fstream conf;
conf.open(_cfg_file.c_str(), ios::in | ios::binary);
if(!conf)
{
conf.close();
return -1;
}
rv = do_load(conf);
conf.close();
return rv ;
}
static dbus_bool_t
check_file_valid (DBusString *full_path,
Validity validity)
{
dbus_bool_t retval;
if (validity == VALID)
printf ("Testing valid file:\n");
else if (validity == INVALID)
printf ("Testing invalid file:\n");
else
printf ("Testing unknown file:\n");
/* print the filename, just so we match the other output */
printf (" %s\n", _dbus_string_get_const_data (full_path));
/* only test one file */
retval = do_load (full_path, validity, TRUE);
return retval;
}
void G1PreBarrierStub::emit_code(LIR_Assembler* ce) {
// At this point we know that marking is in progress.
// If do_load() is true then we have to emit the
// load of the previous value; otherwise it has already
// been loaded into _pre_val.
__ bind(_entry);
ce->check_reserved_argument_area(16); // RT stub needs 2 spill slots.
assert(pre_val()->is_register(), "Precondition.");
Register pre_val_reg = pre_val()->as_register();
if (do_load()) {
ce->mem2reg(addr(), pre_val(), T_OBJECT, patch_code(), info(), false /*wide*/, false /*unaligned*/);
}
__ z_ltgr(Z_R1_scratch, pre_val_reg); // Pass oop in Z_R1_scratch to Runtime1::g1_pre_barrier_slow_id.
__ branch_optimized(Assembler::bcondZero, _continuation);
ce->emit_call_c(Runtime1::entry_for (Runtime1::g1_pre_barrier_slow_id));
CHECK_BAILOUT();
__ branch_optimized(Assembler::bcondAlways, _continuation);
}
mcfly_err_t mcfly_mod_load(mcfly_t mcfly)
{
DIR *dir;
char fpath[(MCFLY_MAX_STRING_LEN * 2) + 2];
const char *dname;
void *handle;
struct dirent *entry;
mcfly_mod_t *mod;
/* Open the path where modules are located */
dname = mcfly_cfg_get_from_key(mcfly->configs, MCFLY_CFG_MODULES_PATH);
if (!dname || !(dir = opendir(dname)))
return MCFLY_ERR_ODIR;
/* Pull out the symbols from the modules we care about */
while ((entry = readdir(dir)))
{
snprintf(fpath, MCFLY_MAX_STRING_LEN*2, "%s/%s", dname, entry->d_name);
if (!(handle = dlopen(fpath, RTLD_NOW)))
continue;
if (!(mod = (mcfly_mod_t *)dlsym(handle,MCFLY_MODULE_STRUCT_STRING)) ||
!do_load(mcfly, mod->name))
{
dlclose(handle);
continue;
}
mod->dl_handle = handle;
if (!mcfly->modules)
mcfly->modules = mod;
else
mcfly_util_list_add(&mcfly->modules->list, &mod->list);
}
closedir(dir);
return MCFLY_SUCCESS;
}
int loadfont_main(int argc UNUSED_PARAM, char **argv)
{
size_t len;
unsigned char *buffer;
// no arguments allowed!
opt_complementary = "=0";
getopt32(argv, "");
/*
* We used to look at the length of the input file
* with stat(); now that we accept compressed files,
* just read the entire file.
*/
len = 32*1024; // can't be larger
buffer = xmalloc_read(STDIN_FILENO, &len);
// xmalloc_open_zipped_read_close(filename, &len);
if (!buffer)
bb_perror_msg_and_die("error reading input font");
do_load(get_console_fd_or_die(), buffer, len);
return EXIT_SUCCESS;
}
static symtab_t
load_symtab(char *filename)
{
int fd;
symtab_t symtab;
symtab = (symtab_t) xmalloc(sizeof(*symtab));
memset(symtab, 0, sizeof(*symtab));
fd = open(filename, O_RDONLY);
if (0 > fd) {
//perror("open");
return NULL;
}
if (0 > do_load(fd, symtab)) {
#ifdef DEBUG
printf("Error ELF parsing %s\n", filename);
#endif
free(symtab);
symtab = NULL;
}
close(fd);
return symtab;
}
