Changeset 3029 for src/pge

Timestamp:

05/12/05 04:01:26 (4 years ago)

Author:

autrijus

svk:copy_cache_prev:

4536

Message:

* sync up with PGE for character classes.

Location:

src/pge

Files:

• PGE.pir (modified) (1 diff)
• PGE/Exp.pir (modified) (3 diffs)
• PGE/P6Rule.pir (modified) (7 diffs)
• README (modified) (2 diffs)

src/pge/PGE.pir

@@ -18 +18 @@
 .sub "__onload" @LOAD
     .local pmc load
+    load_bytecode "Data/Escape.imc"
     load = find_global "PGE::TokenHash", "__onload"
     load()

src/pge/PGE/Exp.pir

@@ -15 +15 @@
     PGE::Dot       - match any character
     PGE::CCShortcut - character class shortcuts (\d, \D, \w, etc.)
+    PGE::CharClass - character classes (<[abcde]>, <-[abcde]>)
     PGE::WS        - <?ws> rule
     PGE::Anchor    - matching of ^, ^^, $, $$, \b, \B anchors
@@ -45 +46 @@
     $P0 = subclass expclass, "PGE::Exp::Dot"
     $P0 = subclass expclass, "PGE::Exp::CCShortcut"
+    $P0 = subclass expclass, "PGE::Exp::CharClass"
     $P0 = subclass expclass, "PGE::Exp::WS"
     $P0 = subclass expclass, "PGE::Exp::Anchor"
@@ -640 +642 @@
     emit(code, "  %s_f:", label)
     emit(code, "    goto fail")
+.end
+
+.namespace [ "PGE::Exp::CharClass" ]
+
+# Note:  The implementation interface for CharClass may change
+# in the near future, so don't rely on this too heavily just yet.
+# (pmichaud, 2005-05-11)
+
+.sub gen method
+    .param pmc code
+    .param string label
+    .param string next
+    .local string token
+    .local int min, max, isgreedy, iscut
+    .local pmc emit
+    .local string charclass, charmatch
+    (min, max, isgreedy, iscut) = self."_getattributes"()
+    emit = find_global "PGE::Exp", "emit"
+    $P0 = find_global "Data::Escape", "String"
+    charclass = self["charclass"]
+    charclass = $P0(charclass, '"')
+    charmatch = self["charmatch"]
+    emit(code, "\n  %s:", label)
+    emit(code, "    rep = 0")
+    unless isgreedy goto lazy
+    emit(code, "  %s_1:", label)
+    emit(code, "    if pos >= lastpos goto %s_2", label)
+    emit(code, "    if rep >= %d goto %s_2", max, label)
+    emit(code, "    $S0 = substr target, pos, 1")
+    emit(code, "    $I0 = index \"%s\", $S0", charclass)
+    emit(code, "    %s $I0 == -1 goto %s_2", charmatch, label)
+    emit(code, "    inc pos")
+    emit(code, "    inc rep")
+    emit(code, "    goto %s_1", label)
+    emit(code, "  %s_2:", label)
+    emit(code, "    if rep < %d goto fail", min)
+    unless iscut goto greedy_1
+    emit(code, "    goto %s", next)
+    .return ()
+  greedy_1:
+    emit(code, "    if rep == %d goto %s", min, next)
+    self.emitsub(code, next, "pos", "rep")
+    emit(code, "    dec pos")
+    emit(code, "    dec rep")
+    emit(code, "    goto %s_2", label)
+    .return ()
+  lazy:
+    emit(code, "  %s_0:", label)
+    emit(code, "    if rep < %d goto %s_1", min, label)
+    unless iscut goto lazy_1
+    emit(code, "    goto %s", next)
+    goto lazy_2
+  lazy_1:
+    emit(code, "    if rep >= %d goto %s", max, next)
+    emit(code, "    if pos > lastpos goto fail")
+    self.emitsub(code, next, "pos", "rep")
+  lazy_2:
+    emit(code, "  %s_1:", label)
+    emit(code, "    $S0 = substr target, pos, 1")
+    emit(code, "    $I0 = index \"%s\", pos")
+    emit(code, "    %s $I0 == -1 goto fail", charmatch)
+    emit(code, "    inc rep")
+    emit(code, "    inc pos")
+    emit(code, "    goto %s_0", label) 
 .end
 

src/pge/PGE/P6Rule.pir

@@ -67 +67 @@
     p6meta['$8'] = $P0
     p6meta['$9'] = $P0
-    $P0 = find_global "PGE::P6Rule", "p6rule_parse_subrule"      # XXX: TODO
+    $P0 = find_global "PGE::P6Rule", "p6rule_parse_subrule" 
     p6meta['<'] = $P0
     p6meta['>'] = u
-    $P0 = find_global "PGE::P6Rule", "p6rule_parse_charclass"
+    $P0 = find_global "PGE::P6Rule", "p6rule_parse_ccshortcut"
     p6meta['\d'] = $P0
     p6meta['\D'] = $P0
@@ -79 +79 @@
     p6meta['\n'] = $P0
     p6meta['\N'] = $P0
+    $P0 = find_global "PGE::P6Rule", "p6rule_parse_charclass"
+    p6meta['<['] = $P0
+    p6meta['<-['] = $P0
+    p6meta['<+['] = $P0
 .end
 
@@ -438 +442 @@
 
 
-=item C<p6rule_parse_charclass(STR pattern, PMC lex)>
+=item C<p6rule_parse_ccshortcut(STR pattern, PMC lex)>
 
 Parses a character class of some sort, including the \n, \N, \s, \S,
@@ -445 +449 @@
 =cut
 
-.sub p6rule_parse_charclass
+.sub p6rule_parse_ccshortcut
     .param string pattern
     .param pmc lex
@@ -455 +459 @@
     $I0 = length token
     p6rule_parse_skip(pattern, lex, $I0)
+    .return (exp)
+.end
+
+=item C<p6rule_parse_charclass(STR pattern, PMC lex, STR token)>
+
+Parse a character class in a rule expression.
+
+Note: The interface for PGE::Exp::CharClass may change in the
+near future, so don't rely on this code too strongly just yet.
+(pmichaud, 2005-05-11)
+
+=cut
+
+.sub p6rule_parse_charclass
+    .param string pattern
+    .param pmc lex
+    .param string token
+    .local int pos, plen
+    .local string charclass
+    .local int range
+    .local pmc exp
+    pos = lex["pos"]
+    plen = lex["plen"]
+    $I0 = length token
+    pos += $I0
+    charclass = ''
+    range = 0
+  scan:
+    if pos >= plen goto no_close_err
+    $S0 = substr pattern, pos, 1
+    if $S0 == ']' goto end_class
+    if $S0 == '-' goto unescaped_hyphen
+    if $S0 == '.' goto start_range
+    unless $S0 == '\\' goto add_char
+  backslash:
+    inc pos
+    $S0 = substr pattern, pos, 1
+    $I0 = index "nrtfae0", $S0
+    if $I0 == -1 goto add_char
+    $S0 = substr "\n\r\t\f\a\e\0", $I0, 1
+  add_char:
+    inc pos
+    if range goto add_range
+    concat charclass, $S0
+    goto scan
+  add_range:
+    range = 0
+    $I2 = ord charclass, -1
+    $I0 = ord $S0
+  add_range_1:
+    inc $I2
+    if $I2 > $I0 goto scan
+    $S1 = chr $I2
+    concat charclass, $S1
+    goto add_range_1
+  start_range:
+    if range goto add_range
+    $S1 = substr pattern, pos, 2
+    unless $S1 == ".." goto add_char
+    pos += 2
+    range = 1
+    goto scan
+  end_class:
+    $S0 = substr pattern, pos, 2
+    unless $S0 == "]>" goto unescaped_bracket
+    pos += 2
+    lex["pos"] = pos
+    p6rule_parse_skip(pattern, lex, 0)
+    $P0 = find_global "PGE::Exp", "new"
+    exp = $P0("PGE::Exp::CharClass")
+    exp["charclass"] = charclass
+    $S0 = substr token, 1, 1
+    if $S0 == "-" goto charclass_negate
+    exp["charmatch"] = "if"
+    goto end
+  charclass_negate:
+    exp["charmatch"] = "unless"
+    goto end
+  unescaped_hyphen:
+    p6rule_parse_error(pattern, lex, "Unescaped '-' in charclass (use '..' or '\\-')")
+    goto end
+  no_close_err:
+    p6rule_parse_error(pattern, lex, "No closing ']>' for character class")
+    goto end
+  unescaped_bracket:
+    p6rule_parse_error(pattern, lex, "Unescaped ']' in character class")
+    goto end
+  end:
     .return (exp)
 .end
@@ -543 +635 @@
   quant:                                           # qexp is the atom to quant
   quant_quest:
-    if c != '?' goto quant_plus
+    if c != "?" goto quant_plus
     pos = "p6rule_parse_skip"(pattern, lex, 1)
     qexp["min"] = 0
     goto quant_greedy
   quant_plus:
-    if c != '+' goto quant_star
+    if c != "+" goto quant_star
     pos = "p6rule_parse_skip"(pattern, lex, 1)
     qexp["max"] = PGE_INF
@@ -554 +646 @@
     goto quant_greedy
   quant_star:
-    if c != '*' goto quant_greedy
+    if c != "*" goto quant_greedy
     pos = "p6rule_parse_skip"(pattern, lex, 1)
     c = substr pattern, pos, 1

src/pge/README

@@ -43 +43 @@
 the load_bytecode operation, as in
 
-    load_bytecode "runtime/parrot/library/PGE.pbc"          
+    load_bytecode "PGE.pbc"          
 
 This imports the C<PGE::p6rule> subroutine, which can be used to
@@ -94 +94 @@
 
 PGE doesn't (yet) properly handle nested repetitions of zero-length 
-patterns in groups -- that's coming next.
+patterns in groups -- that's coming soon.
 
 This is just the first-cut framework for building the 
 remainder of the engine, so many items (lookaround, 
-conjunctions, closures, character classes, and hypotheticals)
+conjunctions, closures, and hypotheticals)
 just aren't implemented yet.  They're on their way!