static DEVICE_START( ym2203 ) { static const ym2203_interface generic_2203 = { { AY8910_LEGACY_OUTPUT, AY8910_DEFAULT_LOADS, DEVCB_NULL, DEVCB_NULL, DEVCB_NULL, DEVCB_NULL }, NULL }; const ym2203_interface *intf = device->baseconfig().static_config() ? (const ym2203_interface *)device->baseconfig().static_config() : &generic_2203; ym2203_state *info = get_safe_token(device); int rate = device->clock()/72; /* ??? */ info->intf = intf; info->device = device; info->psg = ay8910_start_ym(NULL, YM2203, device, device->clock(), &intf->ay8910_intf); assert_always(info->psg != NULL, "Error creating YM2203/AY8910 chip"); /* Timer Handler set */ info->timer[0] = timer_alloc(device->machine, timer_callback_2203_0, info); info->timer[1] = timer_alloc(device->machine, timer_callback_2203_1, info); /* stream system initialize */ info->stream = stream_create(device,0,1,rate,info,ym2203_stream_update); /* Initialize FM emurator */ info->chip = ym2203_init(info,device,device->clock(),rate,timer_handler,IRQHandler,&psgintf); assert_always(info->chip != NULL, "Error creating YM2203 chip"); state_save_register_postload(device->machine, ym2203_intf_postload, info); }
static MACHINE_START( ninjaw ) { ninjaw_state *state = (ninjaw_state *)machine->driver_data; memory_configure_bank(machine, "bank10", 0, 8, memory_region(machine, "audiocpu") + 0xc000, 0x4000); state->maincpu = machine->device("maincpu"); state->audiocpu = machine->device("audiocpu"); state->subcpu = machine->device("sub"); state->tc0140syt = machine->device("tc0140syt"); state->tc0100scn_1 = machine->device("tc0100scn_1"); state->tc0100scn_2 = machine->device("tc0100scn_2"); state->tc0100scn_3 = machine->device("tc0100scn_3"); state->lscreen = machine->device("lscreen"); state->mscreen = machine->device("mscreen"); state->rscreen = machine->device("rscreen"); state->_2610_1l = machine->device("2610.1.l"); state->_2610_1r = machine->device("2610.1.r"); state->_2610_2l = machine->device("2610.2.l"); state->_2610_2r = machine->device("2610.2.r"); state_save_register_global(machine, state->cpua_ctrl); state_save_register_global(machine, state->banknum); state_save_register_global_array(machine, state->pandata); state_save_register_postload(machine, ninjaw_postload, NULL); }
static void *ym2612_start(int sndindex, int clock, const void *config) { static const struct YM2612interface dummy = { 0 }; struct ym2612_info *info; int rate = clock/72; info = auto_malloc(sizeof(*info)); memset(info, 0, sizeof(*info)); info->intf = config ? config : &dummy; /* FM init */ /* Timer Handler set */ info->timer[0] = timer_alloc(timer_callback_2612_0, info); info->timer[1] = timer_alloc(timer_callback_2612_1, info); /* stream system initialize */ info->stream = stream_create(0,2,rate,info,ym2612_stream_update); /**** initialize YM2612 ****/ info->chip = YM2612Init(info,sndindex,clock,rate,timer_handler,IRQHandler); state_save_register_postload(Machine, ym2612_postload, info); if (info->chip) return info; /* error */ return NULL; }
void timer_init(running_machine *machine) { int i; /* we need to wait until the first call to timer_cyclestorun before using real CPU times */ global_basetime = attotime_zero; callback_timer = NULL; callback_timer_modified = FALSE; /* register with the save state system */ state_save_push_tag(0); state_save_register_item("timer", 0, global_basetime.seconds); state_save_register_item("timer", 0, global_basetime.attoseconds); state_save_register_postload(machine, timer_postload, NULL); state_save_pop_tag(); /* reset the timers */ memset(timers, 0, sizeof(timers)); /* initialize the lists */ timer_head = NULL; timer_free_head = &timers[0]; for (i = 0; i < MAX_TIMERS-1; i++) timers[i].next = &timers[i+1]; timers[MAX_TIMERS-1].next = NULL; timer_free_tail = &timers[MAX_TIMERS-1]; }
void timer_init(running_machine *machine) { timer_private *global; int i; /* allocate global data */ global = machine->timer_data = auto_alloc_clear(machine, timer_private); /* we need to wait until the first call to timer_cyclestorun before using real CPU times */ global->exec.basetime = attotime_zero; global->exec.nextfire = attotime_never; global->exec.curquantum = DEFAULT_MINIMUM_QUANTUM; global->callback_timer = NULL; global->callback_timer_modified = FALSE; /* register with the save state system */ state_save_register_item(machine, "timer", NULL, 0, global->exec.basetime.seconds); state_save_register_item(machine, "timer", NULL, 0, global->exec.basetime.attoseconds); state_save_register_postload(machine, timer_postload, NULL); /* initialize the lists */ global->activelist = NULL; global->freelist = &global->timers[0]; for (i = 0; i < MAX_TIMERS-1; i++) global->timers[i].next = &global->timers[i+1]; global->timers[MAX_TIMERS-1].next = NULL; global->freelist_tail = &global->timers[MAX_TIMERS-1]; /* reset the quanta */ global->quantum_list[0].requested = DEFAULT_MINIMUM_QUANTUM; global->quantum_list[0].actual = DEFAULT_MINIMUM_QUANTUM; global->quantum_list[0].expire = attotime_never; global->quantum_current = &global->quantum_list[0]; global->quantum_minimum = ATTOSECONDS_IN_NSEC(1) / 1000; }
sound_stream *stream_create(device_t *device, int inputs, int outputs, int sample_rate, void *param, stream_update_func callback) { running_machine *machine = device->machine; streams_private *strdata = machine->streams_data; int inputnum, outputnum; sound_stream *stream; char statetag[30]; /* allocate memory */ stream = auto_alloc_clear(device->machine, sound_stream); VPRINTF(("stream_create(%d, %d, %d) => %p\n", inputs, outputs, sample_rate, stream)); /* fill in the data */ stream->device = device; stream->index = strdata->stream_index++; stream->sample_rate = sample_rate; stream->inputs = inputs; stream->outputs = outputs; stream->callback = callback; stream->param = param; /* create a unique tag for saving */ sprintf(statetag, "%d", stream->index); state_save_register_item(machine, "stream", statetag, 0, stream->sample_rate); state_save_register_postload(machine, stream_postload, stream); /* allocate space for the inputs */ if (inputs > 0) { stream->input = auto_alloc_array_clear(device->machine, stream_input, inputs); stream->input_array = auto_alloc_array_clear(device->machine, stream_sample_t *, inputs); }
void demonwld_driver_savestate(running_machine *machine) { state_save_register_global(machine, demonwld_dsp_on); state_save_register_global(machine, dsp_addr_w); state_save_register_global(machine, main_ram_seg); state_save_register_global(machine, demonwld_dsp_BIO); state_save_register_global(machine, dsp_execute); state_save_register_postload(machine, demonwld_restore_dsp, NULL); }
static MACHINE_START( atetris ) { /* Allocate interrupt timer */ interrupt_timer = timer_alloc(machine, interrupt_gen, NULL); /* Set up save state */ state_save_register_global(machine, current_bank); state_save_register_global(machine, nvram_write_enable); state_save_register_postload(machine, atetris_postload, NULL); }
static MACHINE_START( ninjaw ) { cpua_ctrl = 0xff; banknum = -1; memset(ninjaw_pandata, 0, sizeof(ninjaw_pandata)); state_save_register_global(machine, cpua_ctrl); state_save_register_global(machine, banknum); state_save_register_postload(machine, ninjaw_postload, NULL); }
static void *ym2608_start(int sndindex, int clock, const void *config) { static const struct YM2608interface generic_2608 = { { AY8910_LEGACY_OUTPUT | AY8910_SINGLE_OUTPUT, AY8910_DEFAULT_LOADS, NULL, NULL, NULL, NULL }, NULL, 0, }; const struct YM2608interface *intf = config ? config : &generic_2608; int rate = clock/72; void *pcmbufa; int pcmsizea; struct ym2608_info *info; info = auto_malloc(sizeof(*info)); memset(info, 0, sizeof(*info)); info->intf = intf; /* FIXME: Force to use simgle output */ info->psg = ay8910_start_ym(SOUND_YM2608, sndindex, clock, &intf->ay8910_intf); if (!info->psg) return NULL; /* Timer Handler set */ info->timer[0] = timer_alloc(timer_callback_2608_0, info); info->timer[1] = timer_alloc(timer_callback_2608_1, info); /* stream system initialize */ info->stream = stream_create(0,2,rate,info,ym2608_stream_update); /* setup adpcm buffers */ pcmbufa = (void *)(memory_region(info->intf->pcmrom)); pcmsizea = memory_region_length(info->intf->pcmrom); /* initialize YM2608 */ info->chip = YM2608Init(info,sndindex,clock,rate, pcmbufa,pcmsizea, timer_handler,IRQHandler,&psgintf); state_save_register_postload(Machine, ym2608_postload, info); if (info->chip) return info; /* error */ return NULL; }
static DEVICE_START( ym2610 ) { static const ym2610_interface generic_2610 = { 0 }; static const ay8910_interface generic_ay8910 = { AY8910_LEGACY_OUTPUT | AY8910_SINGLE_OUTPUT, AY8910_DEFAULT_LOADS, DEVCB_NULL, DEVCB_NULL, DEVCB_NULL, DEVCB_NULL }; const ym2610_interface *intf = device->baseconfig().static_config() ? (const ym2610_interface *)device->baseconfig().static_config() : &generic_2610; int rate = device->clock()/72; void *pcmbufa,*pcmbufb; int pcmsizea,pcmsizeb; ym2610_state *info = get_safe_token(device); astring name; device_type type = device->type(); info->intf = intf; info->device = device; info->psg = ay8910_start_ym(NULL, device->type(), device, device->clock(), &generic_ay8910); assert_always(info->psg != NULL, "Error creating YM2610/AY8910 chip"); /* Timer Handler set */ info->timer[0] = timer_alloc(device->machine, timer_callback_0, info); info->timer[1] = timer_alloc(device->machine, timer_callback_1, info); /* stream system initialize */ info->stream = stream_create(device,0,2,rate,info,(type == SOUND_YM2610) ? ym2610_stream_update : ym2610b_stream_update); /* setup adpcm buffers */ pcmbufa = *device->region(); pcmsizea = device->region()->bytes(); name.printf("%s.deltat", device->tag()); pcmbufb = (void *)(memory_region(device->machine, name)); pcmsizeb = memory_region_length(device->machine, name); if (pcmbufb == NULL || pcmsizeb == 0) { pcmbufb = pcmbufa; pcmsizeb = pcmsizea; } /**** initialize YM2610 ****/ info->chip = ym2610_init(info,device,device->clock(),rate, pcmbufa,pcmsizea,pcmbufb,pcmsizeb, timer_handler,IRQHandler,&psgintf); assert_always(info->chip != NULL, "Error creating YM2610 chip"); state_save_register_postload(device->machine, ym2610_intf_postload, info); }
static DEVICE_START( nmk112 ) { nmk112_state *nmk112 = get_safe_token(device); const nmk112_interface *intf = get_interface(device); nmk112->rom0 = memory_region(device->machine, intf->rgn0); nmk112->size0 = memory_region_length(device->machine, intf->rgn0) - 0x40000; nmk112->rom1 = memory_region(device->machine, intf->rgn1); nmk112->size1 = memory_region_length(device->machine, intf->rgn1) - 0x40000; nmk112->page_mask = ~intf->disable_page_mask; state_save_register_device_item_array(device, 0, nmk112->current_bank); state_save_register_device_item_array(device, 0, nmk112->last_bank); state_save_register_postload(device->machine, nmk112_postload_bankswitch, nmk112); }
static DEVICE_START( ym2608 ) { static const ym2608_interface generic_2608 = { { AY8910_LEGACY_OUTPUT | AY8910_SINGLE_OUTPUT, AY8910_DEFAULT_LOADS, DEVCB_NULL, DEVCB_NULL, DEVCB_NULL, DEVCB_NULL }, NULL }; const ym2608_interface *intf = device->baseconfig().static_config() ? (const ym2608_interface *)device->baseconfig().static_config() : &generic_2608; int rate = device->clock()/72; void *pcmbufa; int pcmsizea; ym2608_state *info = get_safe_token(device); info->intf = intf; info->device = device; /* FIXME: Force to use simgle output */ info->psg = ay8910_start_ym(NULL, SOUND_YM2608, device, device->clock(), &intf->ay8910_intf); assert_always(info->psg != NULL, "Error creating YM2608/AY8910 chip"); /* Timer Handler set */ info->timer[0] = timer_alloc(device->machine, timer_callback_2608_0, info); info->timer[1] = timer_alloc(device->machine, timer_callback_2608_1, info); /* stream system initialize */ info->stream = stream_create(device,0,2,rate,info,ym2608_stream_update); /* setup adpcm buffers */ pcmbufa = *device->region(); pcmsizea = device->region()->bytes(); /* initialize YM2608 */ info->chip = ym2608_init(info,device,device->clock(),rate, pcmbufa,pcmsizea, timer_handler,IRQHandler,&psgintf); assert_always(info->chip != NULL, "Error creating YM2608 chip"); state_save_register_postload(device->machine, ym2608_intf_postload, info); }
void streams_init(running_machine *machine) { streams_private *strdata; /* allocate memory for our private data */ strdata = auto_alloc_clear(machine, streams_private); /* reset globals */ strdata->stream_tailptr = &strdata->stream_head; strdata->update_attoseconds = STREAMS_UPDATE_ATTOTIME.attoseconds; /* set the global pointer */ machine->streams_data = strdata; /* register global states */ state_save_register_global(machine, strdata->last_update.seconds); state_save_register_global(machine, strdata->last_update.attoseconds); state_save_register_postload(machine, stream_postload, strdata); }
static void *ym2203_start(int sndindex, int clock, const void *config) { static const struct YM2203interface generic_2203 = { { AY8910_LEGACY_OUTPUT, AY8910_DEFAULT_LOADS, NULL, NULL, NULL, NULL }, NULL }; const struct YM2203interface *intf = config ? config : &generic_2203; struct ym2203_info *info; int rate = clock/72; /* ??? */ info = auto_malloc(sizeof(*info)); memset(info, 0, sizeof(*info)); info->intf = intf; info->psg = ay8910_start_ym(SOUND_YM2203, sndindex, clock, &intf->ay8910_intf); if (!info->psg) return NULL; /* Timer Handler set */ info->timer[0] = timer_alloc(timer_callback_2203_0, info); info->timer[1] = timer_alloc(timer_callback_2203_1, info); /* stream system initialize */ info->stream = stream_create(0,1,rate,info,ym2203_stream_update); /* Initialize FM emurator */ info->chip = YM2203Init(info,sndindex,clock,rate,timer_handler,IRQHandler,&psgintf); state_save_register_postload(Machine, ym2203_postload, info); if (info->chip) return info; /* error */ /* stream close */ return NULL; }
static DEVICE_START( ym2151 ) { static const ym2151_interface dummy = { 0 }; ym2151_state *info = get_safe_token(device); int rate; info->intf = device->baseconfig().static_config ? (const ym2151_interface *)device->baseconfig().static_config : &dummy; rate = device->clock/64; /* stream setup */ info->stream = stream_create(device,0,2,rate,info,ym2151_update); info->chip = ym2151_init(device,device->clock,rate); assert_always(info->chip != NULL, "Error creating YM2151 chip"); state_save_register_postload(device->machine, ym2151intf_postload, info); ym2151_set_irq_handler(info->chip,info->intf->irqhandler); ym2151_set_port_write_handler(info->chip,info->intf->portwritehandler); }
/* device interface */ static DEVICE_START( tms9927 ) { tms9927_state *tms = get_safe_token(device); /* validate arguments */ assert(device != NULL); assert(device->tag != NULL); tms->intf = (const tms9927_interface *)device->static_config; if (tms->intf != NULL) { assert(device->clock > 0); assert(tms->intf->hpixels_per_column > 0); /* copy the initial parameters */ tms->clock = device->clock; tms->hpixels_per_column = tms->intf->hpixels_per_column; /* get the screen device */ tms->screen = devtag_get_device(device->machine, tms->intf->screen_tag); assert(tms->screen != NULL); /* get the self-load PROM */ if (tms->intf->selfload_region != NULL) { tms->selfload = memory_region(device->machine, tms->intf->selfload_region); assert(tms->selfload != NULL); } } /* register for state saving */ state_save_register_postload(device->machine, tms9927_state_save_postload, tms); state_save_register_device_item(device, 0, tms->clock); state_save_register_device_item_array(device, 0, tms->reg); state_save_register_device_item(device, 0, tms->start_datarow); state_save_register_device_item(device, 0, tms->reset); state_save_register_device_item(device, 0, tms->hpixels_per_column); }
static DEVICE_START( bsmt2000 ) { bsmt2000_chip *chip = get_safe_token(device); int voicenum; /* create a stream at a nominal sample rate (real one specified later) */ chip->stream = stream_create(device, 0, 2, device->clock() / 1000, chip, bsmt2000_update); chip->clock = device->clock(); /* initialize the regions */ chip->region_base = *device->region(); chip->total_banks = device->region()->bytes() / 0x10000; /* register chip-wide data for save states */ state_save_register_postload(device->machine, bsmt2000_postload, chip); state_save_register_device_item(device, 0, chip->last_register); state_save_register_device_item(device, 0, chip->mode); state_save_register_device_item(device, 0, chip->stereo); state_save_register_device_item(device, 0, chip->voices); state_save_register_device_item(device, 0, chip->adpcm); state_save_register_device_item(device, 0, chip->adpcm_current); state_save_register_device_item(device, 0, chip->adpcm_delta_n); /* register voice-specific data for save states */ for (voicenum = 0; voicenum < MAX_VOICES; voicenum++) { bsmt2000_voice *voice = &chip->voice[voicenum]; state_save_register_device_item(device, voicenum, voice->pos); state_save_register_device_item(device, voicenum, voice->rate); state_save_register_device_item(device, voicenum, voice->loopend); state_save_register_device_item(device, voicenum, voice->loopstart); state_save_register_device_item(device, voicenum, voice->bank); state_save_register_device_item(device, voicenum, voice->leftvol); state_save_register_device_item(device, voicenum, voice->rightvol); state_save_register_device_item(device, voicenum, voice->fraction); } }
static DEVICE_START( ym2612 ) { static const ym2612_interface dummy = { 0 }; ym2612_state *info = get_safe_token(device); int rate = device->clock()/72; info->intf = device->baseconfig().static_config() ? (const ym2612_interface *)device->baseconfig().static_config() : &dummy; info->device = device; /* FM init */ /* Timer Handler set */ info->timer[0] = timer_alloc(device->machine, timer_callback_2612_0, info); info->timer[1] = timer_alloc(device->machine, timer_callback_2612_1, info); /* stream system initialize */ info->stream = stream_create(device,0,2,rate,info,ym2612_stream_update); /**** initialize YM2612 ****/ info->chip = ym2612_init(info,device,device->clock(),rate,timer_handler,IRQHandler); assert_always(info->chip != NULL, "Error creating YM2612 chip"); state_save_register_postload(device->machine, ym2612_intf_postload, info); }
static MACHINE_START( warriorb ) { warriorb_state *state = machine->driver_data<warriorb_state>(); memory_configure_bank(machine, "bank10", 0, 8, machine->region("audiocpu")->base() + 0xc000, 0x4000); state->maincpu = machine->device("maincpu"); state->audiocpu = machine->device("audiocpu"); state->tc0140syt = machine->device("tc0140syt"); state->tc0100scn_1 = machine->device("tc0100scn_1"); state->tc0100scn_2 = machine->device("tc0100scn_2"); state->lscreen = machine->device("lscreen"); state->rscreen = machine->device("rscreen"); state->_2610_1l = machine->device("2610.1.l"); state->_2610_1r = machine->device("2610.1.r"); state->_2610_2l = machine->device("2610.2.l"); state->_2610_2r = machine->device("2610.2.r"); state_save_register_global(machine, state->banknum); state_save_register_global_array(machine, state->pandata); state_save_register_postload(machine, warriorb_postload, NULL); }
static void gtia_state(running_machine *machine) { state_save_register_global(gtia.r.m0pf); state_save_register_global(gtia.r.m1pf); state_save_register_global(gtia.r.m2pf); state_save_register_global(gtia.r.m3pf); state_save_register_global(gtia.r.p0pf); state_save_register_global(gtia.r.p1pf); state_save_register_global(gtia.r.p2pf); state_save_register_global(gtia.r.p3pf); state_save_register_global(gtia.r.m0pl); state_save_register_global(gtia.r.m1pl); state_save_register_global(gtia.r.m2pl); state_save_register_global(gtia.r.m3pl); state_save_register_global(gtia.r.p0pl); state_save_register_global(gtia.r.p1pl); state_save_register_global(gtia.r.p2pl); state_save_register_global(gtia.r.p3pl); state_save_register_global_array(gtia.r.but); state_save_register_global(gtia.r.pal); state_save_register_global(gtia.r.gtia15); state_save_register_global(gtia.r.gtia16); state_save_register_global(gtia.r.gtia17); state_save_register_global(gtia.r.gtia18); state_save_register_global(gtia.r.gtia19); state_save_register_global(gtia.r.gtia1a); state_save_register_global(gtia.r.gtia1b); state_save_register_global(gtia.r.gtia1c); state_save_register_global(gtia.r.gtia1d); state_save_register_global(gtia.r.gtia1e); state_save_register_global(gtia.r.cons); state_save_register_global(gtia.w.hposp0); state_save_register_global(gtia.w.hposp1); state_save_register_global(gtia.w.hposp2); state_save_register_global(gtia.w.hposp3); state_save_register_global(gtia.w.hposm0); state_save_register_global(gtia.w.hposm1); state_save_register_global(gtia.w.hposm2); state_save_register_global(gtia.w.hposm3); state_save_register_global(gtia.w.sizep0); state_save_register_global(gtia.w.sizep1); state_save_register_global(gtia.w.sizep2); state_save_register_global(gtia.w.sizep3); state_save_register_global(gtia.w.sizem); state_save_register_global_array(gtia.w.grafp0); state_save_register_global_array(gtia.w.grafp1); state_save_register_global_array(gtia.w.grafp2); state_save_register_global_array(gtia.w.grafp3); state_save_register_global_array(gtia.w.grafm); state_save_register_global(gtia.w.colpm0); state_save_register_global(gtia.w.colpm1); state_save_register_global(gtia.w.colpm2); state_save_register_global(gtia.w.colpm3); state_save_register_global(gtia.w.colpf0); state_save_register_global(gtia.w.colpf1); state_save_register_global(gtia.w.colpf2); state_save_register_global(gtia.w.colpf3); state_save_register_global(gtia.w.colbk); state_save_register_global(gtia.w.prior); state_save_register_global(gtia.w.vdelay); state_save_register_global(gtia.w.gractl); state_save_register_global(gtia.w.hitclr); state_save_register_global(gtia.w.cons); state_save_register_postload(machine, gtia_state_postload, NULL); }
void palette_init(running_machine *machine) { int format; palette_private *palette = auto_malloc(sizeof(*palette)); const device_config *device = video_screen_first(machine->config); /* get the format from the first screen, or use BITMAP_FORMAT_INVALID, if screenless */ if (device != NULL) { screen_config *config = device->inline_config; format = config->format; } else format = BITMAP_FORMAT_INVALID; /* request cleanup */ machine->palette_data = palette; add_exit_callback(machine, palette_exit); /* reset all our data */ memset(palette, 0, sizeof(*palette)); palette->format = format; /* determine the color mode */ switch (format) { case BITMAP_FORMAT_INDEXED16: case BITMAP_FORMAT_RGB15: case BITMAP_FORMAT_RGB32: /* indexed and RGB modes are fine for everything */ break; case BITMAP_FORMAT_INVALID: /* invalid format means no palette - or at least it should */ assert(machine->config->total_colors == 0); return; default: fatalerror("Unsupported screen bitmap format!"); break; } /* allocate all the data structures */ if (machine->config->total_colors > 0) { int numcolors; allocate_palette(machine, palette); allocate_color_tables(machine, palette); allocate_shadow_tables(machine, palette); /* set up save/restore of the palette */ numcolors = palette_get_num_colors(machine->palette); palette->save_pen = auto_malloc(sizeof(*palette->save_pen) * numcolors); palette->save_bright = auto_malloc(sizeof(*palette->save_bright) * numcolors); state_save_register_global_pointer(palette->save_pen, numcolors); state_save_register_global_pointer(palette->save_bright, numcolors); state_save_register_presave(machine, palette_presave, palette); state_save_register_postload(machine, palette_postload, palette); } }
static MACHINE_START( wgp ) { state_save_register_global(cpua_ctrl); state_save_register_global(banknum); state_save_register_postload(machine, wgp_postload, NULL); }