Mercurial > vim

comparison src/eval.c @ 8493:caed4b2d305f v7.4.1537

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
commit https://github.com/vim/vim/commit/509ce2a558e7e0c03242e32e844255af52f1c821 Author: Bram Moolenaar <Bram@vim.org> Date: Fri Mar 11 22:52:15 2016 +0100 patch 7.4.1537 Problem: Too many feature flags for pipes, jobs and channels. Solution: Only use FEAT_JOB_CHANNEL.
author Christian Brabandt <cb@256bit.org>
date Fri, 11 Mar 2016 23:00:06 +0100
parents daebcbd87bd3
children 42277980a76d
comparison
equal deleted inserted replaced
8492:a2a51c928924 8493:caed4b2d305f
494 static void f_byteidxcomp(typval_T *argvars, typval_T *rettv); 494 static void f_byteidxcomp(typval_T *argvars, typval_T *rettv);
495 static void f_call(typval_T *argvars, typval_T *rettv); 495 static void f_call(typval_T *argvars, typval_T *rettv);
496 #ifdef FEAT_FLOAT 496 #ifdef FEAT_FLOAT
497 static void f_ceil(typval_T *argvars, typval_T *rettv); 497 static void f_ceil(typval_T *argvars, typval_T *rettv);
498 #endif 498 #endif
499 #ifdef FEAT_CHANNEL 499 #ifdef FEAT_JOB_CHANNEL
500 static void f_ch_close(typval_T *argvars, typval_T *rettv); 500 static void f_ch_close(typval_T *argvars, typval_T *rettv);
501 static void f_ch_evalexpr(typval_T *argvars, typval_T *rettv); 501 static void f_ch_evalexpr(typval_T *argvars, typval_T *rettv);
502 static void f_ch_evalraw(typval_T *argvars, typval_T *rettv); 502 static void f_ch_evalraw(typval_T *argvars, typval_T *rettv);
503 static void f_ch_getbufnr(typval_T *argvars, typval_T *rettv); 503 static void f_ch_getbufnr(typval_T *argvars, typval_T *rettv);
504 # ifdef FEAT_JOB
505 static void f_ch_getjob(typval_T *argvars, typval_T *rettv); 504 static void f_ch_getjob(typval_T *argvars, typval_T *rettv);
506 # endif
507 static void f_ch_log(typval_T *argvars, typval_T *rettv); 505 static void f_ch_log(typval_T *argvars, typval_T *rettv);
508 static void f_ch_logfile(typval_T *argvars, typval_T *rettv); 506 static void f_ch_logfile(typval_T *argvars, typval_T *rettv);
509 static void f_ch_open(typval_T *argvars, typval_T *rettv); 507 static void f_ch_open(typval_T *argvars, typval_T *rettv);
510 static void f_ch_read(typval_T *argvars, typval_T *rettv); 508 static void f_ch_read(typval_T *argvars, typval_T *rettv);
511 static void f_ch_readraw(typval_T *argvars, typval_T *rettv); 509 static void f_ch_readraw(typval_T *argvars, typval_T *rettv);
630 static void f_islocked(typval_T *argvars, typval_T *rettv); 628 static void f_islocked(typval_T *argvars, typval_T *rettv);
631 #if defined(FEAT_FLOAT) && defined(HAVE_MATH_H) 629 #if defined(FEAT_FLOAT) && defined(HAVE_MATH_H)
632 static void f_isnan(typval_T *argvars, typval_T *rettv); 630 static void f_isnan(typval_T *argvars, typval_T *rettv);
633 #endif 631 #endif
634 static void f_items(typval_T *argvars, typval_T *rettv); 632 static void f_items(typval_T *argvars, typval_T *rettv);
635 #ifdef FEAT_JOB 633 #ifdef FEAT_JOB_CHANNEL
636 # ifdef FEAT_CHANNEL
637 static void f_job_getchannel(typval_T *argvars, typval_T *rettv); 634 static void f_job_getchannel(typval_T *argvars, typval_T *rettv);
638 # endif
639 static void f_job_setoptions(typval_T *argvars, typval_T *rettv); 635 static void f_job_setoptions(typval_T *argvars, typval_T *rettv);
640 static void f_job_start(typval_T *argvars, typval_T *rettv); 636 static void f_job_start(typval_T *argvars, typval_T *rettv);
641 static void f_job_stop(typval_T *argvars, typval_T *rettv); 637 static void f_job_stop(typval_T *argvars, typval_T *rettv);
642 static void f_job_status(typval_T *argvars, typval_T *rettv); 638 static void f_job_status(typval_T *argvars, typval_T *rettv);
643 #endif 639 #endif
6234 case VAR_FLOAT: 6230 case VAR_FLOAT:
6235 #ifdef FEAT_FLOAT 6231 #ifdef FEAT_FLOAT
6236 return tv1->vval.v_float == tv2->vval.v_float; 6232 return tv1->vval.v_float == tv2->vval.v_float;
6237 #endif 6233 #endif
6238 case VAR_JOB: 6234 case VAR_JOB:
6239 #ifdef FEAT_JOB 6235 #ifdef FEAT_JOB_CHANNEL
6240 return tv1->vval.v_job == tv2->vval.v_job; 6236 return tv1->vval.v_job == tv2->vval.v_job;
6241 #endif 6237 #endif
6242 case VAR_CHANNEL: 6238 case VAR_CHANNEL:
6243 #ifdef FEAT_CHANNEL 6239 #ifdef FEAT_JOB_CHANNEL
6244 return tv1->vval.v_channel == tv2->vval.v_channel; 6240 return tv1->vval.v_channel == tv2->vval.v_channel;
6245 #endif 6241 #endif
6246 case VAR_UNKNOWN: 6242 case VAR_UNKNOWN:
6247 break; 6243 break;
6248 } 6244 }
6924 6920
6925 #ifdef FEAT_PYTHON3 6921 #ifdef FEAT_PYTHON3
6926 abort = abort || set_ref_in_python3(copyID); 6922 abort = abort || set_ref_in_python3(copyID);
6927 #endif 6923 #endif
6928 6924
6929 #ifdef FEAT_CHANNEL 6925 #ifdef FEAT_JOB_CHANNEL
6930 abort = abort || set_ref_in_channel(copyID); 6926 abort = abort || set_ref_in_channel(copyID);
6931 #endif 6927 #endif
6932 6928
6933 if (!abort) 6929 if (!abort)
6934 { 6930 {
7736 } 7732 }
7737 7733
7738 return OK; 7734 return OK;
7739 } 7735 }
7740 7736
7741 #if defined(FEAT_CHANNEL) || defined(PROTO) 7737 #if defined(FEAT_JOB_CHANNEL) || defined(PROTO)
7742 /* 7738 /*
7743 * Decrement the reference count on "channel" and maybe free it when it goes 7739 * Decrement the reference count on "channel" and maybe free it when it goes
7744 * down to zero. Don't free it if there is a pending action. 7740 * down to zero. Don't free it if there is a pending action.
7745 * Returns TRUE when the channel is no longer referenced. 7741 * Returns TRUE when the channel is no longer referenced.
7746 */ 7742 */
7749 { 7745 {
7750 if (channel != NULL && --channel->ch_refcount <= 0) 7746 if (channel != NULL && --channel->ch_refcount <= 0)
7751 return channel_may_free(channel); 7747 return channel_may_free(channel);
7752 return FALSE; 7748 return FALSE;
7753 } 7749 }
7754 #endif 7750
7755
7756 #if defined(FEAT_JOB) || defined(PROTO)
7757 static job_T *first_job = NULL; 7751 static job_T *first_job = NULL;
7758 7752
7759 static void 7753 static void
7760 job_free(job_T *job) 7754 job_free(job_T *job)
7761 { 7755 {
7762 # ifdef FEAT_CHANNEL
7763 ch_log(job->jv_channel, "Freeing job"); 7756 ch_log(job->jv_channel, "Freeing job");
7764 if (job->jv_channel != NULL) 7757 if (job->jv_channel != NULL)
7765 { 7758 {
7766 /* The link from the channel to the job doesn't count as a reference, 7759 /* The link from the channel to the job doesn't count as a reference,
7767 * thus don't decrement the refcount of the job. The reference from 7760 * thus don't decrement the refcount of the job. The reference from
7769 * NULL the reference. We don't set ch_job_killed, unreferencing the 7762 * NULL the reference. We don't set ch_job_killed, unreferencing the
7770 * job doesn't mean it stops running. */ 7763 * job doesn't mean it stops running. */
7771 job->jv_channel->ch_job = NULL; 7764 job->jv_channel->ch_job = NULL;
7772 channel_unref(job->jv_channel); 7765 channel_unref(job->jv_channel);
7773 } 7766 }
7774 # endif
7775 mch_clear_job(job); 7767 mch_clear_job(job);
7776 7768
7777 if (job->jv_next != NULL) 7769 if (job->jv_next != NULL)
7778 job->jv_next->jv_prev = job->jv_prev; 7770 job->jv_next->jv_prev = job->jv_prev;
7779 if (job->jv_prev == NULL) 7771 if (job->jv_prev == NULL)
7796 if (job->jv_status != JOB_STARTED 7788 if (job->jv_status != JOB_STARTED
7797 || (job->jv_stoponexit == NULL && job->jv_exit_cb == NULL)) 7789 || (job->jv_stoponexit == NULL && job->jv_exit_cb == NULL))
7798 { 7790 {
7799 job_free(job); 7791 job_free(job);
7800 } 7792 }
7801 # ifdef FEAT_CHANNEL
7802 else if (job->jv_channel != NULL) 7793 else if (job->jv_channel != NULL)
7803 { 7794 {
7804 /* Do remove the link to the channel, otherwise it hangs 7795 /* Do remove the link to the channel, otherwise it hangs
7805 * around until Vim exits. See job_free() for refcount. */ 7796 * around until Vim exits. See job_free() for refcount. */
7806 job->jv_channel->ch_job = NULL; 7797 job->jv_channel->ch_job = NULL;
7807 channel_unref(job->jv_channel); 7798 channel_unref(job->jv_channel);
7808 job->jv_channel = NULL; 7799 job->jv_channel = NULL;
7809 } 7800 }
7810 # endif
7811 } 7801 }
7812 } 7802 }
7813 7803
7814 /* 7804 /*
7815 * Allocate a job. Sets the refcount to one and sets options default. 7805 * Allocate a job. Sets the refcount to one and sets options default.
8202 {"byteidxcomp", 2, 2, f_byteidxcomp}, 8192 {"byteidxcomp", 2, 2, f_byteidxcomp},
8203 {"call", 2, 3, f_call}, 8193 {"call", 2, 3, f_call},
8204 #ifdef FEAT_FLOAT 8194 #ifdef FEAT_FLOAT
8205 {"ceil", 1, 1, f_ceil}, 8195 {"ceil", 1, 1, f_ceil},
8206 #endif 8196 #endif
8207 #ifdef FEAT_CHANNEL 8197 #ifdef FEAT_JOB_CHANNEL
8208 {"ch_close", 1, 1, f_ch_close}, 8198 {"ch_close", 1, 1, f_ch_close},
8209 {"ch_evalexpr", 2, 3, f_ch_evalexpr}, 8199 {"ch_evalexpr", 2, 3, f_ch_evalexpr},
8210 {"ch_evalraw", 2, 3, f_ch_evalraw}, 8200 {"ch_evalraw", 2, 3, f_ch_evalraw},
8211 {"ch_getbufnr", 2, 2, f_ch_getbufnr}, 8201 {"ch_getbufnr", 2, 2, f_ch_getbufnr},
8212 # ifdef FEAT_JOB
8213 {"ch_getjob", 1, 1, f_ch_getjob}, 8202 {"ch_getjob", 1, 1, f_ch_getjob},
8214 # endif
8215 {"ch_log", 1, 2, f_ch_log}, 8203 {"ch_log", 1, 2, f_ch_log},
8216 {"ch_logfile", 1, 2, f_ch_logfile}, 8204 {"ch_logfile", 1, 2, f_ch_logfile},
8217 {"ch_open", 1, 2, f_ch_open}, 8205 {"ch_open", 1, 2, f_ch_open},
8218 {"ch_read", 1, 2, f_ch_read}, 8206 {"ch_read", 1, 2, f_ch_read},
8219 {"ch_readraw", 1, 2, f_ch_readraw}, 8207 {"ch_readraw", 1, 2, f_ch_readraw},
8342 {"islocked", 1, 1, f_islocked}, 8330 {"islocked", 1, 1, f_islocked},
8343 #if defined(FEAT_FLOAT) && defined(HAVE_MATH_H) 8331 #if defined(FEAT_FLOAT) && defined(HAVE_MATH_H)
8344 {"isnan", 1, 1, f_isnan}, 8332 {"isnan", 1, 1, f_isnan},
8345 #endif 8333 #endif
8346 {"items", 1, 1, f_items}, 8334 {"items", 1, 1, f_items},
8347 #ifdef FEAT_JOB 8335 #ifdef FEAT_JOB_CHANNEL
8348 # ifdef FEAT_CHANNEL
8349 {"job_getchannel", 1, 1, f_job_getchannel}, 8336 {"job_getchannel", 1, 1, f_job_getchannel},
8350 # endif
8351 {"job_setoptions", 2, 2, f_job_setoptions}, 8337 {"job_setoptions", 2, 2, f_job_setoptions},
8352 {"job_start", 1, 2, f_job_start}, 8338 {"job_start", 1, 2, f_job_start},
8353 {"job_status", 1, 1, f_job_status}, 8339 {"job_status", 1, 1, f_job_status},
8354 {"job_stop", 1, 2, f_job_stop}, 8340 {"job_stop", 1, 2, f_job_stop},
8355 #endif 8341 #endif
9953 else 9939 else
9954 rettv->vval.v_float = 0.0; 9940 rettv->vval.v_float = 0.0;
9955 } 9941 }
9956 #endif 9942 #endif
9957 9943
9958 #if defined(FEAT_CHANNEL) || defined(FEAT_JOB) 9944 #if defined(FEAT_JOB_CHANNEL)
9959 /* 9945 /*
9960 * Get a callback from "arg". It can be a Funcref or a function name. 9946 * Get a callback from "arg". It can be a Funcref or a function name.
9961 * When "arg" is zero return an empty string. 9947 * When "arg" is zero return an empty string.
9962 * Return NULL for an invalid argument. 9948 * Return NULL for an invalid argument.
9963 */ 9949 */
10310 10296
10311 return OK; 10297 return OK;
10312 } 10298 }
10313 #endif 10299 #endif
10314 10300
10315 #ifdef FEAT_CHANNEL 10301 #ifdef FEAT_JOB_CHANNEL
10316 /* 10302 /*
10317 * Get the channel from the argument. 10303 * Get the channel from the argument.
10318 * Returns NULL if the handle is invalid. 10304 * Returns NULL if the handle is invalid.
10319 */ 10305 */
10320 static channel_T * 10306 static channel_T *
10385 if (channel->ch_part[part].ch_buffer != NULL) 10371 if (channel->ch_part[part].ch_buffer != NULL)
10386 rettv->vval.v_number = channel->ch_part[part].ch_buffer->b_fnum; 10372 rettv->vval.v_number = channel->ch_part[part].ch_buffer->b_fnum;
10387 } 10373 }
10388 } 10374 }
10389 10375
10390 # ifdef FEAT_JOB
10391 /* 10376 /*
10392 * "ch_getjob()" function 10377 * "ch_getjob()" function
10393 */ 10378 */
10394 static void 10379 static void
10395 f_ch_getjob(typval_T *argvars, typval_T *rettv) 10380 f_ch_getjob(typval_T *argvars, typval_T *rettv)
10402 rettv->vval.v_job = channel->ch_job; 10387 rettv->vval.v_job = channel->ch_job;
10403 if (channel->ch_job != NULL) 10388 if (channel->ch_job != NULL)
10404 ++channel->ch_job->jv_refcount; 10389 ++channel->ch_job->jv_refcount;
10405 } 10390 }
10406 } 10391 }
10407 # endif
10408 10392
10409 /* 10393 /*
10410 * "ch_log()" function 10394 * "ch_log()" function
10411 */ 10395 */
10412 static void 10396 static void
11425 case VAR_SPECIAL: 11409 case VAR_SPECIAL:
11426 n = argvars[0].vval.v_number != VVAL_TRUE; 11410 n = argvars[0].vval.v_number != VVAL_TRUE;
11427 break; 11411 break;
11428 11412
11429 case VAR_JOB: 11413 case VAR_JOB:
11430 #ifdef FEAT_JOB 11414 #ifdef FEAT_JOB_CHANNEL
11431 n = argvars[0].vval.v_job == NULL 11415 n = argvars[0].vval.v_job == NULL
11432 || argvars[0].vval.v_job->jv_status != JOB_STARTED; 11416 || argvars[0].vval.v_job->jv_status != JOB_STARTED;
11433 break; 11417 break;
11434 #endif 11418 #endif
11435 case VAR_CHANNEL: 11419 case VAR_CHANNEL:
11436 #ifdef FEAT_CHANNEL 11420 #ifdef FEAT_JOB_CHANNEL
11437 n = argvars[0].vval.v_channel == NULL 11421 n = argvars[0].vval.v_channel == NULL
11438 || !channel_is_open(argvars[0].vval.v_channel); 11422 || !channel_is_open(argvars[0].vval.v_channel);
11439 break; 11423 break;
11440 #endif 11424 #endif
11441 case VAR_UNKNOWN: 11425 case VAR_UNKNOWN:
13813 "browsefilter", 13797 "browsefilter",
13814 #endif 13798 #endif
13815 #ifdef FEAT_BYTEOFF 13799 #ifdef FEAT_BYTEOFF
13816 "byte_offset", 13800 "byte_offset",
13817 #endif 13801 #endif
13818 #ifdef FEAT_CHANNEL 13802 #ifdef FEAT_JOB_CHANNEL
13819 "channel", 13803 "channel",
13820 #endif 13804 #endif
13821 #ifdef FEAT_CINDENT 13805 #ifdef FEAT_CINDENT
13822 "cindent", 13806 "cindent",
13823 #endif 13807 #endif
13949 "iconv", 13933 "iconv",
13950 #endif 13934 #endif
13951 #ifdef FEAT_INS_EXPAND 13935 #ifdef FEAT_INS_EXPAND
13952 "insert_expand", 13936 "insert_expand",
13953 #endif 13937 #endif
13954 #ifdef FEAT_JOB 13938 #ifdef FEAT_JOB_CHANNEL
13955 "job", 13939 "job",
13956 #endif 13940 #endif
13957 #ifdef FEAT_JUMPLIST 13941 #ifdef FEAT_JUMPLIST
13958 "jumplist", 13942 "jumplist",
13959 #endif 13943 #endif
15090 f_items(typval_T *argvars, typval_T *rettv) 15074 f_items(typval_T *argvars, typval_T *rettv)
15091 { 15075 {
15092 dict_list(argvars, rettv, 2); 15076 dict_list(argvars, rettv, 2);
15093 } 15077 }
15094 15078
15095 #if defined(FEAT_JOB) || defined(PROTO) 15079 #if defined(FEAT_JOB_CHANNEL) || defined(PROTO)
15096 /* 15080 /*
15097 * Get the job from the argument. 15081 * Get the job from the argument.
15098 * Returns NULL if the job is invalid. 15082 * Returns NULL if the job is invalid.
15099 */ 15083 */
15100 static job_T * 15084 static job_T *
15112 if (job == NULL) 15096 if (job == NULL)
15113 EMSG(_("E916: not a valid job")); 15097 EMSG(_("E916: not a valid job"));
15114 return job; 15098 return job;
15115 } 15099 }
15116 15100
15117 # ifdef FEAT_CHANNEL
15118 /* 15101 /*
15119 * "job_getchannel()" function 15102 * "job_getchannel()" function
15120 */ 15103 */
15121 static void 15104 static void
15122 f_job_getchannel(typval_T *argvars, typval_T *rettv) 15105 f_job_getchannel(typval_T *argvars, typval_T *rettv)
15129 rettv->vval.v_channel = job->jv_channel; 15112 rettv->vval.v_channel = job->jv_channel;
15130 if (job->jv_channel != NULL) 15113 if (job->jv_channel != NULL)
15131 ++job->jv_channel->ch_refcount; 15114 ++job->jv_channel->ch_refcount;
15132 } 15115 }
15133 } 15116 }
15134 # endif
15135 15117
15136 /* 15118 /*
15137 * "job_setoptions()" function 15119 * "job_setoptions()" function
15138 */ 15120 */
15139 static void 15121 static void
15296 cmd = ga.ga_data; 15278 cmd = ga.ga_data;
15297 #endif 15279 #endif
15298 } 15280 }
15299 15281
15300 #ifdef USE_ARGV 15282 #ifdef USE_ARGV
15301 # ifdef FEAT_CHANNEL
15302 if (ch_log_active()) 15283 if (ch_log_active())
15303 { 15284 {
15304 garray_T ga; 15285 garray_T ga;
15305 int i; 15286 int i;
15306 15287
15312 ga_concat(&ga, (char_u *)argv[i]); 15293 ga_concat(&ga, (char_u *)argv[i]);
15313 } 15294 }
15314 ch_logs(NULL, "Starting job: %s", (char *)ga.ga_data); 15295 ch_logs(NULL, "Starting job: %s", (char *)ga.ga_data);
15315 ga_clear(&ga); 15296 ga_clear(&ga);
15316 } 15297 }
15317 # endif
15318 mch_start_job(argv, job, &opt); 15298 mch_start_job(argv, job, &opt);
15319 #else 15299 #else
15320 # ifdef FEAT_CHANNEL
15321 ch_logs(NULL, "Starting job: %s", (char *)cmd); 15300 ch_logs(NULL, "Starting job: %s", (char *)cmd);
15322 # endif
15323 mch_start_job((char *)cmd, job, &opt); 15301 mch_start_job((char *)cmd, job, &opt);
15324 #endif 15302 #endif
15325 15303
15326 #ifdef FEAT_CHANNEL
15327 /* If the channel is reading from a buffer, write lines now. */ 15304 /* If the channel is reading from a buffer, write lines now. */
15328 if (job->jv_channel != NULL) 15305 if (job->jv_channel != NULL)
15329 channel_write_in(job->jv_channel); 15306 channel_write_in(job->jv_channel);
15330 #endif
15331 15307
15332 theend: 15308 theend:
15333 #ifdef USE_ARGV 15309 #ifdef USE_ARGV
15334 vim_free(argv); 15310 vim_free(argv);
15335 #else 15311 #else
15352 else if (job->jv_status == JOB_FAILED) 15328 else if (job->jv_status == JOB_FAILED)
15353 result = "fail"; 15329 result = "fail";
15354 else 15330 else
15355 { 15331 {
15356 result = mch_job_status(job); 15332 result = mch_job_status(job);
15357 # ifdef FEAT_CHANNEL
15358 if (job->jv_status == JOB_ENDED) 15333 if (job->jv_status == JOB_ENDED)
15359 ch_log(job->jv_channel, "Job ended"); 15334 ch_log(job->jv_channel, "Job ended");
15360 # endif
15361 if (job->jv_status == JOB_ENDED && job->jv_exit_cb != NULL) 15335 if (job->jv_status == JOB_ENDED && job->jv_exit_cb != NULL)
15362 { 15336 {
15363 typval_T argv[3]; 15337 typval_T argv[3];
15364 typval_T rettv; 15338 typval_T rettv;
15365 int dummy; 15339 int dummy;
15448 { 15422 {
15449 EMSG(_(e_invarg)); 15423 EMSG(_(e_invarg));
15450 return; 15424 return;
15451 } 15425 }
15452 } 15426 }
15453 # ifdef FEAT_CHANNEL
15454 ch_logs(job->jv_channel, "Stopping job with '%s'", (char *)arg); 15427 ch_logs(job->jv_channel, "Stopping job with '%s'", (char *)arg);
15455 # endif
15456 if (mch_stop_job(job, arg) == FAIL) 15428 if (mch_stop_job(job, arg) == FAIL)
15457 rettv->vval.v_number = 0; 15429 rettv->vval.v_number = 0;
15458 else 15430 else
15459 { 15431 {
15460 rettv->vval.v_number = 1; 15432 rettv->vval.v_number = 1;
22412 break; 22384 break;
22413 case VAR_DICT: 22385 case VAR_DICT:
22414 dict_unref(varp->vval.v_dict); 22386 dict_unref(varp->vval.v_dict);
22415 break; 22387 break;
22416 case VAR_JOB: 22388 case VAR_JOB:
22417 #ifdef FEAT_JOB 22389 #ifdef FEAT_JOB_CHANNEL
22418 job_unref(varp->vval.v_job); 22390 job_unref(varp->vval.v_job);
22419 break; 22391 break;
22420 #endif 22392 #endif
22421 case VAR_CHANNEL: 22393 case VAR_CHANNEL:
22422 #ifdef FEAT_CHANNEL 22394 #ifdef FEAT_JOB_CHANNEL
22423 channel_unref(varp->vval.v_channel); 22395 channel_unref(varp->vval.v_channel);
22424 break; 22396 break;
22425 #endif 22397 #endif
22426 case VAR_NUMBER: 22398 case VAR_NUMBER:
22427 case VAR_FLOAT: 22399 case VAR_FLOAT:
22466 #ifdef FEAT_FLOAT 22438 #ifdef FEAT_FLOAT
22467 varp->vval.v_float = 0.0; 22439 varp->vval.v_float = 0.0;
22468 break; 22440 break;
22469 #endif 22441 #endif
22470 case VAR_JOB: 22442 case VAR_JOB:
22471 #ifdef FEAT_JOB 22443 #ifdef FEAT_JOB_CHANNEL
22472 job_unref(varp->vval.v_job); 22444 job_unref(varp->vval.v_job);
22473 varp->vval.v_job = NULL; 22445 varp->vval.v_job = NULL;
22474 #endif 22446 #endif
22475 break; 22447 break;
22476 case VAR_CHANNEL: 22448 case VAR_CHANNEL:
22477 #ifdef FEAT_CHANNEL 22449 #ifdef FEAT_JOB_CHANNEL
22478 channel_unref(varp->vval.v_channel); 22450 channel_unref(varp->vval.v_channel);
22479 varp->vval.v_channel = NULL; 22451 varp->vval.v_channel = NULL;
22480 #endif 22452 #endif
22481 case VAR_UNKNOWN: 22453 case VAR_UNKNOWN:
22482 break; 22454 break;
22541 break; 22513 break;
22542 case VAR_SPECIAL: 22514 case VAR_SPECIAL:
22543 return varp->vval.v_number == VVAL_TRUE ? 1 : 0; 22515 return varp->vval.v_number == VVAL_TRUE ? 1 : 0;
22544 break; 22516 break;
22545 case VAR_JOB: 22517 case VAR_JOB:
22546 #ifdef FEAT_JOB 22518 #ifdef FEAT_JOB_CHANNEL
22547 EMSG(_("E910: Using a Job as a Number")); 22519 EMSG(_("E910: Using a Job as a Number"));
22548 break; 22520 break;
22549 #endif 22521 #endif
22550 case VAR_CHANNEL: 22522 case VAR_CHANNEL:
22551 #ifdef FEAT_CHANNEL 22523 #ifdef FEAT_JOB_CHANNEL
22552 EMSG(_("E913: Using a Channel as a Number")); 22524 EMSG(_("E913: Using a Channel as a Number"));
22553 break; 22525 break;
22554 #endif 22526 #endif
22555 case VAR_UNKNOWN: 22527 case VAR_UNKNOWN:
22556 EMSG2(_(e_intern2), "get_tv_number(UNKNOWN)"); 22528 EMSG2(_(e_intern2), "get_tv_number(UNKNOWN)");
22587 break; 22559 break;
22588 case VAR_SPECIAL: 22560 case VAR_SPECIAL:
22589 EMSG(_("E907: Using a special value as a Float")); 22561 EMSG(_("E907: Using a special value as a Float"));
22590 break; 22562 break;
22591 case VAR_JOB: 22563 case VAR_JOB:
22592 # ifdef FEAT_JOB 22564 # ifdef FEAT_JOB_CHANNEL
22593 EMSG(_("E911: Using a Job as a Float")); 22565 EMSG(_("E911: Using a Job as a Float"));
22594 break; 22566 break;
22595 # endif 22567 # endif
22596 case VAR_CHANNEL: 22568 case VAR_CHANNEL:
22597 # ifdef FEAT_CHANNEL 22569 # ifdef FEAT_JOB_CHANNEL
22598 EMSG(_("E914: Using a Channel as a Float")); 22570 EMSG(_("E914: Using a Channel as a Float"));
22599 break; 22571 break;
22600 # endif 22572 # endif
22601 case VAR_UNKNOWN: 22573 case VAR_UNKNOWN:
22602 EMSG2(_(e_intern2), "get_tv_float(UNKNOWN)"); 22574 EMSG2(_(e_intern2), "get_tv_float(UNKNOWN)");
22709 return (char_u *)""; 22681 return (char_u *)"";
22710 case VAR_SPECIAL: 22682 case VAR_SPECIAL:
22711 STRCPY(buf, get_var_special_name(varp->vval.v_number)); 22683 STRCPY(buf, get_var_special_name(varp->vval.v_number));
22712 return buf; 22684 return buf;
22713 case VAR_JOB: 22685 case VAR_JOB:
22714 #ifdef FEAT_JOB 22686 #ifdef FEAT_JOB_CHANNEL
22715 { 22687 {
22716 job_T *job = varp->vval.v_job; 22688 job_T *job = varp->vval.v_job;
22717 char *status; 22689 char *status;
22718 22690
22719 if (job == NULL) 22691 if (job == NULL)
22736 return buf; 22708 return buf;
22737 } 22709 }
22738 #endif 22710 #endif
22739 break; 22711 break;
22740 case VAR_CHANNEL: 22712 case VAR_CHANNEL:
22741 #ifdef FEAT_CHANNEL 22713 #ifdef FEAT_JOB_CHANNEL
22742 { 22714 {
22743 channel_T *channel = varp->vval.v_channel; 22715 channel_T *channel = varp->vval.v_channel;
22744 char *status = channel_status(channel); 22716 char *status = channel_status(channel);
22745 22717
22746 if (channel == NULL) 22718 if (channel == NULL)
23375 #ifdef FEAT_FLOAT 23347 #ifdef FEAT_FLOAT
23376 to->vval.v_float = from->vval.v_float; 23348 to->vval.v_float = from->vval.v_float;
23377 break; 23349 break;
23378 #endif 23350 #endif
23379 case VAR_JOB: 23351 case VAR_JOB:
23380 #ifdef FEAT_JOB 23352 #ifdef FEAT_JOB_CHANNEL
23381 to->vval.v_job = from->vval.v_job; 23353 to->vval.v_job = from->vval.v_job;
23382 if (to->vval.v_job != NULL) 23354 if (to->vval.v_job != NULL)
23383 ++to->vval.v_job->jv_refcount; 23355 ++to->vval.v_job->jv_refcount;
23384 break; 23356 break;
23385 #endif 23357 #endif
23386 case VAR_CHANNEL: 23358 case VAR_CHANNEL:
23387 #ifdef FEAT_CHANNEL 23359 #ifdef FEAT_JOB_CHANNEL
23388 to->vval.v_channel = from->vval.v_channel; 23360 to->vval.v_channel = from->vval.v_channel;
23389 if (to->vval.v_channel != NULL) 23361 if (to->vval.v_channel != NULL)
23390 ++to->vval.v_channel->ch_refcount; 23362 ++to->vval.v_channel->ch_refcount;
23391 break; 23363 break;
23392 #endif 23364 #endif