Mercurial > vim
comparison src/eval.c @ 8493:caed4b2d305f v7.4.1537
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 |