bool CConfigList::Load (void) { DIR *dptr; struct dirent *fptr; dptr = opendir(m_directory); if (dptr == NULL) { error_message("Can't open directory %s", m_directory); return false; } while ((fptr = readdir(dptr)) != NULL) { char fname[PATH_MAX]; sprintf(fname, "%s/%s", m_directory, fptr->d_name); struct stat buf; if (stat(fname, &buf) >= 0 && S_ISREG(buf.st_mode)) { debug_message("trying %s", fname); m_config_list = CreateConfigInt(fname, m_config_list); m_config_list->Initialize(); if (m_config_list->IsValid()) { m_config_count++; debug_message("loaded %s config %s", m_config_type, m_config_list->GetName()); m_config_list->Update(); } } } closedir(dptr); return true; }
// Audio encoding main process int CAudioEncoder::ThreadMain(void) { CMsg* pMsg; bool stop = false; debug_message("audio encoder thread %s %s %s start", Profile()->GetName(), Profile()->GetStringValue(CFG_AUDIO_ENCODER), Profile()->GetStringValue(CFG_AUDIO_ENCODING)); while (stop == false && SDL_SemWait(m_myMsgQueueSemaphore) == 0) { pMsg = m_myMsgQueue.get_message(); if (pMsg != NULL) { switch (pMsg->get_value()) { case MSG_NODE_STOP_THREAD: DoStopAudio(); stop = true; break; case MSG_NODE_START: // DoStartTransmit(); Anything ? break; case MSG_NODE_STOP: DoStopAudio(); break; case MSG_SINK_FRAME: { uint32_t dontcare; CMediaFrame *mf = (CMediaFrame*)pMsg->get_message(dontcare); if (m_stop_thread == false) ProcessAudioFrame(mf); if (mf->RemoveReference()) { delete mf; } break; } } delete pMsg; } } while ((pMsg = m_myMsgQueue.get_message()) != NULL) { if (pMsg->get_value() == MSG_SINK_FRAME) { uint32_t dontcare; CMediaFrame *mf = (CMediaFrame*)pMsg->get_message(dontcare); if (mf->RemoveReference()) { delete mf; } } delete pMsg; } if (m_audioResample != NULL) { for (uint ix = 0; ix < m_audioDstChannels; ix++) { st_resample_stop(m_audioResample[ix]); m_audioResample[ix] = NULL; } free(m_audioResample); } CHECK_AND_FREE(m_audioPreEncodingBuffer); debug_message("audio encoder thread %s exit", Profile()->GetName()); return 0; }
static void msvcrt_delete(void *p) { debug_message("delete(%p) called: ", p); w32api_mem_free(p); debug_message("deleted.\n"); }
static void restore_stat_list (const char * file, mudlib_stats_t ** list) { FILE *f; char fname_buf[MAXPATHLEN]; char *fname = fname_buf; mudlib_stats_t *entry; if (file) { if (strchr(file, '/')) { if (file[0] == '/') file++; f = fopen(file, "r"); } else { sprintf(fname, "%s/%s", LOG_DIR, file); if (fname[0] == '/') fname++; f = fopen(fname, "r"); } } else { debug_message("*Warning: call to save_stat_list with null filename\n"); return; } if (!f) { debug_message("*Warning: unable to open stat file %s for reading.\n", file); return; } while (fscanf(f, "%s", fname) != EOF) { entry = add_stat_entry(fname, list); fscanf(f, "%d %d\n", &entry->moves, &entry->heart_beats); } fclose(f); }
static void save_stat_list (const char * file, mudlib_stats_t * list) { FILE *f; char fname_buf[MAXPATHLEN]; char *fname = fname_buf; if (file) { if (strchr(file, '/')) { if (file[0] == '/') file++; f = fopen(file, "w"); } else { sprintf(fname, "%s/%s", LOG_DIR, file); if (fname[0] == '/') fname++; f = fopen(fname, "w"); } } else { debug_message("*Warning: call to save_stat_list with null filename\n"); return; } if (!f) { debug_message("*Error: unable to open stat file %s for writing.\n", file); return; } while (list) { fprintf(f, "%s %d %d\n", list->name, list->moves, list->heart_beats); list = list->next; } fclose(f); }
static bool ReadNextLine (text_file_data_t *tptr) { off_t start; start = ftello(tptr->m_file); if (fgets(tptr->m_buffer, PATH_MAX, tptr->m_file) == NULL) { tptr->m_max_index = tptr->m_index; return false; } char *end = tptr->m_buffer + strlen(tptr->m_buffer) - 1; while (isspace(*end) && end > tptr->m_buffer) { *end = '\0'; end--; } debug_message("Read line %u %s", tptr->m_index, tptr->m_buffer); if (tptr->m_line_offset_tail == NULL || tptr->m_line_offset_tail->index < tptr->m_index) { text_line_offset_t *tlptr = MALLOC_STRUCTURE(text_line_offset_t); tlptr->next_line = NULL; tlptr->index = tptr->m_index; tlptr->offset = start; if (tptr->m_line_offset_head == NULL) { tptr->m_line_offset_head = tptr->m_line_offset_tail = tlptr; } else { tptr->m_line_offset_tail->next_line = tlptr; tptr->m_line_offset_tail = tlptr; } debug_message("Add to end"); } tptr->m_index++; return true; }
void InstallSignalHandler (const char *sig, void (*sighandler)(int), bool setsigint) { struct sigaction act; bool sigintset = false; act.sa_handler = sighandler; sigemptyset(&act.sa_mask); act.sa_flags = 0; int maxsigs = sizeof(sig_str_to_value) / sizeof(sig_str_to_value[0]); if (sig != NULL && *sig != '\0') { debug_message("sigals are %s", sig); for (int ix = 0; ix < maxsigs; ix++) { if (strcasestr(sig, sig_str_to_value[ix].str) != NULL) { debug_message("installing sig %s", sig_str_to_value[ix].str); sigaction(sig_str_to_value[ix].value, &act, 0); if (sig_str_to_value[ix].value == SIGINT) { sigintset = true; } } } } if (setsigint && sigintset == false) { sigaction(SIGINT, &act, 0); } }
static int write_device(AudioDevice *ad, unsigned char *data, int size) { ALSA_data *alsa = (ALSA_data *)ad->private_data; snd_pcm_sframes_t r; ssize_t unit = snd_pcm_samples_to_bytes(alsa->fd, 1) * ad->channels; snd_pcm_uframes_t count = size / unit; while (count > 0) { if ((r = snd_pcm_writei(alsa->fd, data, count)) == -EAGAIN) { //debug_message_fnc(" EAGAIN\n"); snd_pcm_wait(alsa->fd, 1000); } else if (r > 0) { //debug_message_fnc(" wrote %d bytes\n", (int)(r * unit)); ad->bytes_written += r * unit; count -= r; data += r * unit; } else if (r == -EPIPE) { debug_message_fnc("EPIPE: "); if (snd_pcm_state(alsa->fd) == SND_PCM_STATE_XRUN) { if ((r = snd_pcm_prepare(alsa->fd)) < 0) { debug_message("failed\n"); warning_fnc("snd_pcm_prepare() failed."); } else { debug_message("OK\n"); } } } else { warning_fnc(" r = %d < 0...\n", (int)r); } } return 1; }
static void GoToLine (text_file_data_t *tptr, uint index) { uint ix; debug_message("go to line %u", index); if (tptr->m_line_offset_tail != NULL) { debug_message("tail index %u", index); } if (tptr->m_line_offset_tail != NULL && tptr->m_line_offset_tail->index >= index) { debug_message("Looking for tail"); text_line_offset_t *tlptr; for (ix = 0, tlptr = tptr->m_line_offset_head; ix < index; ix++) { tlptr = tlptr->next_line; } if (tlptr->index != index) { error_message("Seek not right %u %u", tlptr->index, index); } GoToLine(tptr, tlptr); return; } uint start_index = 0; if (tptr->m_line_offset_tail) { start_index = tptr->m_line_offset_tail->index; GoToLine(tptr, tptr->m_line_offset_tail); } for (ix = start_index; ix < index; ix++) { if (ReadNextLine(tptr) == false) return; } }
bool CMediaSource::AddSink(CMediaSink* pSink) { bool rc = false; int i; if (SDL_LockMutex(m_pSinksMutex) == -1) { debug_message("AddSink LockMutex error"); return rc; } for (i = 0; i < MAX_SINKS; i++) { if (m_sinks[i] == pSink) { SDL_UnlockMutex(m_pSinksMutex); return true; } } for (i = 0; i < MAX_SINKS; i++) { if (m_sinks[i] == NULL) { m_sinks[i] = pSink; rc = true; break; } } if (SDL_UnlockMutex(m_pSinksMutex) == -1) { debug_message("UnlockMutex error"); } return rc; }
void free_vector(struct vector *p) { int i; if (!p->ref || --p->ref > 0) return; #if 0 if (p->ref < 0) { debug_message("Array reference count < 0 in free_vector.\n"); return; } #endif #if defined(DEBUG) if (p == &null_vector) { p->ref = 1; debug_message("Tried to free the zero-size shared vector.\n"); return; } #endif for (i = 0; i < p->size; i++) free_svalue(&p->item[i]); num_arrays--; total_array_size -= sizeof (struct vector) + sizeof (struct svalue) * (p->size-1); free((char *)p); }
bool Player::load(void) { ALLEGRO_STATE state; al_store_state(&state, ALLEGRO_STATE_TARGET_BITMAP | ALLEGRO_STATE_BLENDER); bitmap = al_load_bitmap(getResource("gfx/ship.tga")); if (!bitmap) { debug_message("Error loading %s\n", getResource("gfx/ship.tga")); return false; } trans_bitmap = al_create_bitmap(al_get_bitmap_width(bitmap), al_get_bitmap_height(bitmap)); if (!trans_bitmap) { debug_message("Error loading %s\n", getResource("gfx/ship_trans.tga")); al_destroy_bitmap(bitmap); return false; } /* Make a translucent copy of the ship */ al_set_target_bitmap(trans_bitmap); al_set_blender(ALLEGRO_ADD, ALLEGRO_ONE, ALLEGRO_ZERO); al_draw_tinted_bitmap(bitmap, al_map_rgba(255, 255, 255, 160), 0, 0, 0); al_restore_state(&state); trail_bitmap = al_load_bitmap(getResource("gfx/trail.tga")); if (!trail_bitmap) { debug_message("Error loading %s\n", getResource("gfx/trail.tga")); al_destroy_bitmap(bitmap); al_destroy_bitmap(trans_bitmap); return false; } icon = al_load_bitmap(getResource("gfx/ship_icon.tga")); if (!icon) { debug_message("Error loading %s\n", getResource("gfx/icon.tga")); al_destroy_bitmap(bitmap); al_destroy_bitmap(trans_bitmap); al_destroy_bitmap(trail_bitmap); return false; } highscoreBitmap = al_create_bitmap(300, 200); al_set_target_bitmap(highscoreBitmap); al_clear_to_color(al_map_rgba(0, 0, 0, 0)); al_restore_state(&state); draw_radius = al_get_bitmap_width(bitmap)/2; radius = draw_radius / 2; newGame(); reset(); return true; }
void string_list(void) { debug_message( "-------------------- String Table ------------------------\n"); table_walk_items(gdata->string_table, &list_item, NULL); debug_message( "----------------------------------------------------------\n"); }
void loader_list(void) { debug_message( "--------------------- Loader Table ------------------------\n"); table_walk_items(gdata->loader_table, &list_item, NULL); debug_message( "----------------------------------------------------------\n"); }
void object_list(void) { debug_message( "--------------------- Object Table ------------------------\n"); table_walk_items(gdata->object_table, &list_item, NULL); debug_message( "----------------------------------------------------------\n"); }
void site_list(void) { debug_message( "--------------------- Site Table ------------------------\n"); table_walk_items(gdata->site_table, &list_item, NULL); debug_message( "----------------------------------------------------------\n"); }
void frame_list(void) { debug_message( "--------------------- Frame Table ------------------------\n"); table_walk_items(gdata->frame_table, &list_item, NULL); debug_message( "----------------------------------------------------------\n"); }
int CALSAAudioSource::ThreadMain(void) { debug_message("alsa start"); while (true) { int rc; if (m_source) { rc = SDL_SemTryWait(m_myMsgQueueSemaphore); } else { rc = SDL_SemWait(m_myMsgQueueSemaphore); } // semaphore error if (rc == -1) { break; } // message pending if (rc == 0) { CMsg* pMsg = m_myMsgQueue.get_message(); if (pMsg != NULL) { switch (pMsg->get_value()) { case MSG_NODE_STOP_THREAD: DoStopCapture(); // ensure things get cleaned up delete pMsg; debug_message("alsa stop thread"); return 0; case MSG_NODE_START: DoStartCapture(); break; case MSG_NODE_STOP: DoStopCapture(); break; } delete pMsg; } } if (m_source) { try { //debug_message("processaudio"); ProcessAudio(); } catch (...) { error_message("alsa stop capture"); DoStopCapture(); break; } } } debug_message("alsa thread exit"); return -1; }
/* 将ob设置为master对象 */ void set_master(object_t * ob) { #if defined(PACKAGE_UIDS) || defined(PACKAGE_MUDLIB_STATS) int first_load = (!master_ob); #endif #ifdef PACKAGE_UIDS svalue_t *ret; #endif get_master_applies(ob); /* master load好之后,要apply一下? */ master_ob = ob; /* Make sure master_ob is never made a dangling pointer. */ add_ref(master_ob, "set_master"); #ifndef PACKAGE_UIDS # ifdef PACKAGE_MUDLIB_STATS if (first_load) { set_backbone_domain("BACKBONE"); set_master_author("NONAME"); } # endif #else ret = apply_master_ob(APPLY_GET_ROOT_UID, 0); /* can't be -1 or we wouldn't be here */ if (!ret) { debug_message("No function %s() in master object; possibly the mudlib doesn't want PACKAGE_UIDS to be defined.\n", applies_table[APPLY_GET_ROOT_UID]); exit(-1); } if (ret->type != T_STRING) { debug_message("%s() in master object does not work.\n", applies_table[APPLY_GET_ROOT_UID]); exit(-1); } if (first_load) { /* 第一次load master? */ master_ob->uid = set_root_uid(ret->u.string); master_ob->euid = master_ob->uid; # ifdef PACKAGE_MUDLIB_STATS set_master_author(ret->u.string); # endif ret = apply_master_ob(APPLY_GET_BACKBONE_UID, 0); if (ret == 0 || ret->type != T_STRING) { debug_message("%s() in the master file does not work\n", applies_table[APPLY_GET_BACKBONE_UID]); /* apply有多个,装table */ exit(-1); } set_backbone_uid(ret->u.string); # ifdef PACKAGE_MUDLIB_STATS set_backbone_domain(ret->u.string); # endif } else { master_ob->uid = add_uid(ret->u.string); master_ob->euid = master_ob->uid; } #endif }
void myread(int file, char *cmd, char *buffer) { debug_message("READ1\n"); int len; mywrite(file, cmd); len = read(file, buffer, BUFFER_SIZE); if (len >= 0) buffer[len] = 0; else buffer[0] = 0; debug_message("BUFFER: %s\n", buffer); debug_message("READ2\n"); }
// ValidateAddressAndPort does a number of things - verifies that the // address and port are in a valid range, set all streams with similiar // profiles to that address, and makes sure there are no duplicate addresses void ValidateIpAddressAndPort (CMediaStreamList *stream_list, CMediaStream *s, config_index_t profile_ix, config_index_t fixed_ix, config_index_t addr_ix, config_index_t port_ix) { bool corrected; debug_message("Checking %s %s %s %s:%u", s->GetName(), s->GetNameFromIndex(profile_ix), s->GetStringValue(profile_ix), s->GetStringValue(addr_ix), s->GetIntegerValue(port_ix)); do { if (ValidateIpAddress(s->GetStringValue(addr_ix)) == false) { struct in_addr in; debug_message("Stream %s %s address was invalid \"%s\"", s->GetName(), s->GetNameFromIndex(profile_ix), s->GetStringValue(addr_ix)); in.s_addr = GetRandomMcastAddress(); s->SetStringValue(addr_ix, inet_ntoa(in)); debug_message("changed to \"%s\"", s->GetStringValue(addr_ix)); } if (s->GetIntegerValue(port_ix) >= 0xffff || ValidateIpPort(s->GetIntegerValue(port_ix)) == false) { debug_message("Stream %s %s address was invalid %u", s->GetName(), s->GetNameFromIndex(profile_ix), s->GetIntegerValue(port_ix)); s->SetIntegerValue(port_ix, GetRandomPort()); debug_message("Changed to %u", s->GetIntegerValue(port_ix)); } if (s->GetBoolValue(fixed_ix) == false) { SetRestOfProfile(s, profile_ix, fixed_ix, addr_ix, port_ix); } corrected = CheckAddressForDup(stream_list, s, profile_ix, addr_ix, port_ix); if (corrected == true) { // keep address, move port - by setting port to 0, we will trigger // the above s->SetIntegerValue(port_ix, 0); } } while (corrected); }
void render_printmatrix(matrix* mat) // FLAG use this? erase? { debug_message("Matrix:\n"); int i,j; for(i=0;i<4;i++) { for(j=0;j<4;j++) { debug_message(" %2.3f",mat->cell[i+4*j]); } debug_message("\n"); } }
void f_replace_program P2(int, num_arg, int, instruction) { replace_ob_t *tmp; int name_len; char *name, *xname; program_t *new_prog; int var_offset; if (sp->type != T_STRING) bad_arg(1, instruction); #ifdef DEBUG if (d_flag) debug_message("replace_program called\n"); #endif if (!current_object) error("replace_program called with no current object\n"); if (current_object == simul_efun_ob) error("replace_program on simul_efun object\n"); if (current_object->prog->func_ref) error("cannot replace a program with function references.\n"); name_len = strlen(sp->u.string); name = (char *) DMALLOC(name_len + 3, TAG_TEMPORARY, "replace_program"); xname = name; strcpy(name, sp->u.string); if (name[name_len - 2] != '.' || name[name_len - 1] != 'c') strcat(name, ".c"); if (*name == '/') name++; new_prog = search_inherited(name, current_object->prog, &var_offset); FREE(xname); if (!new_prog) { error("program to replace the current with has to be inherited\n"); } if (!(tmp = retrieve_replace_program_entry())) { tmp = ALLOCATE(replace_ob_t, TAG_TEMPORARY, "replace_program"); tmp->ob = current_object; tmp->next = obj_list_replace; obj_list_replace = tmp; } tmp->new_prog = new_prog; tmp->var_offset = var_offset; #ifdef DEBUG if (d_flag) debug_message("replace_program finished\n"); #endif free_string_svalue(sp--); }
bool EncodeFrame (const char *fptr) { ADV_SPACE(fptr); CHECK_AND_FREE(m_encodedFrame); if (*fptr == 'A' || *fptr == '<') { // we have an already formatted href const char *check = fptr + 1; if (*check == '<') { check++; } if (strncmp(check, m_base_url, m_base_url_len) == 0) { check += m_base_url_len; m_encodedFrame = (char *)malloc(strlen(check) + *fptr == 'A' ? 2 : 1); char *copyto = m_encodedFrame; if (*fptr == 'A') { *copyto++ = 'A'; } *copyto++ = '<'; strcpy(copyto, check); debug_message("%s", m_encodedFrame); } else { m_encodedFrame = strdup(fptr); } chomp(); } else { // we need to add <> and maybe an A uint32_t size = strlen(fptr) + 1; // add \0 at end if (strncmp(fptr, m_base_url, m_base_url_len) == 0) { fptr += m_base_url_len; } debug_message("string \"%s\"", fptr); size += 2; // add <> if (Profile()->GetBoolValue(CFG_TEXT_HREF_MAKE_AUTOMATIC)) size++; m_encodedFrame = (char *)malloc(size); char *write = m_encodedFrame; if (Profile()->GetBoolValue(CFG_TEXT_HREF_MAKE_AUTOMATIC)) { *write++ = 'A'; } *write++ = '<'; *write = '\0'; strcat(write, fptr); debug_message("before chomp \"%s\"", m_encodedFrame); chomp(); strcat(write, ">"); debug_message("\"%s\"", m_encodedFrame); } m_encodedFrameLen = strlen(m_encodedFrame) + 1; return true; };
bool SampleResource::load(void) { if (!al_is_audio_installed()) { debug_message("Skipped loading sample %s\n", filename.c_str()); return true; } sample_data = al_load_sample(filename.c_str()); if (!sample_data) { debug_message("Error loading sample %s\n", filename.c_str()); return false; } return true; }
bool CALSAAudioCapabilities::ProbeDevice() { if (allSampleRateTableSize > NUM_ELEMENTS_IN_ARRAY(m_samplingRates)) { error_message("Number of sample rates exceeds audio cap array"); return false; } // Open PCM snd_pcm_t *pcm_handle; snd_pcm_stream_t stream = SND_PCM_STREAM_CAPTURE; snd_pcm_hw_params_t *hwparams; snd_pcm_hw_params_alloca(&hwparams); int err; if ((err= snd_pcm_open(&pcm_handle, m_deviceName, stream, SND_PCM_NONBLOCK)) < 0) { error_message("Failed to open %s: %s", m_deviceName, snd_strerror(err)); return false; } m_canOpen = true; if ((err = snd_pcm_hw_params_any(pcm_handle, hwparams)) < 0) { error_message("Broken configuration for playback: no configurations available: %s\n", snd_strerror(err)); return false; } // union of valid sampling rates for MP3 and AAC // for all possible sampling rates u_int8_t i; for (i = 0; i < allSampleRateTableSize; i++) { u_int32_t targetRate = allSampleRateTable[i]; if (snd_pcm_hw_params_test_rate(pcm_handle, hwparams, targetRate, 0) != 0) { debug_message("audio device %s doesn't support sampling rate %u", m_deviceName, targetRate); continue; } debug_message("sampling rate %u supported", targetRate); // valid sampling rate m_samplingRates[m_numSamplingRates++] = targetRate; } // zero out remaining sampling rate entries for (i = m_numSamplingRates; i < allSampleRateTableSize; i++) { m_samplingRates[i] = 0; } snd_pcm_close(pcm_handle); return true; }
/* * push_file () pushes an input file on the input stack, saving the * current file name and line number. If next is non-NULL, this push * invalidates a call to push_string_init (), whose storage are * consequentely released. */ void push_file (FILE *fp, const char *title) { input_block *i; if (next != NULL) { obstack_free (current_input, next); next = NULL; } if (debug_level & DEBUG_TRACE_INPUT) debug_message ("input read from %s", title); i = (input_block *) obstack_alloc (current_input, sizeof (struct input_block)); i->type = INPUT_FILE; i->u.u_f.name = current_file; i->u.u_f.lineno = current_line; i->u.u_f.out_lineno = output_current_line; i->u.u_f.advance_line = start_of_input_line; current_file = obstack_copy0 (current_input, title, strlen (title)); current_line = 1; output_current_line = -1; i->u.u_f.file = fp; i->prev = isp; isp = i; }
static void GB2Big(char *istr, char *ostr, int inlen) { unsigned char s[2]; #ifdef DEBUG debug_message("translate GB to BIG5.\n"); #endif while(inlen >= 2) { s[0] = *istr++; s[1] = *istr++; if(is_GB1(s[0]) && is_GB2(s[1])) { g2b(s); *ostr++ = s[0]; *ostr++ = s[1]; inlen -= 2; } else { *ostr++ = s[0]; istr--; inlen--; } } if(inlen > 0) *ostr++ = *istr; *ostr = '\0'; }
static void Big2GB(char *istr, char *ostr, int inlen) { unsigned char s[2]; #ifdef DEBUG debug_message("translate BIG5 to GB.\n"); #endif while(inlen >= 2) { s[0] = *istr++; s[1] = *istr++; if(is_B51(s[0]) && is_B52(s[1])) { b2g(s); *ostr++ = s[0]; *ostr++ = s[1]; inlen -= 2; } else { *ostr++ = s[0]; istr--; inlen--; } } if(inlen > 0) *ostr++ = *istr; *ostr = '\0'; }
/* * The function pop_input () pops one level of input sources. If the * popped input_block is a file, current_file and current_line are reset * to the saved values before the memory for the input_block are * released. */ static void pop_input (void) { input_block *tmp = isp->prev; switch (isp->type) { case INPUT_STRING: case INPUT_MACRO: break; case INPUT_FILE: if (debug_level & DEBUG_TRACE_INPUT) debug_message ("input reverted to %s, line %d", isp->u.u_f.name, isp->u.u_f.lineno); fclose (isp->u.u_f.file); current_file = isp->u.u_f.name; current_line = isp->u.u_f.lineno; output_current_line = isp->u.u_f.out_lineno; start_of_input_line = isp->u.u_f.advance_line; if (tmp != NULL) output_current_line = -1; break; default: internal_error ("Input stack botch in pop_input ()"); break; } obstack_free (current_input, isp); next = NULL; /* might be set in push_string_init () */ isp = tmp; }