hpricot 0.6-jruby

data/ext/hpricot_scan/hpricot_scan.h

@@ -0,0 +1,79 @@
+/*
+ * hpricot_scan.h
+ *
+ * $Author: why $
+ * $Date: 2006-05-08 22:03:50 -0600 (Mon, 08 May 2006) $
+ *
+ * Copyright (C) 2006 why the lucky stiff
+ * You can redistribute it and/or modify it under the same terms as Ruby.
+ */
+
+#ifndef hpricot_scan_h
+#define hpricot_scan_h
+
+#include <sys/types.h>
+
+#if defined(_WIN32)
+#include <stddef.h>
+#endif
+
+/*
+ * Memory Allocation
+ */
+#if defined(HAVE_ALLOCA_H) && !defined(__GNUC__)
+#include <alloca.h>
+#endif
+
+#ifndef NULL
+# define NULL (void *)0
+#endif
+
+#define BUFSIZE 16384
+
+#define S_ALLOC_N(type,n) (type*)malloc(sizeof(type)*(n))
+#define S_ALLOC(type) (type*)malloc(sizeof(type))
+#define S_REALLOC_N(var,type,n) (var)=(type*)realloc((char*)(var),sizeof(type)*(n))
+#define S_FREE(n) free(n); n = NULL;
+
+#define S_ALLOCA_N(type,n) (type*)alloca(sizeof(type)*(n))
+
+#define S_MEMZERO(p,type,n) memset((p), 0, sizeof(type)*(n))
+#define S_MEMCPY(p1,p2,type,n) memcpy((p1), (p2), sizeof(type)*(n))
+#define S_MEMMOVE(p1,p2,type,n) memmove((p1), (p2), sizeof(type)*(n))
+#define S_MEMCMP(p1,p2,type,n) memcmp((p1), (p2), sizeof(type)*(n))
+
+typedef struct {
+  void *name;
+  void *attributes;
+} hpricot_element;
+
+typedef void (*hpricot_element_cb)(void *data, hpricot_element *token);
+
+typedef struct hpricot_scan {
+  int lineno;
+  int cs;
+  size_t nread;
+  size_t mark;
+
+  void *data;
+
+  hpricot_element_cb xmldecl;
+  hpricot_element_cb doctype;
+  hpricot_element_cb xmlprocins;
+  hpricot_element_cb starttag;
+  hpricot_element_cb endtag;
+  hpricot_element_cb emptytag;
+  hpricot_element_cb comment;
+  hpricot_element_cb cdata;
+
+} http_scan;
+
+// int hpricot_scan_init(hpricot_scan *scan);
+// int hpricot_scan_finish(hpricot_scan *scan);
+// size_t hpricot_scan_execute(hpricot_scan *scan, const char *data, size_t len, size_t off);
+// int hpricot_scan_has_error(hpricot_scan *scan);
+// int hpricot_scan_is_finished(hpricot_scan *scan);
+// 
+// #define hpricot_scan_nread(scan) (scan)->nread 
+
+#endif

data/ext/hpricot_scan/hpricot_scan.java.rl

@@ -0,0 +1,363 @@
+
+import java.io.IOException;
+
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyHash;
+import org.jruby.RubyModule;
+import org.jruby.RubyNumeric;
+import org.jruby.RubyString;
+import org.jruby.runtime.Block;
+import org.jruby.runtime.CallbackFactory;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.exceptions.RaiseException;
+import org.jruby.runtime.load.BasicLibraryService;
+
+public class HpricotScanService implements BasicLibraryService {
+       public static String NO_WAY_SERIOUSLY="*** This should not happen, please send a bug report with the HTML you're parsing to why@whytheluckystiff.net.  So sorry!";
+
+       public void ELE(IRubyObject N) {
+         if (tokend > tokstart || text) {
+           IRubyObject raw_string = runtime.getNil();
+           ele_open = false; text = false;
+           if (tokstart != -1 && N != cdata && N != sym_text && N != procins && N != comment) { 
+             raw_string = runtime.newString(new String(buf,tokstart,tokend-tokstart));
+           } 
+           rb_yield_tokens(N, tag[0], attr, raw_string, taint);
+         }
+       }
+
+       public void SET(IRubyObject[] N, int E) {
+         int mark = 0;
+         if(N == tag) { 
+           if(mark_tag == -1 || E == mark_tag) {
+             tag[0] = runtime.newString("");
+           } else if(E > mark_tag) {
+             tag[0] = runtime.newString(new String(buf,mark_tag, E-mark_tag));
+           }
+         } else if(N == akey) {
+           if(mark_akey == -1 || E == mark_akey) {
+             akey[0] = runtime.newString("");
+           } else if(E > mark_akey) {
+             akey[0] = runtime.newString(new String(buf,mark_akey, E-mark_akey));
+           }
+         } else if(N == aval) {
+           if(mark_aval == -1 || E == mark_aval) {
+             aval[0] = runtime.newString("");
+           } else if(E > mark_aval) {
+             aval[0] = runtime.newString(new String(buf,mark_aval, E-mark_aval));
+           }
+         }
+       }
+
+       public void CAT(IRubyObject[] N, int E) {
+         if(N[0].isNil()) {
+           SET(N,E);
+         } else {
+           int mark = 0;
+           if(N == tag) {
+             mark = mark_tag;
+           } else if(N == akey) {
+             mark = mark_akey;
+           } else if(N == aval) {
+             mark = mark_aval;
+           }
+           ((RubyString)(N[0])).append(runtime.newString(new String(buf, mark, E-mark)));
+         }
+       }
+
+       public void SLIDE(Object N) {
+           int mark = 0;
+           if(N == tag) {
+             mark = mark_tag;
+           } else if(N == akey) {
+             mark = mark_akey;
+           } else if(N == aval) {
+             mark = mark_aval;
+           }
+           if(mark > tokstart) {
+             if(N == tag) {
+               mark_tag  -= tokstart;
+             } else if(N == akey) {
+               mark_akey -= tokstart;
+             } else if(N == aval) {
+               mark_aval -= tokstart;
+             }
+           }
+       }
+
+       public void ATTR(IRubyObject K, IRubyObject V) {
+         if(!K.isNil()) {
+           if(attr.isNil()) {
+             attr = RubyHash.newHash(runtime);
+           }
+           ((RubyHash)attr).aset(K,V);
+         }
+       }
+
+       public void ATTR(IRubyObject[] K, IRubyObject V) {
+         ATTR(K[0],V);
+       }
+
+       public void ATTR(IRubyObject K, IRubyObject[] V) {
+         ATTR(K,V[0]);
+       }
+
+       public void ATTR(IRubyObject[] K, IRubyObject[] V) {
+         ATTR(K[0],V[0]);
+       }
+
+       public void TEXT_PASS() {
+         if(!text) { 
+           if(ele_open) { 
+             ele_open = false; 
+             if(tokstart > -1) { 
+               mark_tag = tokstart; 
+             } 
+           } else {
+             mark_tag = p; 
+           } 
+           attr = runtime.getNil(); 
+           tag[0] = runtime.getNil(); 
+           text = true; 
+         }
+       }
+
+       public void EBLK(IRubyObject N, int T) {
+         CAT(tag, p - T + 1);
+         ELE(N);
+       }
+
+
+       public void rb_raise(RubyClass error, String message) {
+              throw new RaiseException(runtime, error, message, true);
+       }
+
+       public IRubyObject rb_str_new2(String s) {
+              return runtime.newString(s);
+       }
+
+%%{
+  machine hpricot_scan;
+
+  action newEle {
+    if (text) {
+      CAT(tag, p);
+      ELE(sym_text);
+      text = false;
+    }
+    attr = runtime.getNil();
+    tag[0] = runtime.getNil();
+    mark_tag = -1;
+    ele_open = true;
+  }
+
+  action _tag { mark_tag = p; }
+  action _aval { mark_aval = p; }
+  action _akey { mark_akey = p; }
+  action tag { SET(tag, p); }
+  action tagc { SET(tag, p-1); }
+  action aval { SET(aval, p); }
+  action aunq { 
+    if (buf[p-1] == '"' || buf[p-1] == '\'') { SET(aval, p-1); }
+    else { SET(aval, p); }
+  }
+  action akey { SET(akey, p); }
+  action xmlver { SET(aval, p); ATTR(rb_str_new2("version"), aval); }
+  action xmlenc { SET(aval, p); ATTR(rb_str_new2("encoding"), aval); }
+  action xmlsd  { SET(aval, p); ATTR(rb_str_new2("standalone"), aval); }
+  action pubid  { SET(aval, p); ATTR(rb_str_new2("public_id"), aval); }
+  action sysid  { SET(aval, p); ATTR(rb_str_new2("system_id"), aval); }
+
+  action new_attr { 
+    akey[0] = runtime.getNil();
+    aval[0] = runtime.getNil();
+    mark_akey = -1;
+    mark_aval = -1;
+  }
+
+  action save_attr { 
+    ATTR(akey, aval);
+  }
+
+  include hpricot_common "ext/hpricot_scan/hpricot_common.rl";
+
+}%%
+
+%% write data nofinal;
+
+public final static int BUFSIZE=16384;
+
+private void rb_yield_tokens(IRubyObject sym, IRubyObject tag, IRubyObject attr, IRubyObject raw, boolean taint) {
+  IRubyObject ary;
+  if (sym == runtime.newSymbol("text")) {
+    raw = tag;
+  }
+  ary = runtime.newArray(new IRubyObject[]{sym, tag, attr, raw});
+  if (taint) { 
+    ary.setTaint(true);
+    tag.setTaint(true);
+    attr.setTaint(true);
+    raw.setTaint(true);
+  }
+  block.yield(runtime.getCurrentContext(), ary, null, null, false);
+}
+
+
+int cs, act, have = 0, nread = 0, curline = 1, p=-1;
+boolean text = false;
+int tokstart=-1, tokend;
+char[] buf;
+Ruby runtime;
+IRubyObject attr, bufsize;
+IRubyObject[] tag, akey, aval;
+int mark_tag, mark_akey, mark_aval;
+boolean done = false, ele_open = false;
+int buffer_size = 0;        
+boolean taint = false;
+Block block = null;
+
+
+IRubyObject xmldecl, doctype, procins, stag, etag, emptytag, comment,
+      cdata, sym_text;
+
+IRubyObject hpricot_scan(IRubyObject recv, IRubyObject port) {
+  attr = bufsize = runtime.getNil();
+  tag = new IRubyObject[]{runtime.getNil()};
+  akey = new IRubyObject[]{runtime.getNil()};
+  aval = new IRubyObject[]{runtime.getNil()};
+
+  RubyClass rb_eHpricotParseError = runtime.getModule("Hpricot").getClass("ParseError");
+
+  taint = port.isTaint();
+  if ( !port.respondsTo("read")) {
+    if ( port.respondsTo("to_str")) {
+      port = port.callMethod(runtime.getCurrentContext(),"to_str");
+    } else {
+      throw runtime.newArgumentError("bad Hpricot argument, String or IO only please.");
+    }
+  }
+
+  buffer_size = BUFSIZE;
+  if (recv.getInstanceVariable("@buffer_size") != null) {
+    bufsize = recv.getInstanceVariable("@buffer_size");
+    if (!bufsize.isNil()) {
+      buffer_size = RubyNumeric.fix2int(bufsize);
+    }
+  }
+  buf = new char[buffer_size];
+
+  %% write init;
+
+  while( !done ) {
+    IRubyObject str;
+    p = have;
+    int pe;
+    int len, space = buffer_size - have;
+
+    if ( space == 0 ) {
+      /* We've used up the entire buffer storing an already-parsed token
+       * prefix that must be preserved.  Likely caused by super-long attributes.
+       * See ticket #13. */
+      rb_raise(rb_eHpricotParseError, "ran out of buffer space on element <" + tag.toString() + ">, starting on line "+curline+".");
+    }
+
+    if (port.respondsTo("read")) {
+      str = port.callMethod(runtime.getCurrentContext(),"read",runtime.newFixnum(space));
+    } else {
+      str = ((RubyString)port).substr(nread,space);
+    }
+
+    str = str.convertToString();
+    String sss = str.toString();
+    char[] chars = sss.toCharArray();
+    System.arraycopy(chars,0,buf,p,chars.length);
+
+    len = sss.length();
+    nread += len;
+
+    if ( len < space ) {
+      len++;
+      done = true;
+    }
+
+    pe = p + len;
+    char[] data = buf;
+
+    %% write exec;
+    
+    if ( cs == hpricot_scan_error ) {
+      if(!tag[0].isNil()) {
+        rb_raise(rb_eHpricotParseError, "parse error on element <"+tag.toString()+">, starting on line "+curline+".\n" + NO_WAY_SERIOUSLY);
+      } else {
+        rb_raise(rb_eHpricotParseError, "parse error on line "+curline+".\n" + NO_WAY_SERIOUSLY);
+      }
+    }
+    
+    if ( done && ele_open ) {
+      ele_open = false;
+      if(tokstart > -1) {
+        mark_tag = tokstart;
+        tokstart = -1;
+        text = true;
+      }
+    }
+
+    if(tokstart == -1) {
+      have = 0;
+      /* text nodes have no tokstart because each byte is parsed alone */
+      if(mark_tag != -1 && text) {
+        if (done) {
+          if(mark_tag < p-1) {
+            CAT(tag, p-1);
+            ELE(sym_text);
+          }
+        } else {
+          CAT(tag, p);
+        }
+      }
+      mark_tag = 0;
+    } else {
+      have = pe - tokstart;
+      System.arraycopy(buf,tokstart,buf,0,have);
+      SLIDE(tag);
+      SLIDE(akey);
+      SLIDE(aval);
+      tokend = (tokend - tokstart);
+      tokstart = 0;
+    }
+  }
+  return runtime.getNil();
+}
+
+public static IRubyObject __hpricot_scan(IRubyObject recv, IRubyObject port, Block block) {
+  Ruby runtime = recv.getRuntime();
+  HpricotScanService service = new HpricotScanService();
+  service.runtime = runtime;
+  service.xmldecl = runtime.newSymbol("xmldecl");
+  service.doctype = runtime.newSymbol("doctype");
+  service.procins = runtime.newSymbol("procins");
+  service.stag = runtime.newSymbol("stag");
+  service.etag = runtime.newSymbol("etag");
+  service.emptytag = runtime.newSymbol("emptytag");
+  service.comment = runtime.newSymbol("comment");
+  service.cdata = runtime.newSymbol("cdata");
+  service.sym_text = runtime.newSymbol("text");
+  service.block = block;
+  return service.hpricot_scan(recv, port);
+}
+
+
+public boolean basicLoad(final Ruby runtime) throws IOException {
+       Init_hpricot_scan(runtime);
+       return true;
+}
+
+public static void Init_hpricot_scan(Ruby runtime) {
+  RubyModule mHpricot = runtime.defineModule("Hpricot");
+  mHpricot.getMetaClass().attr_accessor(new IRubyObject[]{runtime.newSymbol("buffer_size")});
+  CallbackFactory fact = runtime.callbackFactory(HpricotScanService.class);
+  mHpricot.getMetaClass().defineMethod("scan",fact.getSingletonMethod("__hpricot_scan",IRubyObject.class));
+  mHpricot.defineClassUnder("ParseError",runtime.getClass("Exception"),runtime.getClass("Exception").getAllocator());
+}
+}

data/ext/hpricot_scan/hpricot_scan.rl

@@ -0,0 +1,273 @@
+/*
+ * hpricot_scan.rl
+ *
+ * $Author: why $
+ * $Date: 2006-05-08 22:03:50 -0600 (Mon, 08 May 2006) $
+ *
+ * Copyright (C) 2006 why the lucky stiff
+ */
+#include <ruby.h>
+
+#define NO_WAY_SERIOUSLY "*** This should not happen, please send a bug report with the HTML you're parsing to why@whytheluckystiff.net.  So sorry!"
+
+static VALUE sym_xmldecl, sym_doctype, sym_procins, sym_stag, sym_etag, sym_emptytag, sym_comment,
+      sym_cdata, sym_text;
+static VALUE rb_eHpricotParseError;
+static ID s_read, s_to_str;
+
+#define ELE(N) \
+  if (tokend > tokstart || text == 1) { \
+    VALUE raw_string = Qnil; \
+    ele_open = 0; text = 0; \
+    if (tokstart != 0 && sym_##N != sym_cdata && sym_##N != sym_text && sym_##N != sym_procins && sym_##N != sym_comment) { \
+      raw_string = rb_str_new(tokstart, tokend-tokstart); \
+    } \
+    rb_yield_tokens(sym_##N, tag, attr, raw_string, taint); \
+  }
+
+#define SET(N, E) \
+  if (mark_##N == NULL || E == mark_##N) \
+    N = rb_str_new2(""); \
+  else if (E > mark_##N) \
+    N = rb_str_new(mark_##N, E - mark_##N);
+
+#define CAT(N, E) if (NIL_P(N)) { SET(N, E); } else { rb_str_cat(N, mark_##N, E - mark_##N); }
+
+#define SLIDE(N) if ( mark_##N > tokstart ) mark_##N = buf + (mark_##N - tokstart);
+
+#define ATTR(K, V) \
+    if (!NIL_P(K)) { \
+      if (NIL_P(attr)) attr = rb_hash_new(); \
+      rb_hash_aset(attr, K, V); \
+    }
+
+#define TEXT_PASS() \
+    if (text == 0) \
+    { \
+      if (ele_open == 1) { \
+        ele_open = 0; \
+        if (tokstart > 0) { \
+          mark_tag = tokstart; \
+        } \
+      } else { \
+        mark_tag = p; \
+      } \
+      attr = Qnil; \
+      tag = Qnil; \
+      text = 1; \
+    }
+
+#define EBLK(N, T) CAT(tag, p - T + 1); ELE(N);
+
+%%{
+  machine hpricot_scan;
+
+  action newEle {
+    if (text == 1) {
+      CAT(tag, p);
+      ELE(text);
+      text = 0;
+    }
+    attr = Qnil;
+    tag = Qnil;
+    mark_tag = NULL;
+    ele_open = 1;
+  }
+
+  action _tag { mark_tag = p; }
+  action _aval { mark_aval = p; }
+  action _akey { mark_akey = p; }
+  action tag { SET(tag, p); }
+  action tagc { SET(tag, p-1); }
+  action aval { SET(aval, p); }
+  action aunq { 
+    if (*(p-1) == '"' || *(p-1) == '\'') { SET(aval, p-1); }
+    else { SET(aval, p); }
+  }
+  action akey { SET(akey, p); }
+  action xmlver { SET(aval, p); ATTR(rb_str_new2("version"), aval); }
+  action xmlenc { SET(aval, p); ATTR(rb_str_new2("encoding"), aval); }
+  action xmlsd  { SET(aval, p); ATTR(rb_str_new2("standalone"), aval); }
+  action pubid  { SET(aval, p); ATTR(rb_str_new2("public_id"), aval); }
+  action sysid  { SET(aval, p); ATTR(rb_str_new2("system_id"), aval); }
+
+  action new_attr { 
+    akey = Qnil;
+    aval = Qnil;
+    mark_akey = NULL;
+    mark_aval = NULL;
+  }
+
+  action save_attr { 
+    ATTR(akey, aval);
+  }
+
+  include hpricot_common "ext/hpricot_scan/hpricot_common.rl";
+
+}%%
+
+%% write data nofinal;
+
+#define BUFSIZE 16384
+
+void rb_yield_tokens(VALUE sym, VALUE tag, VALUE attr, VALUE raw, int taint)
+{
+  VALUE ary;
+  if (sym == sym_text) {
+    raw = tag;
+  }
+  ary = rb_ary_new3(4, sym, tag, attr, raw);
+  if (taint) { 
+    OBJ_TAINT(ary);
+    OBJ_TAINT(tag);
+    OBJ_TAINT(attr);
+    OBJ_TAINT(raw);
+  }
+  rb_yield(ary);
+}
+
+VALUE hpricot_scan(VALUE self, VALUE port)
+{
+  int cs, act, have = 0, nread = 0, curline = 1, text = 0;
+  char *tokstart = 0, *tokend = 0, *buf = NULL;
+
+  VALUE attr = Qnil, tag = Qnil, akey = Qnil, aval = Qnil, bufsize = Qnil;
+  char *mark_tag = 0, *mark_akey = 0, *mark_aval = 0;
+  int done = 0, ele_open = 0, buffer_size = 0;
+
+  int taint = OBJ_TAINTED( port );
+  if ( !rb_respond_to( port, s_read ) )
+  {
+    if ( rb_respond_to( port, s_to_str ) )
+    {
+      port = rb_funcall( port, s_to_str, 0 );
+      StringValue(port);
+    }
+    else
+    {
+      rb_raise( rb_eArgError, "bad Hpricot argument, String or IO only please." );
+    }
+  }
+
+  buffer_size = BUFSIZE;
+  if (rb_ivar_defined(self, rb_intern("@buffer_size")) == Qtrue) {
+    bufsize = rb_ivar_get(self, rb_intern("@buffer_size"));
+    if (!NIL_P(bufsize)) {
+      buffer_size = NUM2INT(bufsize);
+    }
+  }
+  buf = ALLOC_N(char, buffer_size);
+
+  %% write init;
+  
+  while ( !done ) {
+    VALUE str;
+    char *p = buf + have, *pe;
+    int len, space = buffer_size - have;
+
+    if ( space == 0 ) {
+      /* We've used up the entire buffer storing an already-parsed token
+       * prefix that must be preserved.  Likely caused by super-long attributes.
+       * See ticket #13. */
+      rb_raise(rb_eHpricotParseError, "ran out of buffer space on element <%s>, starting on line %d.", RSTRING(tag)->ptr, curline);
+    }
+
+    if ( rb_respond_to( port, s_read ) )
+    {
+      str = rb_funcall( port, s_read, 1, INT2FIX(space) );
+    }
+    else
+    {
+      str = rb_str_substr( port, nread, space );
+    }
+
+    StringValue(str);
+    memcpy( p, RSTRING(str)->ptr, RSTRING(str)->len );
+    len = RSTRING(str)->len;
+    nread += len;
+
+    /* If this is the last buffer, tack on an EOF. */
+    if ( len < space ) {
+      p[len++] = 0;
+      done = 1;
+    }
+
+    pe = p + len;
+    %% write exec;
+    
+    if ( cs == hpricot_scan_error ) {
+      free(buf);
+      if ( !NIL_P(tag) )
+      {
+        rb_raise(rb_eHpricotParseError, "parse error on element <%s>, starting on line %d.\n" NO_WAY_SERIOUSLY, RSTRING(tag)->ptr, curline);
+      }
+      else
+      {
+        rb_raise(rb_eHpricotParseError, "parse error on line %d.\n" NO_WAY_SERIOUSLY, curline);
+      }
+    }
+    
+    if ( done && ele_open )
+    {
+      ele_open = 0;
+      if (tokstart > 0) {
+        mark_tag = tokstart;
+        tokstart = 0;
+        text = 1;
+      }
+    }
+
+    if ( tokstart == 0 )
+    {
+      have = 0;
+      /* text nodes have no tokstart because each byte is parsed alone */
+      if ( mark_tag != NULL && text == 1 )
+      {
+        if (done)
+        {
+          if (mark_tag < p-1)
+          {
+            CAT(tag, p-1);
+            ELE(text);
+          }
+        }
+        else
+        {
+          CAT(tag, p);
+        }
+      }
+      mark_tag = buf;
+    }
+    else
+    {
+      have = pe - tokstart;
+      memmove( buf, tokstart, have );
+      SLIDE(tag);
+      SLIDE(akey);
+      SLIDE(aval);
+      tokend = buf + (tokend - tokstart);
+      tokstart = buf;
+    }
+  }
+  free(buf);
+}
+
+void Init_hpricot_scan()
+{
+  VALUE mHpricot = rb_define_module("Hpricot");
+  rb_define_attr(rb_singleton_class(mHpricot), "buffer_size", 1, 1);
+  rb_define_singleton_method(mHpricot, "scan", hpricot_scan, 1);
+  rb_eHpricotParseError = rb_define_class_under(mHpricot, "ParseError", rb_eException);
+
+  s_read = rb_intern("read");
+  s_to_str = rb_intern("to_str");
+  sym_xmldecl = ID2SYM(rb_intern("xmldecl"));
+  sym_doctype = ID2SYM(rb_intern("doctype"));
+  sym_procins = ID2SYM(rb_intern("procins"));
+  sym_stag = ID2SYM(rb_intern("stag"));
+  sym_etag = ID2SYM(rb_intern("etag"));
+  sym_emptytag = ID2SYM(rb_intern("emptytag"));
+  sym_comment = ID2SYM(rb_intern("comment"));
+  sym_cdata = ID2SYM(rb_intern("cdata"));
+  sym_text = ID2SYM(rb_intern("text"));
+}