Update of /cvsroot/monetdb/pathfinder/compiler/mil
In directory sc8-pr-cvs16.sourceforge.net:/tmp/cvs-serv21826/compiler/mil

Modified Files:
      Tag: PF_ROX
        mil.c mil_dce.c milgen.brg milprint.c 
Log Message:
propagated changes of Thursday Jun 05 2008 - Friday Jun 06 2008
from the development trunk to the PF_ROX branch



U milprint.c
Index: milprint.c
===================================================================
RCS file: /cvsroot/monetdb/pathfinder/compiler/mil/milprint.c,v
retrieving revision 1.62.2.8
retrieving revision 1.62.2.9
diff -u -d -r1.62.2.8 -r1.62.2.9
--- milprint.c  24 May 2008 10:51:37 -0000      1.62.2.8
+++ milprint.c  6 Jun 2008 14:25:43 -0000       1.62.2.9
@@ -10,6 +10,7 @@
    statements    : statements statements                    <m_seq>
                  | 'if (' Expr ') {' stmts '} else {' stmts '}' <m_if>
                  | 'while (' Expr ') {' stmts '}'           <m_while>
+                 | 'break'                                  <m_break>
                  | <nothing>                                <m_nop>
                  | '#' c                                    <m_comment>
                  | statement ';'                            <otherwise>
@@ -60,6 +61,7 @@
                  | expression '.CTrefine (' expression ')'  <m_ctrefine>
                  | expression '.CTrefine_rev (' exp ')'     <m_ctrefine_rev>
                  | expression '.CTderive (' expression ')'  <m_ctderive>
+                 | expression '.texist (' expression ')'    <m_texist>
                  | expression '.insert (' expression ')'    <m_binsert>
                  | expression '.append (' expression ')'    <m_bappend>
                  | expression '.fetch (' expression ')'     <m_fetch>
@@ -104,6 +106,7 @@
                  | '[floor](' expression ')'                <m_mfloor>
                  | '[round_up](' expression ')'             <m_mround_up>
                  | '>(' expression ',' expression ')'       <m_gt>
+                 | '<=(' expression ',' expression ')'      <m_le>
                  | '=(' expression ',' expression ')'       <m_eq>
                  | '[=](' expression ',' expression ')'     <m_meq>
                  | '[>](' expression ',' expression ')'     <m_mgt>
@@ -125,6 +128,7 @@
                  | '[string](' expression ',' expression ')'<m_mstring>
                  | '[string](' exp ',' exp ',' exp ')'      <m_mstring2>
                  | '[startsWith](' exp ',' exp ')'          <m_mstarts_with>
+                 | 'startsWith(' exp ',' exp ')'            <m_starts_with>
                  | '[endsWith](' exp ',' exp ')'            <m_mends_with>
                  | '[length](' expresion ')'                <m_mlength>
                  | '[toUpper](' expresion ')'               <m_mtoUpper>
@@ -278,6 +282,7 @@
     , [m_ctrefine]     = "CTrefine"
     , [m_ctrefine_rev] = "CTrefine_rev"
     , [m_ctderive]     = "CTderive"
+    , [m_texist]       = "texist"
 
     , [m_add]          = "+"
     , [m_madd]         = "[+]"
@@ -293,6 +298,7 @@
     , [m_mfloor]       = "[floor]"
     , [m_mround_up]    = "[round_up]"
     , [m_gt]           = ">"
+    , [m_le]           = "<="
     , [m_eq]           = "="
     , [m_meq]          = "[=]"
     , [m_mgt]          = "[>]"
@@ -311,6 +317,7 @@
     , [m_mstring]      = "[string]"
     , [m_mstring2]     = "[string]"
     , [m_mstarts_with] = "[startsWith]"
+    , [m_starts_with]  = "startsWith"
     , [m_mends_with]   = "[endsWith]"
     , [m_mlength]      = "[length]"
     , [m_mtoUpper]     = "[toUpper]"
@@ -501,6 +508,10 @@
             milprintf ("})");
             break;
 
+        case m_break:
+            milprintf ("break");
+            break;
+
         /* statement : 'var' Variable */
         case m_declare:
             milprintf ("var ");
@@ -698,6 +709,8 @@
         case m_ctrefine_rev:
         /* expression : expression '.CTderive (' expression ')' */
         case m_ctderive:
+        /* expression : expression '.texist (' expression ')' */
+        case m_texist:
         /* expression : expression '.insert (' expression ')' */
         case m_binsert:
         /* expression : expression '.append (' expression ')' */
@@ -808,6 +821,8 @@
         case m_mstring:
         /* expression : '[startsWith](' exp ',' exp)' */
         case m_mstarts_with:
+        /* expression : 'startsWith(' exp ',' exp)' */
+        case m_starts_with:
         /* expression : '[endsWith](' exp ',' exp)' */
         case m_mends_with:
         /* expression : '[pcre_match](' exp ',' exp)' */
@@ -832,6 +847,8 @@
         case m_mmax:
         /* expression : '>(' expression ',' expression ')' */
         case m_gt:
+        /* expression : '<=(' expression ',' expression ')' */
+        case m_le:
         /* expression : '=(' expression ',' expression ')' */
         case m_eq:
         /* expression : '[=](' expression ',' expression ')' */

U mil.c
Index: mil.c
===================================================================
RCS file: /cvsroot/monetdb/pathfinder/compiler/mil/mil.c,v
retrieving revision 1.49.2.10
retrieving revision 1.49.2.11
diff -u -d -r1.49.2.10 -r1.49.2.11
--- mil.c       22 May 2008 08:48:35 -0000      1.49.2.10
+++ mil.c       6 Jun 2008 14:25:40 -0000       1.49.2.11
@@ -474,6 +474,15 @@
 }
 
 /**
+ * MIL break statement
+ */
+PFmil_t *
+PFmil_break ()
+{
+    return leaf (m_break);
+}
+
+/**
  * Construct a combined variable declaration and its assignment.
  * (Declare variable @a v and assign result of @a e to it.)
  *
@@ -969,6 +978,15 @@
 }
 
 /**
+ * Monet texist function.
+ */
+PFmil_t *
+PFmil_texist (const PFmil_t *a, const PFmil_t *b)
+{
+    return wire2 (m_texist, a, b);
+}
+
+/**
  * enumerate operator, return sequence of integers
  * starting from @a a with the length @a l.
  */
@@ -1229,6 +1247,15 @@
 }
 
 /**
+ * less or equal operator
+ */
+PFmil_t *
+PFmil_le (const PFmil_t *a, const PFmil_t *b)
+{
+    return wire2 (m_le, a, b);
+}
+
+/**
  * Equal operator
  */
 PFmil_t *
@@ -1387,6 +1414,13 @@
     return wire3 (m_mstring2, a, b, c);
 }
 
+/** StartsWith() function `[startsWith](a,b)' */
+PFmil_t *
+PFmil_starts_with (const PFmil_t *a, const PFmil_t *b)
+{
+    return wire2 (m_starts_with, a, b);
+}
+
 /** Multiplexed startsWith() function `[startsWith](a,b)' */
 PFmil_t *
 PFmil_mstarts_with (const PFmil_t *a, const PFmil_t *b)

U milgen.brg
Index: milgen.brg
===================================================================
RCS file: /cvsroot/monetdb/pathfinder/compiler/mil/milgen.brg,v
retrieving revision 1.103.2.17
retrieving revision 1.103.2.18
diff -u -d -r1.103.2.17 -r1.103.2.18
--- milgen.brg  2 Jun 2008 20:28:24 -0000       1.103.2.17
+++ milgen.brg  6 Jun 2008 14:25:40 -0000       1.103.2.18
@@ -2483,7 +2483,7 @@
         {
             PFalg_simple_type_t ty;
             PFmil_create_ws_t create;
-            mvar_t *err, *time;
+            mvar_t *err, *time, *try = NULL;
             PFalg_att_t pa_item = p->sem.serialize.item;
             PFmil_t *oldmilprog, *bodymilprog;
 
@@ -2494,19 +2494,28 @@
             milprog = nop ();
 
             /* decide which type of new_ws should invoke */
-            if (aat_update & type_of (L(p), pa_item))
-                create = CREATE_UPDATE_WS;
-            /* FIXME: there is a second case when it is a retry of update
-             * we dont deal with this case right now because there is no loop
-             */   
-            else if (aat_docmgmt & type_of (L(p), pa_item))
-                create = CREATE_DOCMGM_WS;
-            else
-                create = CREATE_READ_ONLY_WS;
+            if (aat_update & type_of (L(p), pa_item)) {
+                try = new_var(1);
+                execute (
+                    comment ("volatile variable environment "
+                             "for an update query"),
+                    assgn (var (PF_MIL_VAR_WS), new_ws (var (try->name))),
+                    /* re-assign var(try) to be ready in case of a retry */
+                    assgn (var (try->name),
+                           add (var (try->name),
+                                lit_int(1))));
+            }
+            else {
+                if (aat_docmgmt & type_of (L(p), pa_item))
+                    create = CREATE_DOCMGM_WS;
+                else
+                    create = CREATE_READ_ONLY_WS;
+
+                execute (
+                    comment ("volatile variable environment"),
+                    assgn (var (PF_MIL_VAR_WS), new_ws (lit_int (create))));
+            }
 
-            execute (
-                comment ("volatile variable environment"),
-                assgn (var (PF_MIL_VAR_WS), new_ws (lit_int (create))));
             reduce (kids[0], nts[0]);
 
             /* add timing information */
@@ -2932,9 +2941,6 @@
                                          var (docmgmt->name)))))));
 
 #ifdef HAVE_PFTIJAH
-               /* INCOMPLETE, when the print is removed it is optimized out */
-               /* added m_tj_docmgmt_tape to the non removable expressions  */
-               /* in mil_dce() but now the system crashed with a fatal()    */
                 execute (
                        tj_docmgmt_tape (
                            var(PF_MIL_TIJAH_FTI_TAPE),
@@ -3437,14 +3443,40 @@
 
             err = new_var (1);
 
-            execute (
-                catch_ (var (err->name), bodymilprog),
-                if_ (not (isnil (var (PF_MIL_VAR_WS))),
-                     destroy_ws (var (PF_MIL_VAR_WS)),
-                     nop ()),
-                if_ (not (isnil (var (err->name))),
-                     error (var (err->name)),
-                     nop ()));
+            /* update queries should loop around until they succeed */
+            if (aat_update & type_of (L(p), pa_item)) {
+
+                execute (
+                    assgn (var (try->name), lit_int (CREATE_UPDATE_WS)),
+                    assgn (var (err->name),
+                           lit_str ("!ERROR: conflicting update")),
+                    while_ (and (le (var (try->name), lit_int(3)),
+                                 not (isnil (var (err->name)))),
+                            seq (if_ (not (starts_with (
+                                               var (err->name),
+                                               lit_str ("!ERROR: conflicting"
+                                                        " update"))),
+                                      break_(),
+                                      nop()),
+                                 catch_ (var (err->name), bodymilprog),
+                                 if_ (not (isnil (var (PF_MIL_VAR_WS))),
+                                      destroy_ws (var (PF_MIL_VAR_WS)),
+                                      nop ()))),
+                    if_ (not (isnil (var (err->name))),
+                         error (var (err->name)),
+                         nop ()));
+                
+                unpin (try, 1);
+            } else {
+                execute (
+                    catch_ (var (err->name), bodymilprog),
+                    if_ (not (isnil (var (PF_MIL_VAR_WS))),
+                         destroy_ws (var (PF_MIL_VAR_WS)),
+                         nop ()),
+                    if_ (not (isnil (var (err->name))),
+                         error (var (err->name)),
+                         nop ()));
+            }
 
             unpin (err, 1);
         }   break; /* fold) */
@@ -4796,31 +4828,42 @@
                                    VAR (L(p)->env, att3, aat_str))));
                 }   break; /* fold) */
                 case alg_fun_fn_replace: /* fold( */
+                case alg_fun_fn_replace_flag:
                 {
-                    PFalg_att_t att1, att2, att3;
+                    PFalg_att_t  att1, att2, att3;
+                    PFmil_t     *flags = NULL;
+                    mvar_t      *chk   = new_var (1);
 
                     att1 = p->sem.fun_1to1.refs.atts[0];
                     att2 = p->sem.fun_1to1.refs.atts[1];
                     att3 = p->sem.fun_1to1.refs.atts[2];
                     res_type = aat_str;
 
+                    switch (p->sem.fun_1to1.kind) {
+                        case alg_fun_fn_replace:
+                            flags = lit_str("");
+                            break;
+                        case alg_fun_fn_replace_flag:
+                            flags = VAR (L(p)->env,
+                                         p->sem.fun_1to1.refs.atts[3],
+                                         aat_str);
+                            break;
+                        default:
+                            assert(!"should never reach here"); break;
+                    }
+
+                    /* check whether the replacement
+                     * string contains variables */
                     execute (
-                        assgn (var (res->name),
-                               mpcre_replace (
-                                   VAR (L(p)->env, att1, aat_str),
-                                   VAR (L(p)->env, att2, aat_str),
-                                   VAR (L(p)->env, att3, aat_str),
-                                   lit_str(""))));
-                }   break; /* fold) */
-                case alg_fun_fn_replace_flag: /* fold( */
-                {
-                    PFalg_att_t att1, att2, att3, att4;
+                        assgn (var (chk->name),
+                               mpcre_match (VAR (L(p)->env, att3, aat_str),
+                                            lit_str("[$][0-9]"))),
+                        if_ (texist (var (chk->name), lit_bit(true)),
+                             error (lit_str ("Variables in replacements are "
+                                             "not supported yet")),
+                             nop ()));
 
-                    att1 = p->sem.fun_1to1.refs.atts[0];
-                    att2 = p->sem.fun_1to1.refs.atts[1];
-                    att3 = p->sem.fun_1to1.refs.atts[2];
-                    att4 = p->sem.fun_1to1.refs.atts[3];
-                    res_type = aat_str;
+                    unpin (chk, 1);
 
                     execute (
                         assgn (var (res->name),
@@ -4828,7 +4871,7 @@
                                    VAR (L(p)->env, att1, aat_str),
                                    VAR (L(p)->env, att2, aat_str),
                                    VAR (L(p)->env, att3, aat_str),
-                                   VAR (L(p)->env, att4, aat_str))));
+                                   flags)));
                 }   break; /* fold) */
                 case alg_fun_fn_name: /* fold( */
                 {
@@ -6960,11 +7003,34 @@
             assert (type_of (LL(p), L(p)->sem.ii.iter) == aat_nat);
             assert (type_of (LL(p), L(p)->sem.ii.item) == aat_str);
         {
-            mvar_t *seqb = new_var (1);
-            mvar_t *root_pre  = new_var (p->refctr);
-            mvar_t *root_frag = new_var (p->refctr);
-            mvar_t *iter = env_mvar (LL(p)->env, L(p)->sem.ii.iter, aat_nat);
-            PFmil_t *item = VAR (LL(p)->env, L(p)->sem.ii.item, aat_str);
+            mvar_t *seqb      = new_var (1),
+                   *root_pre  = new_var (p->refctr),
+                   *root_frag = new_var (p->refctr),
+                   *iter      = new_var (p->refctr),
+                   *item      = new_var (1),
+                   *map       = new_var (1);
+
+            /* prune all empty textnodes */
+            execute (
+                assgn (var (map->name),
+                       hmark (
+                           select_ (meq (VAR (LL(p)->env,
+                                              L(p)->sem.ii.item,
+                                              aat_str),
+                                         lit_str ("")),
+                                    lit_bit (false)),
+                           lit_oid (0))),
+                assgn (var (iter->name),
+                       leftjoin (var (map->name),
+                                 VAR (LL(p)->env,
+                                      L(p)->sem.ii.iter,
+                                      aat_nat))),
+                assgn (var (item->name),
+                       leftjoin (var (map->name),
+                                 VAR (LL(p)->env,
+                                      L(p)->sem.ii.item,
+                                      aat_str))));
+            unpin (map, 1);
 
             execute (
                 /* get first free pre value */
@@ -6992,28 +7058,30 @@
                                  var (PF_MIL_VAR_WS),
                                  var (PF_MIL_VAR_PRE_SIZE)),
                              var (PF_MIL_VAR_WS_CONT)),
-                         project (item, lit_int (0))),
+                         project (var (item->name), lit_int (0))),
                 /* level */
                 bappend (fetch (
                              fetch (
                                  var (PF_MIL_VAR_WS),
                                  var (PF_MIL_VAR_PRE_LEVEL)),
                              var (PF_MIL_VAR_WS_CONT)),
-                         project (item, cast (type (mty_chr), lit_int (0)))),
+                         project (var (item->name),
+                                  cast (type (mty_chr), lit_int (0)))),
                 /* kind */
                 bappend (fetch (
                              fetch (
                                  var (PF_MIL_VAR_WS),
                                  var (PF_MIL_VAR_PRE_KIND)),
                              var (PF_MIL_VAR_WS_CONT)),
-                         project (item, var (PF_MIL_VAR_KIND_TEXT))),
+                         project (var (item->name),
+                                  var (PF_MIL_VAR_KIND_TEXT))),
                 /* prop */
                 bappend (fetch (
                              fetch (
                                  var (PF_MIL_VAR_WS),
                                  var (PF_MIL_VAR_PRE_PROP)),
                              var (PF_MIL_VAR_WS_CONT)),
-                         add_content (item,
+                         add_content (var (item->name),
                                       var (PF_MIL_VAR_WS),
                                       var (PF_MIL_VAR_PROP_TEXT))),
                 /* cont */
@@ -7022,28 +7090,29 @@
                                  var (PF_MIL_VAR_WS),
                                  var (PF_MIL_VAR_PRE_CONT)),
                              var (PF_MIL_VAR_WS_CONT)),
-                         project (item, var (PF_MIL_VAR_WS_CONT))),
+                         project (var (item->name),
+                                  var (PF_MIL_VAR_WS_CONT))),
                 /* pre_nid */
                 bappend (fetch (
                              fetch (
                                  var (PF_MIL_VAR_WS),
                                  var (PF_MIL_VAR_PRE_NID)),
                              var (PF_MIL_VAR_WS_CONT)),
-                         mark (item, var (seqb->name))),
+                         mark (var (item->name), var (seqb->name))),
                 /* nid_rid */
                 bappend (fetch (
                              fetch (
                                  var (PF_MIL_VAR_WS),
                                  var (PF_MIL_VAR_NID_RID)),
                              var (PF_MIL_VAR_WS_CONT)),
-                         mark (item, var (seqb->name))),
+                         mark (var (item->name), var (seqb->name))),
 
                 /* new root pre values */
                 assgn (var (root_pre->name),
-                       mark (item, var (seqb->name))),
+                       mark (var (item->name), var (seqb->name))),
                 /* fragment information */
                 assgn (var (root_frag->name),
-                       project (item, var (PF_MIL_VAR_WS_CONT))),
+                       project (var (item->name), var (PF_MIL_VAR_WS_CONT))),
 
                 /* make the fragment boundaries known */
                 binsert (fetch (
@@ -7057,9 +7126,9 @@
                                  lit_oid (0)))));
 
             unpin (seqb, 1);
-            pin (iter, p->refctr);
-            env_add (p->env, p->sem.ii.iter, aat_nat,   iter);
-            env_add (p->env, p->sem.ii.item, aat_pre,   root_pre);
+            unpin (item, 1);
+            env_add (p->env, p->sem.ii.iter, aat_nat,  iter);
+            env_add (p->env, p->sem.ii.item, aat_pre,  root_pre);
             env_add (p->env, p->sem.ii.item, aat_frag, root_frag);
         }
             break; /* fold) */
@@ -9360,8 +9429,7 @@
 
     bodymilprog = milprog;
 
-    milprog = seq (module (lit_str ("pathfinder")),
-                   module (lit_str ("mkey")),
+    milprog = seq (
 #ifdef HAVE_PFTIJAH
                   /* create pftijah score db */
                   declare (var (PF_MIL_TIJAH_SCORE_DB)),

U mil_dce.c
Index: mil_dce.c
===================================================================
RCS file: /cvsroot/monetdb/pathfinder/compiler/mil/mil_dce.c,v
retrieving revision 1.18.2.2
retrieving revision 1.18.2.3
diff -u -d -r1.18.2.2 -r1.18.2.3
--- mil_dce.c   8 May 2008 07:45:29 -0000       1.18.2.2
+++ mil_dce.c   6 Jun 2008 14:25:40 -0000       1.18.2.3
@@ -440,6 +440,7 @@
         case m_destroy_ws:
         case m_error:
         case m_print:
+        case m_break:
         case m_update_tape:
         case m_docmgmt_tape:
 #ifdef HAVE_PFTIJAH


-------------------------------------------------------------------------
Check out the new SourceForge.net Marketplace.
It's the best place to buy or sell services for
just about anything Open Source.
http://sourceforge.net/services/buy/index.php
_______________________________________________
Monetdb-pf-checkins mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/monetdb-pf-checkins

Reply via email to