示例#1
0
// uninit driver
static void uninit(sh_video_t *sh)
{
    vd_xanim_ctx *priv = sh->context;
    int i;
    void (*close_func)(void);

    for (i=0; i < XA_CLOSE_FUNCS; i++)
	if (xa_close_func[i])
	{
	    close_func = xa_close_func[i];
	    close_func();
	}
    dlclose(priv->file_handler);
    free(priv->decinfo);
    free(priv);
}
示例#2
0
Proto *luaY_parser (lua_State *L, ZIO *z, Mbuffer *buff, const char *name) {
  struct LexState lexstate;
  struct FuncState funcstate;
  lexstate.buff = buff;
  luaX_setinput(L, &lexstate, z, luaS_new(L, name));
  open_func(&lexstate, &funcstate);
  funcstate.f->is_vararg = VARARG_ISVARARG;  /* main func. is always vararg */
  luaX_next(&lexstate);  /* read first token */
  chunk(&lexstate);
  check(&lexstate, TK_EOS);
  close_func(&lexstate);
  lua_assert(funcstate.prev == NULL);
  lua_assert(funcstate.f->nups == 0);
  lua_assert(lexstate.fs == NULL);
  return funcstate.f;
}
示例#3
0
Proto *luaY_parser (lua_State *L, ZIO *z, Mbuffer *buff) {
  struct LexState lexstate;
  struct FuncState funcstate;
  lexstate.buff = buff;
  lexstate.nestlevel = 0;
  luaX_setinput(L, &lexstate, z, luaS_new(L, zname(z)));
  open_func(&lexstate, &funcstate);
  next(&lexstate);  /* read first token */
  chunk(&lexstate);
  check_condition(&lexstate, (lexstate.t.token == TK_EOS), "<eof> expected");
  close_func(&lexstate);
  lua_assert(funcstate.prev == NULL);
  lua_assert(funcstate.f->nups == 0);
  lua_assert(lexstate.nestlevel == 0);
  return funcstate.f;
}
示例#4
0
static struct rldb_plugin_cnts *
open_func(
        struct rldb_plugin_data *data,
        struct runlog_state *rl_state,
        const struct ejudge_cfg *config,
        const struct contest_desc *cnts,
        const struct section_global_data *global,
        int flags,
        time_t init_duration,
        time_t init_sched_time,
        time_t init_finish_time)
{
  struct rldb_file_state *state = (struct rldb_file_state*) data;
  struct rldb_file_cnts *cs = 0;
  path_t runlog_path;

  ASSERT(state);
  XCALLOC(cs, 1);
  cs->plugin_state = state;
  state->nref++;
  cs->rl_state = rl_state;
  cs->run_fd = -1;

  runlog_path[0] = 0;
  if (global && global->run_log_file[0]) {
    snprintf(runlog_path, sizeof(runlog_path), "%s", global->run_log_file);
  }
  if (!runlog_path[0] && cnts && cnts->root_dir) {
    snprintf(runlog_path, sizeof(runlog_path), "%s/var/run.log",
             cnts->root_dir);
  }
  if (!runlog_path[0]) {
    err("`run_log_file' is undefined");
    goto fail;
  }
  cs->runlog_path = xstrdup(runlog_path);

  if (do_run_open(cs, runlog_path, flags, init_duration,
                  init_sched_time, init_finish_time) < 0)
    goto fail;

  return (struct rldb_plugin_cnts*) cs;

 fail:
  close_func((struct rldb_plugin_cnts*) cs);
  return 0;
}
示例#5
0
文件: lparser.c 项目: arsaccol/SLED
static void body (LexState *ls, expdesc *e, int needself, int line) {
  /* body ->  `(' parlist `)' chunk END */  

#ifdef LUA_UTILITIES_NET
  char szFuncName1[256];
  char szFuncName2[256];
#endif

  FuncState new_fs;
  open_func(ls, &new_fs);
  new_fs.f->linedefined = line;

#ifdef LUA_UTILITIES_NET
  szFuncName1[0] = 0;
  szFuncName2[0] = 0;
  TryGetFunctionName(ls->t.seminfo.ts, szFuncName1, 256);
#endif

  checknext(ls, '(');
  if (needself) {
    new_localvarliteral(ls, "self", 0);
    adjustlocalvars(ls, 1);
  }
  parlist(ls);
  checknext(ls, ')');
  chunk(ls);    
  
#ifdef LUA_UTILITIES_NET
  if (szFuncName1[0] == 0)
	TryGetFunctionName(ls->t.seminfo.ts, szFuncName2, 256);
#endif
  
  new_fs.f->lastlinedefined = ls->linenumber;
  check_match(ls, TK_END, TK_FUNCTION, line);
  close_func(ls);

#ifdef LUA_UTILITIES_NET
  // Use the correct function name based on values obtained
  if (szFuncName1[0] == 0)
	  GetFunction(szFuncName2, ls, new_fs.f);
  else
	  GetFunction(szFuncName1, ls, new_fs.f);
#endif

  pushclosure(ls, &new_fs, e);
}
示例#6
0
文件: lparser.c 项目: xiaofeng/Arcemu
static void body (LexState *ls, expdesc *e, int needself, int line) {
  /* body ->  `(' parlist `)' chunk END */
  FuncState new_fs;
  open_func(ls, &new_fs);
  new_fs.f->linedefined = line;
  checknext(ls, '(');
  if (needself) {
    new_localvarliteral(ls, "self", 0);
    adjustlocalvars(ls, 1);
  }
  parlist(ls);
  checknext(ls, ')');
  chunk(ls);
  new_fs.f->lastlinedefined = ls->linenumber;
  check_match(ls, TK_END, TK_FUNCTION, line);
  close_func(ls);
  pushclosure(ls, &new_fs, e);
}
示例#7
0
Proto *luaY_parser (lua_State *L, ZIO *z, Mbuffer *buff, const char *name) {
  struct LexState lexstate;
  struct FuncState *pfuncstate = (struct FuncState*)malloc(sizeof(struct FuncState));
  Proto *res;
  lexstate.buff = buff;
  luaX_setinput(L, &lexstate, z, luaS_new(L, name));
  open_func(&lexstate, pfuncstate);
  pfuncstate->f->is_vararg = VARARG_ISVARARG;  /* main func. is always vararg */
  luaX_next(&lexstate);  /* read first token */
  chunk(&lexstate);
  check(&lexstate, TK_EOS);
  close_func(&lexstate);
  lua_assert(pfuncstate->prev == NULL);
  lua_assert(pfuncstate->f->nups == 0);
  lua_assert(lexstate.fs == NULL);
  res = pfuncstate->f;
  free(pfuncstate);
  return res;
}
示例#8
0
Proto *luaY_parser (lua_State *L, ZIO *z, Mbuffer *buff, const char *name) {
  struct LexState lexstate;
  struct FuncState funcstate;
  TString *tname = luaS_new(L, name);
  setsvalue2s(L, L->top, tname);  /* protect name */
  incr_top(L);
  lexstate.buff = buff;
  luaX_setinput(L, &lexstate, z, tname);
  open_func(&lexstate, &funcstate);
  funcstate.f->is_vararg = VARARG_ISVARARG;  /* main func. is always vararg */
  luaX_next(&lexstate);  /* read first token */
  chunk(&lexstate);
  check(&lexstate, TK_EOS);
  close_func(&lexstate);
  L->top--; /* remove 'name' from stack */
  lua_assert(funcstate.prev == NULL);
  lua_assert(funcstate.f->nups == 0);
  lua_assert(lexstate.fs == NULL);
  return funcstate.f;
}
示例#9
0
static struct rldb_plugin_cnts *
open_func(
        struct rldb_plugin_data *data,
        struct runlog_state *rl_state,
        const struct ejudge_cfg *config,
        const struct contest_desc *cnts,
        const struct section_global_data *global,
        int flags,
        time_t init_duration,
        time_t init_sched_time,
        time_t init_finish_time)
{
  struct rldb_mysql_state *state = (struct rldb_mysql_state*) data;
  struct rldb_mysql_cnts *cs = 0;
  int r;

  ASSERT(state);
  XCALLOC(cs, 1);
  cs->plugin_state = state;
  state->nref++;
  cs->rl_state = rl_state;
  if (cnts) cs->contest_id = cnts->id;
  if (!cs->contest_id) {
    err("undefined contest_id");
    goto fail;
  }

  if (do_open(state) < 0) goto fail;
  if ((r = load_header(cs, flags, init_duration, init_sched_time,
                       init_finish_time)) < 0)
    goto fail;
  if (!r) return (struct rldb_plugin_cnts*) cs;
  if (load_runs(cs) < 0) goto fail;
  state->mi->free_res(state->md);
  return (struct rldb_plugin_cnts*) cs;

 fail:
  state->mi->free_res(state->md);
  close_func((struct rldb_plugin_cnts*) cs);
  return 0;
}
示例#10
0
文件: tftp.c 项目: basecq/q2dos
static int write_func (const void *buf, size_t length)
{
  static DWORD block = 0;

  if (debug_on < 2)
      debug_on = 2;

  if (block == 0)
  {
    tot_size = 0UL;
    start = time (NULL);
    fname = tftp_boot_local_file;
    fprintf (stderr, "opening `%s'\n", fname);
    file = fopen (fname, tftp_openmode ? tftp_openmode : "wb");
  }
  if (!file)
  {
    perror (fname);
    return (-1);
  }

#if defined(__DJGPP__) && 0
  /*
   * Look for optional Watt-32 stubinfo in block 4.
   * If .exe file isn't newer, kill the connection
   */
  if (block == 4 && is_exe && check_timestamp(buf) < our_timestamp)
  {
    close_func();
    return (-1);
  }
#endif

  if (fwrite (buf, 1, length, file) < length)
     return (-1);
  tot_size += length;
  block++;
  return (0);
}
示例#11
0
static void ThreadDecodeSub( PLUGINWORK *pPluginWork )
{
    static ov_callbacks callbacks = {read_func, seek_func, close_func, tell_func};
    ULONG ulTmp;
    HFILE stream;
    ULONG ulAction;

    pPluginWork->jumpto     = -1;
    pPluginWork->fStop      = FALSE;
    pPluginWork->fTerminate = FALSE;
    pPluginWork->ffwd       = FALSE;
    pPluginWork->rew        = FALSE;
    pPluginWork->lRemain    = 0;
    pPluginWork->lOffset    = 0;

    DosWaitEventSem( pPluginWork->hevThreadTrigger, SEM_INDEFINITE_WAIT );
    DosResetEventSem( pPluginWork->hevThreadTrigger, &ulTmp );

    if(pPluginWork->fTerminate) {
        return;
    }

    pPluginWork->fStatus = DECODER_STARTING;

    DosOpen( pPluginWork->szFileName, &stream, &ulAction, 0, FILE_NORMAL, OPEN_ACTION_OPEN_IF_EXISTS, OPEN_ACCESS_READONLY | OPEN_SHARE_DENYWRITE, 0 );
    {
        double posmarker = 0.0;
        vorbis_info *vi = NULL;
        int BytesPerSec;

        // The ov_open() function performs full stream detection and machine
        // initialization.  If it returns 0, the stream *is* Vorbis and we're
        // fully ready to decode.
        if (ov_open_callbacks( (void *)stream, &pPluginWork->vf, NULL, 0, callbacks) < 0) {
            close_func( (void *)stream );
            return;
        }
        vi = ov_info( &pPluginWork->vf, -1);
        pPluginWork->format.size = sizeof(FORMAT_INFO);
        pPluginWork->format.samplerate = vi->rate;
        pPluginWork->format.channels = vi->channels;
        pPluginWork->format.bits = 16;
        pPluginWork->format.format = WAVE_FORMAT_PCM;
        BytesPerSec = vi->rate * vi->channels * 2;

        /* 曲の時間(ms) */
        pPluginWork->songlength = (int)(ov_time_total(&pPluginWork->vf, -1) * 1000.0);

        DosResetEventSem( pPluginWork->hevPlaySem, &ulTmp );
        DosPostEventSem( pPluginWork->hevThreadA );

        pPluginWork->fStatus = DECODER_PLAYING;

        //seekneeded = -1;
        while(!pPluginWork->fStop && !pPluginWork->fTerminate) {
            long read_size, read_size1;
            if(pPluginWork->jumpto != -1) {
                ov_time_seek( &pPluginWork->vf, pPluginWork->jumpto / 1000 );
                posmarker = (double)(pPluginWork->jumpto / 1000) * BytesPerSec;
                pPluginWork->lOffset = 0;
                pPluginWork->lRemain = 0;
                pPluginWork->jumpto = -1;
                WinPostMsg( pPluginWork->hwnd, WM_SEEKSTOP, 0, 0 );
            }
#if 0
            if(pPluginWork->rew) {
                posmarker -= 1 * BytesPerSec; /* 2s */
                ov_time_seek( &pPluginWork->vf, (int)(posmarker / BytesPerSec * 1000.0) );
                pPluginWork->lOffset = 0;
                pPluginWork->lRemain = 0;
//                pPluginWork->jumpto = -1;
//                WinPostMsg( pPluginWork->hwnd, WM_SEEKSTOP, 0, 0 );
            }
#endif
            read_size = Read( pPluginWork, pPluginWork->sample_buffer1, pPluginWork->BufferSize, &read_size1 );
            if(read_size < pPluginWork->BufferSize) {
                if(read_size == 0) {
                    break;
                }
                read_size = pPluginWork->BufferSize;
                memset( &pPluginWork->sample_buffer1[read_size], 0, pPluginWork->BufferSize -  read_size );
            }
            pPluginWork->output_play_samples( pPluginWork->a, &pPluginWork->format, pPluginWork->sample_buffer1, read_size, (int)(posmarker / BytesPerSec * 1000.0) );
            posmarker += (double)read_size1;
        }

        ov_clear( &pPluginWork->vf );
        WinPostMsg( pPluginWork->hwnd, WM_PLAYSTOP, 0, 0 );
        pPluginWork->fStatus = 0;
        close_func( (void *)stream );
        if(pPluginWork->fStop) {
            DosPostEventSem( pPluginWork->hevThreadA );
        }
        DosPostEventSem( pPluginWork->hevPlaySem );
    }
}
示例#12
0
文件: ftpsend.c 项目: sebastinas/yafc
int ftp_getfile(const char *infile, const char *outfile, getmode_t how,
				transfer_mode_t mode, ftp_transfer_func hookf)
{
	FILE *fp;
	int r;
	struct stat statbuf;
	long rp = 0;
	int (*close_func)(FILE *fp);

	if(stat(outfile, &statbuf) == 0) {
		if(S_ISDIR(statbuf.st_mode)) {
			ftp_err(_("%s: is a directory\n"), outfile);
			return -1;
		}
		if(!(statbuf.st_mode & S_IWRITE)) {
			ftp_err(_("%s: permission denied\n"), outfile);
			return -1;
		}
		if(how == getResume)
			ftp->restart_offset = statbuf.st_size;
	} else
		ftp->restart_offset = 0L;

	ftp->ti.total_size = -1;

	/* we need to save this, because ftp_init_receive() sets it to zero */
	rp = ftp->restart_offset;

	reset_transfer_info();
#ifdef HAVE_LIBSSH
	if (ftp->session)
	{
		/* we need to stat the remote file, so we are sure we can read it
		 * this needs to be done before we call ssh_do_receive, because by
		 * then, the file is created, and would leave a zero-size file opon
		 * failure
		 */
		sftp_attributes a = sftp_stat(ftp->sftp_session, infile);
		if(!a) {
			ftp_err(_("Unable to stat file '%s': %s\n"), infile, ssh_get_error(ftp->session));
			return -1;
		}
		sftp_attributes_free(a);
		/* FIXME: how can we check if it will be possible to transfer
		 * the specified file?
		 */
	}
	else
#endif
	if (ftp_init_receive(infile, mode, hookf) != 0)
		return -1;

	if(how == getPipe) {
		fp = popen(outfile, "w");
		close_func = pclose;
	} else {
		fp = fopen(outfile,
				   (rp > 0L || (how == getAppend)) ? "a" : "w");
		close_func = fclose;
	}
	if(!fp) {
		ftp_err("%s: %s\n", outfile, strerror(errno));
		ftp->restart_offset = 0L;
		return -1;
	}

	if(rp > 0L) {
		if(fseek(fp, rp, SEEK_SET) != 0) {
			ftp_err(_("%s: %s, transfer cancelled\n"),
					outfile, strerror(errno));
			close_func(fp);
			ftp->restart_offset = 0L;
			return -1;
		}
	}

	free(ftp->ti.remote_name);
	free(ftp->ti.local_name);
	ftp->ti.remote_name = xstrdup(infile);
	ftp->ti.local_name = xstrdup(outfile);

	foo_hookf = hookf;

#ifdef HAVE_LIBSSH
	if(ftp->session)
		r = ssh_do_receive(infile, fp, mode, hookf);
	else
#endif
		r = ftp_do_receive(fp, mode, hookf);
	close_func(fp);
	return r;
}