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 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)); }