protected RubyModule(string s)
{
this.name = s;
this.symbol = RubySymbol.GetSymbol(s);
this.ClassName = RubySymbol.GetSymbol("Module");
modules.Add(s, this);
}
public XmlDeclaration(RubyContext context)
: base(context, new AttributeData())
{
_encoding = context.CreateAsciiSymbol("encoding");
_standalone = context.CreateAsciiSymbol("standalone");
_version = context.CreateAsciiSymbol("version");
}
protected RubyClass(string s)
{
this.name = s;
this.symbol = RubySymbol.GetSymbol(s);
this.ClassName = RubySymbol.GetSymbol("Class");
classes.Add(s, this);
}
public void InitializeLibrary(RubyScope scope)
{
KernelOps.Require(scope, this, MutableString.CreateAscii("json/common"));
_maxNesting = scope.RubyContext.CreateAsciiSymbol("max_nesting");
_allowNan = scope.RubyContext.CreateAsciiSymbol("allow_nan");
_jsonCreatable = scope.RubyContext.CreateAsciiSymbol("json_creatable?");
_jsonCreate = scope.RubyContext.CreateAsciiSymbol("json_create");
_createId = scope.RubyContext.CreateAsciiSymbol("create_id");
_createAdditions = scope.RubyContext.CreateAsciiSymbol("create_additions");
_chr = scope.RubyContext.CreateAsciiSymbol("chr");
}
public static Win32API/*!*/ Create(RubyClass/*!*/ self,
[DefaultProtocol, NotNull]MutableString/*!*/ libraryName,
[DefaultProtocol, NotNull]MutableString/*!*/ functionName,
[DefaultProtocol, NotNull]MutableString/*!*/ parameterTypes,
[DefaultProtocol, NotNull]MutableString/*!*/ returnType,
RubySymbol callingConvention) {
Debug.Assert(callingConvention.ToString() == "stdcall");
return Reinitialize(new Win32API(self), libraryName, functionName, parameterTypes, returnType);
}
public RubySymbol/*!*/ GetSymbol(RubyContext/*!*/ context) {
return _symbol ?? (_symbol = context.EncodeIdentifier(_string));
}
private IHpricotDataContainer H_ELE(IHpricotDataContainer ele, ScannerState state, RubySymbol sym, MutableString tag, Object attr, Object ec, Int32 raw, Int32 rawlen)
{
if (ele is Element) {
ElementData he = ele.GetData<ElementData>();
he.Name = 0;
he.Tag = tag;
he.Attr = attr;
he.EC = ec;
if (raw > -1 && (sym_emptytag.Equals(sym) || sym_stag.Equals(sym) || sym_etag.Equals(sym) || sym_doctype.Equals(sym))) {
he.Raw = Utilities.CreateMutableStringFromBuffer(buf, raw, rawlen);
}
}
else if (ele is DocumentType || ele is ProcedureInstruction || ele is XmlDeclaration || ele is ETag || ele is BogusETag) {
AttributeData ha = ele.GetData<AttributeData>();
ha.Tag = tag;
if (ele is ETag || ele is BogusETag) {
if (raw > -1) {
ha.Attr = Utilities.CreateMutableStringFromBuffer(buf, raw, rawlen);
}
}
else {
ha.Attr = attr;
}
}
else {
ele.GetData<BasicData>().Tag = tag;
}
state.Last = ele;
return ele;
}
private void rb_hpricot_token(ScannerState state, RubySymbol sym, MutableString tag, Object attr, int raw, int rawlen, bool taint)
{
Object ec = null;
if (!state.Xml) {
ElementData last = state.Focus.GetData<ElementData>();
if (sym_emptytag.Equals(sym) || sym_stag.Equals(sym) || sym_etag.Equals(sym)) {
Debug.Assert(state.EC is Hash, "state.EC is not an instance of Hash");
if (state.EC.ContainsKey(tag)) {
ec = rb_hash_lookup(state.EC, tag);
}
else {
tag = MutableStringOps.DownCase(tag as MutableString);
ec = rb_hash_aref(state.EC, tag);
}
}
// TODO: tag.GetHashCode() == last.name.GetHashCode() ??
if (sym_CDATA.Equals(last.EC) &&
(!sym_procins.Equals(sym) && !sym_comment.Equals(sym) && !sym_cdata.Equals(sym) && !sym_text.Equals(sym)) &&
!(sym_etag.Equals(sym) && tag.GetHashCode() == last.Name.GetHashCode())) {
sym = sym_text;
tag = Utilities.CreateMutableStringFromBuffer(buf, raw, rawlen);
}
if (ec != null) {
if (sym_emptytag.Equals(sym)) {
if (!sym_EMPTY.Equals(ec)) {
sym = sym_stag;
}
}
else if (sym_stag.Equals(sym)) {
if (sym_EMPTY.Equals(ec)) {
sym = sym_emptytag;
}
}
}
}
if (sym_emptytag.Equals(sym) || sym_stag.Equals(sym)) {
var ele = H_ELE(new Element(state), state, sym, tag, attr, ec, raw, rawlen);
ElementData he = ele.GetData<ElementData>();
he.Name = tag.GetHashCode();
if (!state.Xml) {
IHpricotDataContainer match = null;
IHpricotDataContainer e = state.Focus;
while (e != state.Doc) {
ElementData hee = e.GetData<ElementData>();
if (hee.EC is Hash) {
Object has;
if ((hee.EC as Hash).TryGetValue(he.Name, out has)) {
if (has is bool && (bool) has == true) {
if (match == null) {
match = e;
}
}
else if (symAllow.Equals(has)) {
match = state.Focus;
}
else if (symDeny.Equals(has)) {
match = null;
}
}
}
e = hee.Parent;
}
if (match == null) {
match = state.Focus;
}
state.Focus = match;
}
rb_hpricot_add(state.Focus, ele);
//
// in the case of a start tag that should be empty, just
// skip the step that focuses the element. focusing moves
// us deeper into the document.
//
if (sym_stag.Equals(sym)) {
if (state.Xml || !sym_EMPTY.Equals(ec)) {
state.Focus = ele;
state.Last = null;
}
}
}
else if (sym_etag.Equals(sym)) {
int name;
IHpricotDataContainer match = null;
IHpricotDataContainer e = state.Focus;
if (state.Strict) {
Debug.Assert(state.EC is Hash, "state.EC is not an instance of Hash");
if (!state.EC.ContainsKey(tag)) {
tag = MutableString.CreateAscii("div");
}
}
//
// another optimization will be to improve this very simple
// O(n) tag search, where n is the depth of the focused tag.
//
// (see also: the search above for fixups)
//
name = tag.GetHashCode();
while (e != state.Doc) {
ElementData he = e.GetData<ElementData>();
if (he != null && he.Name == name) {
match = e;
break;
}
e = he.Parent;
}
if (match == null) {
rb_hpricot_add(state.Focus, H_ELE(new BogusETag(state), state, sym, tag, attr, ec, raw, rawlen));
}
else {
var ele = H_ELE(new ETag(state), state, sym, tag, attr, ec, raw, rawlen);
ElementData he = match.GetData<ElementData>();
// TODO: couldn't find this in the original implementation but it still sounds right.
he.ETag = ele;
state.Focus = he.Parent;
state.Last = null;
}
}
else if (sym_cdata.Equals(sym)) {
rb_hpricot_add(state.Focus, H_ELE(new CData(state), state, sym, tag, attr, ec, raw, rawlen));
}
else if (sym_comment.Equals(sym)) {
rb_hpricot_add(state.Focus, H_ELE(new Comment(state), state, sym, tag, attr, ec, raw, rawlen));
}
else if (sym_doctype.Equals(sym)) {
if (state.Strict) {
// TODO: need to check if attr is really an Hash instance
Debug.Assert(attr is Hash, "attr is not an instance of Hash");
(attr as Hash).Add(state.Context.CreateAsciiSymbol("system_id"), MutableString.CreateAscii("http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"));
(attr as Hash).Add(state.Context.CreateAsciiSymbol("public_id"), MutableString.CreateAscii("-//W3C//DTD XHTML 1.0 Strict//EN"));
}
rb_hpricot_add(state.Focus, H_ELE(new DocumentType(state), state, sym, tag, attr, ec, raw, rawlen));
}
else if (sym_procins.Equals(sym)) {
Debug.Assert(tag is MutableString, "tag is not an instance of MutableString");
MatchData match = Utilities.ProcessInstructionParser.Match(RubyEncoding.Binary, tag as MutableString);
Debug.Assert(match.GroupSuccess(0) && match.GroupCount == 3, "ProcInsParse failed to parse procins");
tag = match.GetGroupValue(1);
attr = match.GetGroupValue(2);
rb_hpricot_add(state.Focus, H_ELE(new ProcedureInstruction(state), state, sym, tag, attr, ec, raw, rawlen));
}
else if (sym_text.Equals(sym)) {
// TODO: add raw_string as well?
if (state.Last != null && state.Last is Text) {
BasicData he = state.Last.GetData<BasicData>();
Debug.Assert(tag is MutableString, "tag is not an instance of MutableString");
Debug.Assert(he.Tag is MutableString, "he.Tag is not an instance of MutableString");
(he.Tag as MutableString).Append(tag as MutableString);
}
else {
rb_hpricot_add(state.Focus, H_ELE(new Text(state), state, sym, tag, attr, ec, raw, rawlen));
}
}
else if (sym_xmldecl.Equals(sym)) {
rb_hpricot_add(state.Focus, H_ELE(new XmlDeclaration(state), state, sym, tag, attr, ec, raw, rawlen));
}
}
internal bool HasKey(RubySymbol/*!*/ key)
{
lock (_threadLocalStorage) {
return _threadLocalStorage.ContainsKey(key);
}
}
private void EBLK(RubySymbol N, int T)
{
CAT(tag, p - T + 1);
ELE(N);
}
public static Proc/*!*/ ToProc(RubyScope/*!*/ scope, RubySymbol/*!*/ self) {
return Proc.CreateMethodInvoker(scope, self.ToString());
}
public static string TransformToNativeModel(this RubySymbol self)
{
return(self.Name);
}
public static RubySymbol/*!*/ ToSymbol(RubySymbol/*!*/ self) {
return self;
}
public static string/*!*/ ToClrString(RubySymbol/*!*/ self) {
return self.ToString();
}
public static int ToInteger(RubySymbol/*!*/ self) {
return self.Id;
}
// level 0: no overload applicable
// level 1: {L1, L3} applicable, MutableString <-/-> RubySymbol
public void L1([NotNull] RubySymbol a, [DefaultProtocol, NotNull] string b)
{
}
/// <summary>
/// static VALUE r_object0(struct load_arg *arg, int *ivp, VALUE extmod)
/// </summary>
/// <param name="hasivp"></param>
/// <param name="ivp"></param>
/// <param name="extmod"></param>
/// <returns></returns>
public object ReadObject0(bool hasivp, ref bool ivp, List <RubyModule> extmod)
{
object v = null;
var type = ReadByte();
switch (type)
{
case RubyMarshal.Types.LINK:
var id = ReadLong();
object link;
if (!_m_objects.TryGetValue(id, out link))
{
throw new InvalidDataException("dump format error (unlinked)");
}
v = link;
if (_m_proc != null)
{
v = _m_proc(v);
}
break;
case RubyMarshal.Types.INSTANCE_VARIABLE:
{
var ivar = true;
v = ReadObject0(ref ivar, extmod);
var hasenc = false;
if (ivar)
{
ReadInstanceVariable(v, ref hasenc);
}
}
break;
case RubyMarshal.Types.EXTENDED:
{
var m = RubyModule.GetModule(ReadUnique());
if (extmod == null)
{
extmod = new List <RubyModule>();
}
extmod.Add(m);
v = ReadObject0(extmod);
if (v is RubyObject fobj)
{
fobj.ExtendModules.AddRange(extmod);
}
}
break;
case RubyMarshal.Types.USER_CLASS:
{
var c = RubyClass.GetClass(ReadUnique());
v = ReadObject0(extmod);
if (v is RubyObject)
{
(v as RubyObject).ClassName = c.Symbol;
}
}
break;
case RubyMarshal.Types.NIL:
v = RubyNil.Instance;
v = Leave(v);
break;
case RubyMarshal.Types.TRUE:
v = RubyBool.True;
v = Leave(v);
break;
case RubyMarshal.Types.FALSE:
v = RubyBool.False;
v = Leave(v);
break;
case RubyMarshal.Types.FIXNUM:
v = ReadLong();
v = new RubyFixnum(Convert.ToInt64(v));
v = Leave(v);
break;
case RubyMarshal.Types.FLOAT:
{
double d;
var fstr = ReadString();
var str = fstr.Text;
switch (str)
{
case "inf":
d = double.PositiveInfinity;
break;
case "-inf":
d = double.NegativeInfinity;
break;
case "nan":
d = double.NaN;
break;
default:
if (str.Contains("\0"))
{
str = str.Remove(str.IndexOf("\0", StringComparison.Ordinal));
}
d = Convert.ToDouble(str);
break;
}
v = new RubyFloat(d);
v = Entry(v);
v = Leave(v);
}
break;
case RubyMarshal.Types.BIGNUM:
{
var sign = 0;
switch (ReadByte())
{
case 0x2b:
sign = 1;
break;
case 0x2d:
sign = -1;
break;
default:
sign = 0;
break;
}
var num3 = ReadLong();
var index = num3 / 2;
var num5 = (num3 + 1) / 2;
var data = new uint[num5];
for (var i = 0; i < index; i++)
{
data[i] = _m_reader.ReadUInt32();
}
if (index != num5)
{
data[index] = _m_reader.ReadUInt16();
}
v = new RubyBignum(sign, data);
v = Entry(v);
v = Leave(v);
}
break;
case RubyMarshal.Types.STRING:
v = Entry(ReadString());
v = Leave(v);
break;
case RubyMarshal.Types.REGEXP:
{
var str = ReadString();
var options = ReadByte();
var has_encoding = false;
var idx = Prepare();
if (hasivp)
{
ReadInstanceVariable(str, ref has_encoding);
ivp = false;
}
if (!has_encoding)
{
// TODO: 1.8 compatibility; remove escapes undefined in 1.8
/*
* char *ptr = RSTRING_PTR(str), *dst = ptr, *src = ptr;
* long len = RSTRING_LEN(str);
* long bs = 0;
* for (; len-- > 0; *dst++ = *src++) {
* switch (*src) {
* case '\\': bs++; break;
* case 'g': case 'h': case 'i': case 'j': case 'k': case 'l':
* case 'm': case 'o': case 'p': case 'q': case 'u': case 'y':
* case 'E': case 'F': case 'H': case 'I': case 'J': case 'K':
* case 'L': case 'N': case 'O': case 'P': case 'Q': case 'R':
* case 'S': case 'T': case 'U': case 'V': case 'X': case 'Y':
* if (bs & 1) --dst;
* default: bs = 0; break;
* }
* }
* rb_str_set_len(str, dst - ptr);
*/
}
v = Entry0(new RubyRegexp(str, (RubyRegexpOptions)options), idx);
v = Leave(v);
}
break;
case RubyMarshal.Types.ARRAY:
{
var len = ReadLong();
var ary = new RubyArray();
v = ary;
v = Entry(v);
while (len-- > 0)
{
ary.Push(ReadObject());
}
v = Leave(v);
}
break;
case RubyMarshal.Types.HASH:
case RubyMarshal.Types.HASH_WITH_DEFAULT:
{
var len = ReadLong();
var hash = new RubyHash();
v = hash;
v = Entry(v);
while (len-- > 0)
{
var key = ReadObject();
var value = ReadObject();
hash.Add(key, value);
}
if (type == RubyMarshal.Types.HASH_WITH_DEFAULT)
{
hash.DefaultValue = ReadObject();
}
v = Leave(v);
}
break;
case RubyMarshal.Types.STRUCT:
{
var idx = Prepare();
var obj = new RubyStruct();
var klass = ReadUnique();
obj.ClassName = klass;
var len = ReadLong();
v = obj;
v = Entry0(v, idx);
while (len-- > 0)
{
var key = ReadSymbol();
var value = ReadObject();
obj.InstanceVariable[key] = value;
}
v = Leave(v);
}
break;
case RubyMarshal.Types.USER_DEFINED:
{
var klass = ReadUnique();
var obj = RubyUserDefinedObject.TryGetUserDefinedObject(klass.Name);
if (obj == null)
{
var data = ReadString();
if (hasivp)
{
ReadInstanceVariable(data);
ivp = false;
}
obj = new DefaultRubyUserDefinedDumpObject {
Raw = data.Raw
};
}
else
{
obj.Read(_m_reader);
}
obj.ClassName = klass;
v = obj;
v = Entry(v);
v = Leave(v);
}
break;
case RubyMarshal.Types.USER_MARSHAL:
{
var klass = ReadUnique();
var obj = new DefaultRubyUserDefinedMarshalDumpObject();
v = obj;
if (extmod != null)
{
AppendExtendedModule(obj, extmod);
}
v = Entry(v);
var data = ReadObject();
obj.ClassName = klass;
obj.DumpedObject = data;
v = Leave(v);
extmod?.Clear();
}
break;
case RubyMarshal.Types.OBJECT:
{
var idx = Prepare();
var obj = new RubyObject();
var klass = ReadUnique();
obj.ClassName = klass;
v = obj;
v = Entry0(v, idx);
ReadInstanceVariable(v);
v = Leave(v);
}
break;
case RubyMarshal.Types.CLASS:
{
var str = ReadString();
v = RubyClass.GetClass(RubySymbol.GetSymbol(str));
v = Entry(v);
v = Leave(v);
}
break;
case RubyMarshal.Types.MODULE:
{
var str = ReadString();
v = RubyModule.GetModule(RubySymbol.GetSymbol(str));
v = Entry(v);
v = Leave(v);
}
break;
case RubyMarshal.Types.SYMBOL:
if (hasivp)
{
v = ReadSymbolReal(ivp);
ivp = false;
}
else
{
v = ReadSymbolReal(false);
}
v = Leave(v);
break;
case RubyMarshal.Types.SYMBOL_LINK:
v = ReadSymbolLink();
break;
case RubyMarshal.Types.DATA:
/* TODO: Data Support
* {
* VALUE klass = path2class(r_unique(arg));
* VALUE oldclass = 0;
*
* v = obj_alloc_by_klass(klass, arg, &oldclass);
* if (!RB_TYPE_P(v, T_DATA)) {
* rb_raise(rb_eArgError, "dump format error");
* }
* v = r_entry(v, arg);
* if (!rb_respond_to(v, s_load_data)) {
* rb_raise(rb_eTypeError, "class %s needs to have instance method `_load_data'", rb_class2name(klass));
* }
* rb_funcall(v, s_load_data, 1, r_object0(arg, 0, extmod));
* check_load_arg(arg, s_load_data);
* v = r_leave(v, arg);
* }
*/
case RubyMarshal.Types.MODULE_OLD:
/*
* TODO: ModuleOld Support
* {
* volatile VALUE str = r_bytes(arg);
* v = rb_path_to_class(str);
* v = r_entry(v, arg);
* v = r_leave(v, arg);
* }
*/
default:
throw new InvalidDataException($"dump format error(0x{type:X2})");
}
return(v);
}
private void _read()
{
_code = ((RubyMarshal.Codes)m_io.ReadU1());
switch (Code)
{
case RubyMarshal.Codes.PackedInt:
{
_body = new PackedInt(m_io, this, m_root);
break;
}
case RubyMarshal.Codes.Bignum:
{
_body = new Bignum(m_io, this, m_root);
break;
}
case RubyMarshal.Codes.RubyArray:
{
_body = new RubyArray(m_io, this, m_root);
break;
}
case RubyMarshal.Codes.RubySymbolLink:
{
_body = new PackedInt(m_io, this, m_root);
break;
}
case RubyMarshal.Codes.RubyStruct:
{
_body = new RubyStruct(m_io, this, m_root);
break;
}
case RubyMarshal.Codes.RubyString:
{
_body = new RubyString(m_io, this, m_root);
break;
}
case RubyMarshal.Codes.InstanceVar:
{
_body = new InstanceVar(m_io, this, m_root);
break;
}
case RubyMarshal.Codes.RubyHash:
{
_body = new RubyHash(m_io, this, m_root);
break;
}
case RubyMarshal.Codes.RubySymbol:
{
_body = new RubySymbol(m_io, this, m_root);
break;
}
case RubyMarshal.Codes.RubyObjectLink:
{
_body = new PackedInt(m_io, this, m_root);
break;
}
}
}
public static object Match(RubyScope/*!*/ scope, RubySymbol/*!*/ self, [NotNull]RubyRegex/*!*/ regex) {
return MutableStringOps.Match(scope, self.ToMutableString(), regex);
}
public static MutableString/*!*/ Inspect(RubyContext/*!*/ context, RubySymbol/*!*/ self) {
var str = self.ToString();
bool allowMultiByteCharacters = context.RubyOptions.Compatibility >= RubyCompatibility.Ruby19 || context.KCode != null;
var result = self.ToMutableString();
// simple cases:
if (
Tokenizer.IsMethodName(str, allowMultiByteCharacters) ||
Tokenizer.IsConstantName(str, allowMultiByteCharacters) ||
Tokenizer.IsInstanceVariableName(str, allowMultiByteCharacters) ||
Tokenizer.IsClassVariableName(str, allowMultiByteCharacters) ||
Tokenizer.IsGlobalVariableName(str, allowMultiByteCharacters)
) {
result.Insert(0, ':');
} else {
// TODO: this is neither efficient nor complete.
// Any string that parses as 'sym' should not be quoted.
switch (str) {
case null:
// Ruby doesn't allow empty symbols, we can get one from outside though:
return MutableString.CreateAscii(":\"\"");
case "|":
case "^":
case "&":
case "<=>":
case "==":
case "===":
case "=~":
case ">":
case ">=":
case "<":
case "<=":
case "<<":
case ">>":
case "+":
case "-":
case "*":
case "/":
case "%":
case "**":
case "~":
case "+@":
case "-@":
case "[]":
case "[]=":
case "`":
case "$!":
case "$@":
case "$,":
case "$;":
case "$/":
case "$\\":
case "$*":
case "$$":
case "$?":
case "$=":
case "$:":
case "$\"":
case "$<":
case "$>":
case "$.":
case "$~":
case "$&":
case "$`":
case "$'":
case "$+":
result.Insert(0, ':');
break;
default:
result.Insert(0, ":\"").Append('"');
break;
}
}
if (context.RuntimeId != self.RuntimeId) {
result.Append(" @").Append(self.RuntimeId.ToString(CultureInfo.InvariantCulture));
}
return result;
}
public static object Match(BinaryOpStorageWithScope/*!*/ storage, RubyScope/*!*/ scope, RubySymbol/*!*/ self, object obj) {
return MutableStringOps.Match(storage, scope, self.ToMutableString(), obj);
}
internal object this[RubySymbol/*!*/ key]
{
get {
lock (_threadLocalStorage) {
object result;
if (!_threadLocalStorage.TryGetValue(key, out result)) {
result = null;
}
return result;
}
}
set {
lock (_threadLocalStorage) {
if (value == null) {
_threadLocalStorage.Remove(key);
} else {
_threadLocalStorage[key] = value;
}
}
}
}
public static object Match(BinaryOpStorageWithScope/*!*/ storage, RubyScope/*!*/ scope, RubySymbol/*!*/ self, [NotNull]RubyRegex/*!*/ regex) {
return MutableStringOps.Match(storage, scope, self.ToMutableString(), regex);
}
private static bool OPT(Hash opts, RubySymbol key)
{
if (opts != null) {
Object value;
if (opts.TryGetValue(key, out value) && value is bool) {
return (bool)value;
}
else {
return false;
}
}
else {
return false;
}
}
public static object Match(BinaryOpStorageWithScope/*!*/ storage, RubyScope/*!*/ scope, RubySymbol/*!*/ self, [DefaultProtocol, NotNull]MutableString/*!*/ pattern) {
return MutableStringOps.Match(storage, scope, self.ToMutableString(), pattern);
}
private void ELE(RubySymbol N)
{
if (te > ts || text) {
int raw = -1;
int rawlen = 0;
ele_open = false;
text = false;
if (ts != -1 && N != sym_cdata && N != sym_text && N != sym_procins && N != sym_comment) {
raw = ts;
rawlen = te - ts;
}
if (_blockParam != null) {
MutableString raw_string = null;
if (raw > 0) {
raw_string = Utilities.CreateMutableStringFromBuffer(buf, raw, rawlen);
}
// NOTE: right before v0.7 the fourth argument of rb_yield_tokens was yielding raw_string
// but now it yields null (hardcoded). I still have to understand why, but this
// might be a way to limit the memory usage of Hpricot given that raw_string was
// not really that used in userland.
rb_yield_tokens(N, tag[0], attr, null, taint);
}
else {
rb_hpricot_token(_state, N, (MutableString)tag[0], attr, raw, rawlen, taint);
}
}
}
public static bool IsEmpty(RubySymbol/*!*/ self) {
return self.IsEmpty;
}
private void InitializeHpricotSymbols(RubyContext context)
{
sym_xmldecl = context.CreateAsciiSymbol("xmldecl");
sym_doctype = context.CreateAsciiSymbol("doctype");
sym_procins = context.CreateAsciiSymbol("procins");
sym_stag = context.CreateAsciiSymbol("stag");
sym_etag = context.CreateAsciiSymbol("etag");
sym_emptytag = context.CreateAsciiSymbol("emptytag");
sym_comment = context.CreateAsciiSymbol("comment");
sym_cdata = context.CreateAsciiSymbol("cdata");
sym_text = context.CreateAsciiSymbol("text");
sym_EMPTY = context.CreateAsciiSymbol("EMPTY");
sym_CDATA = context.CreateAsciiSymbol("CDATA");
symAllow = context.CreateAsciiSymbol("allow");
symDeny = context.CreateAsciiSymbol("deny");
_optXml = context.CreateAsciiSymbol("xml");
_optFixupTags = context.CreateAsciiSymbol("fixup_tags");
_optXhtmlStrict = context.CreateAsciiSymbol("xhtml_strict");
}
public DocumentType(RubyContext context)
: base(context, new AttributeData())
{
_systemId = context.CreateAsciiSymbol("system_id");
_publicId = context.CreateAsciiSymbol("public_id");
}
public DocumentType(RubyContext context)
: base(context, new AttributeData())
{
_systemId = context.CreateAsciiSymbol("system_id");
_publicId = context.CreateAsciiSymbol("public_id");
}
public static int GetLength(RubySymbol/*!*/ self) {
return (self.Encoding.IsKCoding) ? self.GetByteCount() : self.GetCharCount();
}
public Symbol(string str, RubySymbol sym) {
_string = str;
_symbol = sym;
}
public static MutableString/*!*/ ToString(RubySymbol/*!*/ self) {
return self.ToMutableString();
}
public static RubyEncoding/*!*/ GetEncoding(RubySymbol/*!*/ self) {
return self.Encoding;
}
public static RubySymbol/*!*/ Succ(RubyContext/*!*/ context, RubySymbol/*!*/ self) {
return context.CreateSymbol(MutableStringOps.Succ(self.String));
}
