/*@param char {number}
5546
function type(char) {
  switch (char) {
    case c.letter.d: // d
      return c.type.DICT
    case c.letter.l: // l
      return c.type.LIST
    case c.letter.i: // i
      return c.type.INT
    case c.letter.e: // e
      return c.type.END
    case c.digit.NUM0:
    case c.digit.NUM1:
    case c.digit.NUM2:
    case c.digit.NUM3:
    case c.digit.NUM4:
    case c.digit.NUM5:
    case c.digit.NUM6:
    case c.digit.NUM7:
    case c.digit.NUM8:
    case c.digit.NUM9:
    case c.MINUS:
      return c.type.STR
    default:
      break
  }

  return c.type.UNDEFINED
}
1074309
function (checks) {
    this.from = this.char;

    // Move to the next non-space character.
    var start;
    if (/\s/.test(this.peek())) {
      start = this.char;

      while (/\s/.test(this.peek())) {
        this.from += 1;
        this.skip();
      }
    }

    // Methods that work with multi-line structures and move the
    // character pointer.

    var match = this.scanComments() ||
      this.scanStringLiteral(checks) ||
      this.scanTemplateLiteral();

    if (match) {
      return match;
    }

    // Methods that don't move the character pointer.

    match =
      this.scanRegExp() ||
      this.scanPunctuator() ||
      this.scanKeyword() ||
      this.scanIdentifier() ||
      this.scanNumericLiteral();

    if (match) {
      this.skip(match.value.length);
      return match;
    }

    // No token could be matched, give up.

    return null;
  }
151370
private void writeCharsToOut(char[] cbuf, int len) throws IOException {
		if(len > 0) {
			if(len == 1) {
				out.write(cbuf[0]);
			} else {
				out.write(cbuf, 0, len);
			}
		}
	}
1294427
function _Char_toCode(char)
{
	var code = char.charCodeAt(0);
	if (0xD800 <= code && code <= 0xDBFF)
	{
		return (code - 0xD800) * 0x400 + char.charCodeAt(1) - 0xDC00 + 0x10000
	}
	return code;
}
1296761
public void putCharacter(String key, char c) {
		checkNotNull(key);
		put(key, Character.toString(c));
	}
424593
function incChar(char, base = 10) {
  let val = charToVal(char);
  if (val < 0) throw new Error('in incChar, invalid character');
  val = (val + 1) % base;
  return consts.alphabet[val];
}
1070415
function (c) {

// If a c parameter is provided, verify that it matches the current character.

            if (c && c !== ch) {
                error("Expected '" + c + "' instead of '" + ch + "'");
            }

// Get the next character. When there are no more characters,
// return the empty string.

            ch = text.charAt(at);
            at += 1;
            return ch;
        }
1031671
@Override
    public void characters(final char[] chr, final int start, final int length) throws SAXException {

        final String text = new String(chr).substring(start, start + length);
        LOG.trace("characters; '{}'", text);
        final String trimmedText = text.trim();
        LOG.info("text: '{}'", trimmedText);
        this.textStack.push(trimmedText);
    }
1366211
function (char) {
                if (this._handleEntities(char)) {
                    return;
                }
                if ("*" === char) {
                    return this._parseItalic;
                } else if ("`" === char) {
                    this._toggleTag("code");
                    return this._parseMonospace;
                } else if ("[" === char) {
                    return this._startLink(0);
                } else if ("!" === char) {
                    return this._parseImage;
                } else if ("-" === char) {
                    this._escapeCount = 1;
                    this._escapeChar = "-";
                    return this._parseEscape;
                } else if ("\n" === char) {
                    return null;
                } else {
                    this._output(char);
                }
            }
1266393
function _inputChar(char) {
    if(_charIsPrintable(char.charCodeAt(0))
      &&utils.isSelectable(document.activeElement)) {
      // add the char
      // FIXME: put at caretPosition/replace selected content
      document.activeElement.value += char;
      // fire an input event
      utils.dispatch(document.activeElement, {type: 'input'});
    }
  }
481317
def include_char?(char)
      unless char.empty?
        @chars.has_value?(char) || include_byte?(char_to_byte(char))
      else
        false
      end
    end
971785
private void addChars(String chars) {
        for (int i = 0; i < chars.length(); i++) {
            int c = chars.codePointAt(i) - min;
            if (values[c] != -1 && values[c] != i) {
                throw new IllegalArgumentException("Duplicate characters in the encoding alphabet");
            }
            values[c] = i;
        }
    }
1362135
public static boolean startsWithChar(String str, char ch) {
        if (StringUtils.isEmpty(str)) {
            return false;
        }

        return str.charAt(0) == ch;
    }
286083
private boolean isSockJsSpecialChar(char ch) {
        return ch <= '\u001F'
                || ch >= '\u200C' && ch <= '\u200F'
                || ch >= '\u2028' && ch <= '\u202F'
                || ch >= '\u2060' && ch <= '\u206F'
                || ch >= '\uFFF0'
                || ch >= '\uD800' && ch <= '\uDFFF';
    }
990148
function flush_char(outs) {
    if (a_count > 0) {
      outs.writeByte(a_count);
      outs.writeBytes(accum, 0, a_count);
      a_count = 0;
    }
  }
411777
function (len, min, chars) {
      len = len || 10;
      if (min != undefined) {
        len = publicRuleMethods._num(len, min);
      }
      var i;
      var str = '';
      chars = chars || ALPHA_NUMERIC_CHARS;
      var charsCount = chars.length;
      for (i = 0; i < len; i++) {
        str += chars[Math.floor(Math.random() * charsCount)];
      }
      return str;
    }
670507
public static void normalization(char[] charArray)
    {
        assert charArray != null;
        for (int i = 0; i < charArray.length; i++)
        {
            charArray[i] = CONVERT[charArray[i]];
        }
    }