Changeset 2564

Timestamp:

12/06/07 13:17:11 (5 years ago)

Author:

tasuku

Message:

r292@dhcp158 (orig r35): tasuku | 2007-09-11 15:43:49 +0900
spos pass

Files:

• lang/php/mumu/trunk/mumu.php (modified) (22 diffs)

lang/php/mumu/trunk/mumu.php

@@ -63 +63 @@
 // block.super         : �ƥƥ�졼�Ȥ�lock��������������ä���������
 
-// ����/ find_endtags�ϸ��Ĥ����parse�⤷�ơ�$sposư�����Ƥ⤤���󤸤�����
-// FIXME�����褦�ˡ�
+// ����/ FIXME�����褦�ˡ�
 // �������嵡���Ȥ�������͡��ѡ����Ѥߤι�¤�򥷥ꥢ�饤�����롩
 
@@ -149 +148 @@
 class MuErrorNode extends MuNode {
   private $errorCode;
+  private $filename;
+  private $linenumber;
   // TODO: php5 don't support array as const
   private static $errorMsg = array(
@@ -177 +178 @@
     'unknown' => 'Unknown error. Maybe bugs in MuMu'
   );
-  function __construct($errorCode) {
+  function __construct($errorCode, $filename, $linenumber) {
     if (array_key_exists($errorCode, self::$errorMsg)) {
       $this->errorCode = $errorCode;
@@ -183 +184 @@
       $this->errorCode = 'unknown';
     }
+    $this->filename = $filename;
+    $this->linenumber = $linenumber;
   }
   public function _render($context) {
-    return self::$errorMsg[$this->errorCode];
+    return 'file: '. $this->filename .' line: '. $this->linenumber .' '.
+           self::$errorMsg[$this->errorCode];
   }
 }
@@ -198 +202 @@
     if ($parentPath) {
       if (($this->parent_tfile = MuParser::parse_from_file($parentPath)) === FALSE) {
-        // TODO: ���顼���������ƥ�졼�������˶����Ƥ�����       return new MuErrorNode('invalidfilename_extends');
+        // TODO: ���顼���������ƥ�졼�������˶����Ƥ�����       return $this->make_errornode('invalidfilename_extends');
       }
     }
@@ -267 +271 @@
     // FIXME: �������ƥ�����å���̵�¥롼�ץ���å�
     if (($this->tplfile = MuParser::parse_from_file($includePath)) === FALSE) {
-      // TODO: ���顼���������ƥ�졼�������˶����Ƥ�����     $this->tplfile = new MuErrorNode('invalidfilename_include');
+      // TODO: ���顼���������ƥ�졼�������˶����Ƥ�����     $this->tplfile = $this->make_errornode('invalidfilename_include');
     }
   }
@@ -536 +540 @@
 class MuParser {
   private $template;             // �ѡ�����Υƥ�졼����� private $template_len;         // �ƥ�졼�����Ĺ��
+  public $templatePath;         // �ƥ�졼�ȤΥѥ�(����)
   private $block_dict = array(); // block���� => block�ؤλ���  private $extends = false;      // extends�ξ��Υե�����
-
+  private $spos = 0;             // ���ߥѡ�����ΰ��
   # template syntax constants
   const FILTER_SEPARATOR = '|';
@@ -656 +661 @@
 
   // ��λ����(#}�Ȥ�)����ơ����ΰ�֤��
-  private function find_closetag($spos, $closetag) {
-    if (($fpos = strpos($this->template, $closetag, $spos)) === FALSE) {
+  private function find_closetag($closetag) {
+    if (($fpos = strpos($this->template, $closetag, $this->spos)) === FALSE) {
       return FALSE;
     }
     return $fpos;
+  }
+
+  private function make_errornode($errorCode) {
+    // from $spos to linenumber
+    // TODO: count on parsing
+    $c = substr($this->template, 0, $this->spos);
+    $ln = 0;
+    for ($i = 0; $i < $this->spos; $i++) {
+      switch ($c[$i]) {
+        case "\r":
+          if ($c[$i + 1] == "\n") {
+            $i++;
+          }
+          $ln++;
+          break;
+        case "\n":
+          $ln++;
+          break;
+      }
+    }
+    return new MuErrorNode($errorCode, $this->templatePath, $ln);
   }
 
   // {% %}�����������ơ�MuNode�����
   // extends����˽񤫤ʤ��Ȥ����ʤ�
-  private function parse_block(&$spos) {
-    $spos += 2;
-    if (($lpos = $this->find_closetag($spos, self::BLOCK_TAG_END)) === FALSE) {
-      return new MuErrorNode('without_closetag_tag');
-    }
-    $in = $this->smart_split(substr($this->template, $spos, $lpos - $spos));
+  private function parse_block() {
+    $this->spos += 2;
+    if (($lpos = $this->find_closetag(self::BLOCK_TAG_END)) === FALSE) {
+      return $this->make_errornode('without_closetag_tag');
+    }
+    $in = $this->smart_split(substr($this->template, $this->spos, $lpos - $this->spos));
     switch ($in[0]) {
       // TODO: ���������      case 'extends':
         if ($this->extends !== FALSE) {
-          return new MuErrorNode('multiple_extends_tag');
+          return $this->make_errornode('multiple_extends_tag');
         }
         if (count($in) != 2) {
-          return new MuErrorNode('numofparam_extends_tag');
+          return $this->make_errornode('numofparam_extends_tag');
         }
         $param = explode('"', $in[1]);
         if (count($param) != 3) {
-          // Django��ѿ�K����ɤ�          return new MuErrorNode('invalidparam_extends_tag');
+          // Django��ѿ�K����ɤ�          return $this->make_errornode('invalidparam_extends_tag');
         }
         $this->extends = $param[1];
-        $spos = $lpos + 2;
+        $this->spos = $lpos + 2;
         break;
       case 'include':
         if (count($in) != 2) {
-          return new MuErrorNode('numofparam_include_tag');
+          return $this->make_errornode('numofparam_include_tag');
         }
         $param = explode('"', $in[1]);
         if (count($param) != 3) {
-          // Django��ѿ�K����ɤ�          return new MuErrorNode('invalidparam_include_tag');
+          // Django��ѿ�K����ɤ�          return $this->make_errornode('invalidparam_include_tag');
         }
         $node = new MuIncludeNode($param[1]);
-        $spos = $lpos + 2;
+        $this->spos = $lpos + 2;
         break;
       case 'block': // endblock
@@ -702 +728 @@
         $blockname = $in[1];
         if (array_key_exists($blockname, $this->block_dict)) {
-          return new MuErrorNode('multiple_block_tag');
-        }
-        $spos = $lpos + 2;
-        list($nodelist) = $this->_parse($spos, array('endblock'));
+          return $this->make_errornode('multiple_block_tag');
+        }
+        $this->spos = $lpos + 2;
+        list($nodelist) = $this->_parse(array('endblock'));
         $node = new MuBlockNode($blockname, $nodelist);
         $this->block_dict[$blockname] = $node;
@@ -712 +738 @@
         // $in[1] = $loopvar, $in[2] = 'in', $in[3] = $sequence, $in[4] = 'reversed'
         if ((count($in) != 4 && count($in) != 5) || $in[2] != 'in') {
-          return new MuErrorNode('numofparam_for_tag');
+          return $this->make_errornode('numofparam_for_tag');
         }
         if (count($in) == 5) {
@@ -718 +744 @@
             $reversed = True;
           } else {
-            return new MuErrorNode('invalidparam_for_tag');
+            return $this->make_errornode('invalidparam_for_tag');
           }
         } else {
           $reversed = False;
         }
-        $spos = $lpos + 2;
-        list($nodelist) = $this->_parse($spos, array('endfor'));
+        $this->spos = $lpos + 2;
+        list($nodelist) = $this->_parse(array('endfor'));
         $node = new MuForNode($in[1], $in[3], $reversed, $nodelist);
         break;
@@ -730 +756 @@
         // TODO: implement namedCycleNodes
         if (count($in) != 2) {
-          return new MuErrorNode('numofparam_cycle_tag');
+          return $this->make_errornode('numofparam_cycle_tag');
         }
         $cyclevars = explode(',', $in[1]);
         if (count($cyclevars) == 0) {
-          return new MuErrorNode('invalidparam_cycle_tag');
+          return $this->make_errornode('invalidparam_cycle_tag');
         }
         $node = new MuCycleNode($cyclevars);
-        $spos = $lpos + 2;
+        $this->spos = $lpos + 2;
         break;
       case 'if': // else, endif
         array_shift($in);
         if (count($in) < 1) {
-          return new MuErrorNode('numofparam_if_tag');
+          return $this->make_errornode('numofparam_if_tag');
         }
         $bitstr = implode(' ', $in);
@@ -753 +779 @@
           $link_type = MuIfNode::LINKTYPE_AND;
           if (in_array(' or ', $bitstr)) {
-            return new MuErrorNode('andormixed_if_tag');
+            return $this->make_errornode('andormixed_if_tag');
           }
         }
@@ -762 +788 @@
             list($not, $boolvar) = explode(' ', $boolpair);
             if ($not != 'not') {
-              return new MuErrorNode('invalidparam_if_tag');
+              return $this->make_errornode('invalidparam_if_tag');
             }
             array_push($boolvars, array(True, $boolvar));
@@ -769 +795 @@
           }
         }
-        $spos = $lpos + 2;
+        $this->spos = $lpos + 2;
         list($nodelist_true, $nexttag) =
-          $this->_parse($spos, array('else', 'endif'));
+          $this->_parse(array('else', 'endif'));
         if ($nexttag == 'else') {
-          list($nodelist_false) = $this->_parse($spos, array('endif'));
+          list($nodelist_false) = $this->_parse(array('endif'));
         } else {
           $nodelist_false = new MuNodeList();
@@ -781 +807 @@
       case 'debug':
         $node = new MuDebugNode();
-        $spos = $lpos + 2;
+        $this->spos = $lpos + 2;
         break;
       case 'now':
         if (count($in) != 2) {
-          return new MuErrorNode('numofparam_now_tag');
+          return $this->make_errornode('numofparam_now_tag');
         }
         $param = explode('"', $in[1]);
         if (count($param) != 3) {
-          return new MuErrorNode('invalidparam_now_tag');
+          return $this->make_errornode('invalidparam_now_tag');
         }
         $node = new MuNowNode($param[1]);
-        $spos = $lpos + 2;
+        $this->spos = $lpos + 2;
         break;
       case 'filter': // endfilter
         if (count($in) != 2) {
-          return new MuErrorNode('numofparam_filter_tag');
-        }
-        $spos = $lpos + 2;
+          return $this->make_errornode('numofparam_filter_tag');
+        }
+        $this->spos = $lpos + 2;
         if (($filter_expr = new MuFilterExpression('var|'. $in[1])) === FALSE) {
-          return new MuErrorNode('invalidparam_filter_tag');
-        }
-        list($nodelist) = $this->_parse($spos, array('endfilter'));
+          return $this->make_errornode('invalidparam_filter_tag');
+        }
+        list($nodelist) = $this->_parse(array('endfilter'));
         $node = new MuFilterNode($filter_expr, $nodelist);
         break;
@@ -811 +837 @@
       case 'endfilter':
         $node = $in[0]; // raw string
-        $spos = $lpos + 2;
+        $this->spos = $lpos + 2;
         break;
       default:
-        $node = new MuErrorNode('unknown_tag');
-        echo $in[0];
-        $spos = $lpos + 2;
+        $node = $this->make_errornode('unknown_tag');
+        $this->spos = $lpos + 2;
         break;
     }
@@ -822 +847 @@
   }
 
-  private function parse_variable(&$spos) {
-    $spos += 2;
-    if (($lpos = $this->find_closetag($spos, self::VARIABLE_TAG_END)) === FALSE) {
+  private function parse_variable() {
+    $this->spos += 2;
+    if (($lpos = $this->find_closetag(self::VARIABLE_TAG_END)) === FALSE) {
+      echo "uhyohyo\n";
       return FALSE;
     }
     // TODO: handle empty {{ }}
     if (($fil = new MuFilterExpression(
-                  substr($this->template, $spos, $lpos - $spos))) === FALSE) {
-      return new MuErrorNode('invalidparam_filter_variable');
+                  substr($this->template, $this->spos, $lpos - $this->spos))) === FALSE) {
+      return $this->make_errornode('invalidparam_filter_variable');
     }
     $node = new MuVariableNode($fil);
-    $spos = $lpos + 2;
+    $this->spos = $lpos + 2;
     return $node;
   }
 
-  private function parse_comment(&$spos) {
-    $spos += 2;
-    if (($lpos = $this->find_closetag($spos, self::COMMENT_TAG_END)) === FALSE) {
+  private function parse_comment() {
+    $this->spos += 2;
+    if (($lpos = $this->find_closetag(self::COMMENT_TAG_END)) === FALSE) {
       return FALSE;
     }
-    $spos = $lpos + 2;
+    $this->spos = $lpos + 2;
   }
 
@@ -850 +876 @@
     }
     $p = new MuParser($t);
-    $spos = 0;
-    list($nl) = $p->_parse($spos, array());
+    $p->templatePath = $templatePath;
+    list($nl) = $p->_parse(array());
     return new MuFile($nl, $p->block_dict, $p->extends);
   }
@@ -857 +883 @@
   static public function parse($templateStr) {
     $p = new MuParser($templateStr);
-    $spos = 0;
-    list($nl) = $p->_parse($spos, array());
+    list($nl) = $p->_parse(array());
     return new MuFile($nl, $p->block_dict);
   }
@@ -869 +894 @@
   }
 
-  private function _parse(&$spos, $parse_until) {
+  private function _parse($parse_until) {
     $nl = new MuNodeList();
-    $tspos = $spos;
+    $tspos = $this->spos;
     while (true) {
-      $spos = strpos($this->template, self::SINGLE_BRACE_START, $spos);
-      if ($spos === FALSE) {
+      $this->spos = strpos($this->template, self::SINGLE_BRACE_START, $this->spos);
+      if ($this->spos === FALSE) {
+        $this->spos = $this->template_len;
         $this->add_textnode($nl, $tspos, $this->template_len);
         return array($nl, null);
       }
-      switch (substr($this->template, $spos, 2)) {
+      switch (substr($this->template, $this->spos, 2)) {
         case self::BLOCK_TAG_START:
-          $this->add_textnode($nl, $tspos, $spos);
-          if (($node = $this->parse_block($spos)) === FALSE) {
+          $this->add_textnode($nl, $tspos, $this->spos);
+          if (($node = $this->parse_block()) === FALSE) {
             return FALSE;
           }
-          $tspos = $spos;
+          $tspos = $this->spos;
           if (is_string($node)) {
             // close tag
@@ -897 +923 @@
           break;
         case self::VARIABLE_TAG_START:
-          $this->add_textnode($nl, $tspos, $spos);
-          if (($node = $this->parse_variable($spos)) === FALSE) {
+          $this->add_textnode($nl, $tspos, $this->spos);
+          if (($node = $this->parse_variable()) === FALSE) {
             return FALSE;
           }
           $nl->push($node);
-          $tspos = $spos;
+          $tspos = $this->spos;
           break;
         case self::COMMENT_TAG_START:
-          $this->add_textnode($nl, $tspos, $spos);
-          if (($node = $this->parse_comment($spos)) === FALSE) {
+          $this->add_textnode($nl, $tspos, $this->spos);
+          if (($node = $this->parse_comment()) === FALSE) {
             return FALSE;
           }
           $nl->push($node);
-          $tspos = $spos;
+          $tspos = $this->spos;
           break;
         default:
           // { only
-          $spos += 1;
+          $this->spos += 1;
       }
     }