Mercurial > vim

comparison src/eval.c @ 8104:1a03abdc4234 v7.4.1346

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
commit https://github.com/vim/vim/commit/a1e24b9bc9123ff6dd23e3cac2287a4411ef5572 Author: Bram Moolenaar <Bram@vim.org> Date: Thu Feb 18 20:18:09 2016 +0100 patch 7.4.1346 Problem: Compiler warnings in build with -O2. Solution: Add inintializations.
author Christian Brabandt <cb@256bit.org>
date Thu, 18 Feb 2016 20:30:04 +0100
parents 7bc924a34288
children 4aea0b0aa714
comparison
equal deleted inserted replaced
8103:7f88d25da8ac 8104:1a03abdc4234
8971 * "acos()" function 8971 * "acos()" function
8972 */ 8972 */
8973 static void 8973 static void
8974 f_acos(typval_T *argvars, typval_T *rettv) 8974 f_acos(typval_T *argvars, typval_T *rettv)
8975 { 8975 {
8976 float_T f; 8976 float_T f = 0.0;
8977 8977
8978 rettv->v_type = VAR_FLOAT; 8978 rettv->v_type = VAR_FLOAT;
8979 if (get_float_arg(argvars, &f) == OK) 8979 if (get_float_arg(argvars, &f) == OK)
8980 rettv->vval.v_float = acos(f); 8980 rettv->vval.v_float = acos(f);
8981 else 8981 else
9400 * "asin()" function 9400 * "asin()" function
9401 */ 9401 */
9402 static void 9402 static void
9403 f_asin(typval_T *argvars, typval_T *rettv) 9403 f_asin(typval_T *argvars, typval_T *rettv)
9404 { 9404 {
9405 float_T f; 9405 float_T f = 0.0;
9406 9406
9407 rettv->v_type = VAR_FLOAT; 9407 rettv->v_type = VAR_FLOAT;
9408 if (get_float_arg(argvars, &f) == OK) 9408 if (get_float_arg(argvars, &f) == OK)
9409 rettv->vval.v_float = asin(f); 9409 rettv->vval.v_float = asin(f);
9410 else 9410 else
9430 * "atan2()" function 9430 * "atan2()" function
9431 */ 9431 */
9432 static void 9432 static void
9433 f_atan2(typval_T *argvars, typval_T *rettv) 9433 f_atan2(typval_T *argvars, typval_T *rettv)
9434 { 9434 {
9435 float_T fx, fy; 9435 float_T fx = 0.0, fy = 0.0;
9436 9436
9437 rettv->v_type = VAR_FLOAT; 9437 rettv->v_type = VAR_FLOAT;
9438 if (get_float_arg(argvars, &fx) == OK 9438 if (get_float_arg(argvars, &fx) == OK
9439 && get_float_arg(&argvars[1], &fy) == OK) 9439 && get_float_arg(&argvars[1], &fy) == OK)
9440 rettv->vval.v_float = atan2(fx, fy); 9440 rettv->vval.v_float = atan2(fx, fy);
9838 * "ceil({float})" function 9838 * "ceil({float})" function
9839 */ 9839 */
9840 static void 9840 static void
9841 f_ceil(typval_T *argvars, typval_T *rettv) 9841 f_ceil(typval_T *argvars, typval_T *rettv)
9842 { 9842 {
9843 float_T f; 9843 float_T f = 0.0;
9844 9844
9845 rettv->v_type = VAR_FLOAT; 9845 rettv->v_type = VAR_FLOAT;
9846 if (get_float_arg(argvars, &f) == OK) 9846 if (get_float_arg(argvars, &f) == OK)
9847 rettv->vval.v_float = ceil(f); 9847 rettv->vval.v_float = ceil(f);
9848 else 9848 else
10438 * "cos()" function 10438 * "cos()" function
10439 */ 10439 */
10440 static void 10440 static void
10441 f_cos(typval_T *argvars, typval_T *rettv) 10441 f_cos(typval_T *argvars, typval_T *rettv)
10442 { 10442 {
10443 float_T f; 10443 float_T f = 0.0;
10444 10444
10445 rettv->v_type = VAR_FLOAT; 10445 rettv->v_type = VAR_FLOAT;
10446 if (get_float_arg(argvars, &f) == OK) 10446 if (get_float_arg(argvars, &f) == OK)
10447 rettv->vval.v_float = cos(f); 10447 rettv->vval.v_float = cos(f);
10448 else 10448 else
10453 * "cosh()" function 10453 * "cosh()" function
10454 */ 10454 */
10455 static void 10455 static void
10456 f_cosh(typval_T *argvars, typval_T *rettv) 10456 f_cosh(typval_T *argvars, typval_T *rettv)
10457 { 10457 {
10458 float_T f; 10458 float_T f = 0.0;
10459 10459
10460 rettv->v_type = VAR_FLOAT; 10460 rettv->v_type = VAR_FLOAT;
10461 if (get_float_arg(argvars, &f) == OK) 10461 if (get_float_arg(argvars, &f) == OK)
10462 rettv->vval.v_float = cosh(f); 10462 rettv->vval.v_float = cosh(f);
10463 else 10463 else
11001 * "exp()" function 11001 * "exp()" function
11002 */ 11002 */
11003 static void 11003 static void
11004 f_exp(typval_T *argvars, typval_T *rettv) 11004 f_exp(typval_T *argvars, typval_T *rettv)
11005 { 11005 {
11006 float_T f; 11006 float_T f = 0.0;
11007 11007
11008 rettv->v_type = VAR_FLOAT; 11008 rettv->v_type = VAR_FLOAT;
11009 if (get_float_arg(argvars, &f) == OK) 11009 if (get_float_arg(argvars, &f) == OK)
11010 rettv->vval.v_float = exp(f); 11010 rettv->vval.v_float = exp(f);
11011 else 11011 else
11582 * "float2nr({float})" function 11582 * "float2nr({float})" function
11583 */ 11583 */
11584 static void 11584 static void
11585 f_float2nr(typval_T *argvars, typval_T *rettv) 11585 f_float2nr(typval_T *argvars, typval_T *rettv)
11586 { 11586 {
11587 float_T f; 11587 float_T f = 0.0;
11588 11588
11589 if (get_float_arg(argvars, &f) == OK) 11589 if (get_float_arg(argvars, &f) == OK)
11590 { 11590 {
11591 if (f < -0x7fffffff) 11591 if (f < -0x7fffffff)
11592 rettv->vval.v_number = -0x7fffffff; 11592 rettv->vval.v_number = -0x7fffffff;
11601 * "floor({float})" function 11601 * "floor({float})" function
11602 */ 11602 */
11603 static void 11603 static void
11604 f_floor(typval_T *argvars, typval_T *rettv) 11604 f_floor(typval_T *argvars, typval_T *rettv)
11605 { 11605 {
11606 float_T f; 11606 float_T f = 0.0;
11607 11607
11608 rettv->v_type = VAR_FLOAT; 11608 rettv->v_type = VAR_FLOAT;
11609 if (get_float_arg(argvars, &f) == OK) 11609 if (get_float_arg(argvars, &f) == OK)
11610 rettv->vval.v_float = floor(f); 11610 rettv->vval.v_float = floor(f);
11611 else 11611 else
11616 * "fmod()" function 11616 * "fmod()" function
11617 */ 11617 */
11618 static void 11618 static void
11619 f_fmod(typval_T *argvars, typval_T *rettv) 11619 f_fmod(typval_T *argvars, typval_T *rettv)
11620 { 11620 {
11621 float_T fx, fy; 11621 float_T fx = 0.0, fy = 0.0;
11622 11622
11623 rettv->v_type = VAR_FLOAT; 11623 rettv->v_type = VAR_FLOAT;
11624 if (get_float_arg(argvars, &fx) == OK 11624 if (get_float_arg(argvars, &fx) == OK
11625 && get_float_arg(&argvars[1], &fy) == OK) 11625 && get_float_arg(&argvars[1], &fy) == OK)
11626 rettv->vval.v_float = fmod(fx, fy); 11626 rettv->vval.v_float = fmod(fx, fy);
15020 * "log()" function 15020 * "log()" function
15021 */ 15021 */
15022 static void 15022 static void
15023 f_log(typval_T *argvars, typval_T *rettv) 15023 f_log(typval_T *argvars, typval_T *rettv)
15024 { 15024 {
15025 float_T f; 15025 float_T f = 0.0;
15026 15026
15027 rettv->v_type = VAR_FLOAT; 15027 rettv->v_type = VAR_FLOAT;
15028 if (get_float_arg(argvars, &f) == OK) 15028 if (get_float_arg(argvars, &f) == OK)
15029 rettv->vval.v_float = log(f); 15029 rettv->vval.v_float = log(f);
15030 else 15030 else
15035 * "log10()" function 15035 * "log10()" function
15036 */ 15036 */
15037 static void 15037 static void
15038 f_log10(typval_T *argvars, typval_T *rettv) 15038 f_log10(typval_T *argvars, typval_T *rettv)
15039 { 15039 {
15040 float_T f; 15040 float_T f = 0.0;
15041 15041
15042 rettv->v_type = VAR_FLOAT; 15042 rettv->v_type = VAR_FLOAT;
15043 if (get_float_arg(argvars, &f) == OK) 15043 if (get_float_arg(argvars, &f) == OK)
15044 rettv->vval.v_float = log10(f); 15044 rettv->vval.v_float = log10(f);
15045 else 15045 else
15831 * "pow()" function 15831 * "pow()" function
15832 */ 15832 */
15833 static void 15833 static void
15834 f_pow(typval_T *argvars, typval_T *rettv) 15834 f_pow(typval_T *argvars, typval_T *rettv)
15835 { 15835 {
15836 float_T fx, fy; 15836 float_T fx = 0.0, fy = 0.0;
15837 15837
15838 rettv->v_type = VAR_FLOAT; 15838 rettv->v_type = VAR_FLOAT;
15839 if (get_float_arg(argvars, &fx) == OK 15839 if (get_float_arg(argvars, &fx) == OK
15840 && get_float_arg(&argvars[1], &fy) == OK) 15840 && get_float_arg(&argvars[1], &fy) == OK)
15841 rettv->vval.v_float = pow(fx, fy); 15841 rettv->vval.v_float = pow(fx, fy);
17114 * "round({float})" function 17114 * "round({float})" function
17115 */ 17115 */
17116 static void 17116 static void
17117 f_round(typval_T *argvars, typval_T *rettv) 17117 f_round(typval_T *argvars, typval_T *rettv)
17118 { 17118 {
17119 float_T f; 17119 float_T f = 0.0;
17120 17120
17121 rettv->v_type = VAR_FLOAT; 17121 rettv->v_type = VAR_FLOAT;
17122 if (get_float_arg(argvars, &f) == OK) 17122 if (get_float_arg(argvars, &f) == OK)
17123 rettv->vval.v_float = vim_round(f); 17123 rettv->vval.v_float = vim_round(f);
17124 else 17124 else
18286 * "sin()" function 18286 * "sin()" function
18287 */ 18287 */
18288 static void 18288 static void
18289 f_sin(typval_T *argvars, typval_T *rettv) 18289 f_sin(typval_T *argvars, typval_T *rettv)
18290 { 18290 {
18291 float_T f; 18291 float_T f = 0.0;
18292 18292
18293 rettv->v_type = VAR_FLOAT; 18293 rettv->v_type = VAR_FLOAT;
18294 if (get_float_arg(argvars, &f) == OK) 18294 if (get_float_arg(argvars, &f) == OK)
18295 rettv->vval.v_float = sin(f); 18295 rettv->vval.v_float = sin(f);
18296 else 18296 else
18301 * "sinh()" function 18301 * "sinh()" function
18302 */ 18302 */
18303 static void 18303 static void
18304 f_sinh(typval_T *argvars, typval_T *rettv) 18304 f_sinh(typval_T *argvars, typval_T *rettv)
18305 { 18305 {
18306 float_T f; 18306 float_T f = 0.0;
18307 18307
18308 rettv->v_type = VAR_FLOAT; 18308 rettv->v_type = VAR_FLOAT;
18309 if (get_float_arg(argvars, &f) == OK) 18309 if (get_float_arg(argvars, &f) == OK)
18310 rettv->vval.v_float = sinh(f); 18310 rettv->vval.v_float = sinh(f);
18311 else 18311 else
18887 * "sqrt()" function 18887 * "sqrt()" function
18888 */ 18888 */
18889 static void 18889 static void
18890 f_sqrt(typval_T *argvars, typval_T *rettv) 18890 f_sqrt(typval_T *argvars, typval_T *rettv)
18891 { 18891 {
18892 float_T f; 18892 float_T f = 0.0;
18893 18893
18894 rettv->v_type = VAR_FLOAT; 18894 rettv->v_type = VAR_FLOAT;
18895 if (get_float_arg(argvars, &f) == OK) 18895 if (get_float_arg(argvars, &f) == OK)
18896 rettv->vval.v_float = sqrt(f); 18896 rettv->vval.v_float = sqrt(f);
18897 else 18897 else
19949 * "tan()" function 19949 * "tan()" function
19950 */ 19950 */
19951 static void 19951 static void
19952 f_tan(typval_T *argvars, typval_T *rettv) 19952 f_tan(typval_T *argvars, typval_T *rettv)
19953 { 19953 {
19954 float_T f; 19954 float_T f = 0.0;
19955 19955
19956 rettv->v_type = VAR_FLOAT; 19956 rettv->v_type = VAR_FLOAT;
19957 if (get_float_arg(argvars, &f) == OK) 19957 if (get_float_arg(argvars, &f) == OK)
19958 rettv->vval.v_float = tan(f); 19958 rettv->vval.v_float = tan(f);
19959 else 19959 else
19964 * "tanh()" function 19964 * "tanh()" function
19965 */ 19965 */
19966 static void 19966 static void
19967 f_tanh(typval_T *argvars, typval_T *rettv) 19967 f_tanh(typval_T *argvars, typval_T *rettv)
19968 { 19968 {
19969 float_T f; 19969 float_T f = 0.0;
19970 19970
19971 rettv->v_type = VAR_FLOAT; 19971 rettv->v_type = VAR_FLOAT;
19972 if (get_float_arg(argvars, &f) == OK) 19972 if (get_float_arg(argvars, &f) == OK)
19973 rettv->vval.v_float = tanh(f); 19973 rettv->vval.v_float = tanh(f);
19974 else 19974 else
20153 * "trunc({float})" function 20153 * "trunc({float})" function
20154 */ 20154 */
20155 static void 20155 static void
20156 f_trunc(typval_T *argvars, typval_T *rettv) 20156 f_trunc(typval_T *argvars, typval_T *rettv)
20157 { 20157 {
20158 float_T f; 20158 float_T f = 0.0;
20159 20159
20160 rettv->v_type = VAR_FLOAT; 20160 rettv->v_type = VAR_FLOAT;
20161 if (get_float_arg(argvars, &f) == OK) 20161 if (get_float_arg(argvars, &f) == OK)
20162 /* trunc() is not in C90, use floor() or ceil() instead. */ 20162 /* trunc() is not in C90, use floor() or ceil() instead. */
20163 rettv->vval.v_float = f > 0 ? floor(f) : ceil(f); 20163 rettv->vval.v_float = f > 0 ? floor(f) : ceil(f);