Expression engine: added handling of current timestamp; optimizations

Author: malloch

src/expression.c

@@ -262,7 +262,7 @@ void mpr_expr_set_var_updated(mpr_expr expr, int var_idx)
                   && var_idx != expr->mute_ctl);
     expr->vars[var_idx].flags |= VAR_SET_EXTERN;
     /* Reset expression offset to 0 in case other variables are initialised from this one. */
-    expr->stack->offset = 0;
+    expr->stack->init_offset = 0;
     return;
 }
 

src/expression/expr_evaluator.h

@@ -109,7 +109,7 @@ int mpr_expr_eval(mpr_expr expr, ebuffer buff, mpr_value *v_in, mpr_value *v_var
     etoken_t *tok = stk->tokens, *end = tok + stk->num_tokens;
     int dp = -1, sp = -stk->vec_len, status = 1 | EXPR_EVAL_DONE;
     /* Note: signal, history, and vector reduce are currently limited to 255 items here */
-    uint8_t alive = 1, muted = 0, can_advance = 1, cache = 0, vlen = stk->vec_len;
+    uint8_t alive = 1, muted = 0, cache = 0, vlen = stk->vec_len;
     uint8_t hist_offset = 0, sig_offset = 0, vec_offset = 0;
     mpr_value x = NULL;
 
@@ -118,7 +118,7 @@ int mpr_expr_eval(mpr_expr expr, ebuffer buff, mpr_value *v_in, mpr_value *v_var
     mpr_type *types = buff->types;
 
     if (v_out && mpr_value_get_num_samps(v_out, inst_idx) > 0) {
-        tok += stk->offset;
+        tok += stk->init_offset;
     }
 
     if (v_vars) {
@@ -215,15 +215,31 @@ int mpr_expr_eval(mpr_expr expr, ebuffer buff, mpr_value *v_in, mpr_value *v_var
             if (VAR_Y == tok->var.idx) {
                 RETURN_ARG_UNLESS(v_out, status);
                 v = v_out;
-                can_advance = 0;
 #if TRACE_EVAL
                 printf("[y]");
 #endif
             }
+            else if (VAR_NOW == tok->var.idx) {
+                int i;
+                double t_d;
+                RETURN_ARG_UNLESS(time, status);
+#if TRACE_EVAL
+                printf("[now]");
+#endif
+                SET_STACK_PTR(idxp + 1);
+                t_d = mpr_time_as_dbl(*time);
+                for (i = sp; i < sp + tok->gen.vec_len; i++)
+                    vals[i].d = t_d;
+                SET_TYPE(MPR_DBL);
+                SET_LEN(tok->gen.vec_len);
+#if TRACE_EVAL
+                evalue_print(vals + sp, types[dp], lens[dp], dp);
+#endif
+                break;
+            }
             else if (VAR_NEXT == tok->var.idx) {
                 RETURN_ARG_UNLESS(v_next, status);
                 v = v_next;
-                can_advance = 0;
 #if TRACE_EVAL
                 printf("[next]");
 #endif
@@ -259,7 +275,6 @@ int mpr_expr_eval(mpr_expr expr, ebuffer buff, mpr_value *v_in, mpr_value *v_var
                     else
                         goto error;
                 }
-                can_advance = 0;
 
                 /* If no instance idx is cached this means that this expression contains a
                  * non-reducing reference to the variable x, and that mpr_expr_eval() should be
@@ -269,7 +284,6 @@ int mpr_expr_eval(mpr_expr expr, ebuffer buff, mpr_value *v_in, mpr_value *v_var
             }
             else if (v_vars) {
                 v = v_vars[tok->var.idx];
-                can_advance = 0;
 #if TRACE_EVAL
                 if (expr->vars && expr->vars[tok->var.idx].name)
                     printf("[%d:%s]", tok->var.idx, expr->vars[tok->var.idx].name);
@@ -451,7 +465,6 @@ int mpr_expr_eval(mpr_expr expr, ebuffer buff, mpr_value *v_in, mpr_value *v_var
                 goto error;
             for (i = 1; i < tok->gen.vec_len; i++)
                 vals[sp + i].i = vals[sp].i;
-            can_advance = 0;
 #if TRACE_EVAL
             evalue_print(vals + sp, types[dp], lens[dp], dp);
 #endif
@@ -615,8 +628,6 @@ int mpr_expr_eval(mpr_expr expr, ebuffer buff, mpr_value *v_in, mpr_value *v_var
             default:
                 goto error;
             }
-            if (tok->fn.idx > FN_DEL_IDX)
-                can_advance = 0;
 #if TRACE_EVAL
             evalue_print(vals + sp, types[dp], lens[dp], dp);
 #endif
@@ -894,8 +905,6 @@ int mpr_expr_eval(mpr_expr expr, ebuffer buff, mpr_value *v_in, mpr_value *v_var
         }
         case TOK_ASSIGN:
         case TOK_ASSIGN_USE:
-            if (VAR_Y == tok->var.idx)
-                can_advance = 0;
         case TOK_ASSIGN_CONST: {
             mpr_value v;
             /* currently only history and vector indices are supported for assignment */
@@ -914,7 +923,6 @@ int mpr_expr_eval(mpr_expr expr, ebuffer buff, mpr_value *v_in, mpr_value *v_var
                     goto assign_done;
                 }
                 status |= muted ? EXPR_MUTED_UPDATE : EXPR_UPDATE;
-                can_advance = 0;
                 if (!v_out)
                     return status;
                 v = v_out;
@@ -1014,30 +1022,16 @@ int mpr_expr_eval(mpr_expr expr, ebuffer buff, mpr_value *v_in, mpr_value *v_var
                         status |= EXPR_RELEASE_BEFORE_UPDATE;
                 }
                 alive = vals[sp].i != 0;
-                can_advance = 0;
             }
             else if (tok->var.idx == expr->mute_ctl) {
                 muted = vals[sp].i != 0;
-                can_advance = 0;
             }
             else if (VAR_Y >= tok->var.idx && !hidx) {
                 /* inform value struct that it has value */
                 mpr_value_set_elements_known(v, inst_idx, vidx, tok->gen.vec_len);
             }
 
         assign_done:
-            /* If assignment was constant or history initialization, move expr
-             * start token pointer so we don't evaluate this section again. */
-
-            if (can_advance || tok->gen.flags & VAR_HIST_IDX) {
-#if TRACE_EVAL
-                printf("\n     move start\t%ld\n", tok - stk->tokens + 1);
-#endif
-                stk->offset = tok - stk->tokens + 1;
-            }
-            else
-                can_advance = 0;
-
             if (tok->gen.flags & CLEAR_STACK)
                 dp = -1;
             else if (dp && TOK_ASSIGN_USE != tok->toktype)
@@ -1094,16 +1088,6 @@ int mpr_expr_eval(mpr_expr expr, ebuffer buff, mpr_value *v_in, mpr_value *v_var
             mpr_time_set_dbl(&t, vals[sp].d);
             mpr_value_set_time(v, t, inst_idx, hidx);
 
-            /* If assignment was constant or history initialization, move expr
-             * start token pointer so we don't evaluate this section again. */
-            if (can_advance || tok->gen.flags & VAR_HIST_IDX) {
-#if TRACE_EVAL
-                printf("     move start\t%ld\n", tok - stk->tokens + 1);
-#endif
-                stk->offset = tok - stk->tokens + 1;
-            }
-            else
-                can_advance = 0;
             if (tok->gen.flags & CLEAR_STACK)
                 dp = -1;
             else {

src/expression/expr_lexer.h

@@ -17,6 +17,11 @@ static int var_lookup(etoken tok, const char *s, int len)
         s += 2;
         len -= 2;
     }
+    if (3 == len && 0 == strncmp(s, "now", 3)) {
+        tok->var.idx = VAR_NOW;
+        tok->toktype = TOK_TT;
+        return 0;
+    }
     if (4 == len && 0 == strncmp(s, "next", 4)) {
         tok->var.idx = VAR_NEXT;
         tok->toktype = TOK_TT;

src/expression/expr_parser.h

@@ -315,7 +315,7 @@ int expr_parser_build_stack(mpr_expr expr, const char *str,
                     break;
                 }
 
-                if (tok.var.idx == VAR_X_NEWEST) {
+                if (VAR_X_NEWEST == tok.var.idx) {
                     tok.gen.datatype = type_lo;
                     tok.gen.casttype = type_hi;
                     tok.gen.vec_len = out->vec_len;
@@ -330,12 +330,12 @@ int expr_parser_build_stack(mpr_expr expr, const char *str,
                     tok.gen.flags |= (TYPE_LOCKED | VEC_LEN_LOCKED);
                     is_const = 0;
                 }
-                else if (tok.var.idx == VAR_Y) {
+                else if (VAR_Y == tok.var.idx) {
                     tok.gen.datatype = dst_types[0];
                     tok.gen.vec_len = dst_lens[0];
                     tok.gen.flags |= (TYPE_LOCKED | VEC_LEN_LOCKED);
                 }
-                else if (tok.var.idx == VAR_NEXT) {
+                else if (VAR_NOW == tok.var.idx || VAR_NEXT == tok.var.idx) {
                     tok.gen.datatype = MPR_DBL;
                     tok.gen.vec_len = 1;
                     tok.gen.flags |= (TYPE_LOCKED | VEC_LEN_LOCKED);
@@ -476,6 +476,7 @@ int expr_parser_build_stack(mpr_expr expr, const char *str,
             }
             case TOK_OP_UNARY:
                 {FAIL_IF(   !op->num_tokens
+                         && tok.op.idx != OP_LOGICAL_NOT
                          && tok.op.idx != OP_INCREMENT_PRE
                          && tok.op.idx != OP_DECREMENT_PRE, "illegal unary operator at expr start");}
                 tok.toktype = TOK_OP;
@@ -1872,6 +1873,9 @@ int expr_parser_build_stack(mpr_expr expr, const char *str,
                 pre = t->op.idx == OP_INCREMENT_PRE || t->op.idx == OP_DECREMENT_PRE,
                 var_idx = i - 1,
                 flags = t->gen.flags;
+#if TRACE_PARSE
+            printf("expanding %sfix %screment operator\n", pre ? "pre" : "post", inc ? "in" : "de");
+#endif
             etoken_t newtok, *vartok = estack_peek(out, var_idx);
             {FAIL_IF(TOK_VAR != vartok->toktype, "misplaced increment or decrement operator");}
             {FAIL_IF(vartok->var.idx >= VAR_X_NEWEST, "cannot assign to variable 'x'");}
@@ -1892,18 +1896,35 @@ int expr_parser_build_stack(mpr_expr expr, const char *str,
                 case MPR_DBL:   t->lit.val.d = 1; break;
             }
 
+            /* The postfix increment/decrement operators require copying the unaltered variable
+             * value to the evaluation stack before incrementing/decrementing so it can be used
+             * in further calculations. An exception is made if the variable being incremented
+             * is not otherwise assigned, e.g. "a++;" */
             if (!pre) {
-                /* need to insert copy token after variable */
-                /* newtok.toktype = TOK_COPY_FROM;
-                 * newtok.con.cache_offset = 0;
-                 * estack_insert(out, i++, 1, &newtok);
-                 */
-
-                /* above code does not guarantee that variable token will not be cast to another
-                 * datatype before copy */
-                /* for now we will copy variable substack instead of using copy */
-                estack_insert(out, i, substack_len, estack_peek(out, var_idx - substack_len + 1));
-                i += substack_len;
+                /* check if the variable is assigned */
+                int top = out->num_tokens - 1, copy_tokens = 1;
+                while (top > 0) {
+                    top -= estack_get_substack_len(out, top);
+                    if (top == i) {
+                        copy_tokens = 0;
+                        break;
+                    }
+                    if (top < i)
+                        break;
+                }
+                if (copy_tokens) {
+                    /* need to insert copy token after variable */
+                    /* newtok.toktype = TOK_COPY_FROM;
+                     * newtok.con.cache_offset = 0;
+                     * estack_insert(out, i++, 1, &newtok);
+                     */
+
+                    /* above code does not guarantee that variable token will not be cast to another
+                     * datatype before copy */
+                    /* for now we will copy variable substack instead of using copy */
+                    estack_insert(out, i, substack_len, estack_peek(out, var_idx - substack_len + 1));
+                    i += substack_len;
+                }
             }
 
             /* add operator */
@@ -1923,6 +1944,18 @@ int expr_parser_build_stack(mpr_expr expr, const char *str,
         }
     }
 
+    /* run checks on VAR_NOW and VAR_NEXT */
+    for (i = 0; i < out->num_tokens; i++) {
+        etoken t = estack_peek(out, i);
+        {FAIL_IF(   (TOK_VAR == t->toktype || TOK_ASSIGN == t->toktype)
+                 && (VAR_NOW == t->var.idx || VAR_NEXT == t->var.idx),
+                 "Illegal variable index.");}
+        {FAIL_IF(TOK_TT == t->toktype && VAR_NOW == t->var.idx && NUM_VAR_IDXS(t->gen.flags),
+                 "'now' timestamp does not accept indices.");}
+        {FAIL_IF(TOK_ASSIGN_TT == t->toktype && VAR_NOW == t->var.idx,
+                 "Cannot assign to 'now' timestamp.");}
+    }
+
     /* check that all used-defined variables were assigned */
     for (i = 0; i < num_var; i++) {
         {FAIL_IF(!(vars[i].flags & VAR_ASSIGNED), "User-defined variable not assigned.");}
@@ -1934,6 +1967,8 @@ int expr_parser_build_stack(mpr_expr expr, const char *str,
     /* replace special constants with their typed values */
     {FAIL_IF(estack_replace_special_constants(out), "Error replacing special constants."); }
 
+    estack_find_init_offset(out);
+
 #if TRACE_PARSE
     estack_print("OUTPUT STACK", out, vars, 0);
     estack_print("OPERATOR STACK", op, vars, 0);