// Python rejects names starting with digits.
// We don't enforce either of those.
func isValidCaptureName(name string) bool {
	if name == "" {
		return false
	}
	for _, c := range name {
		if c != '_' && !isalnum(c) {
			return false
		}
	}
	return true
}

// parseInt parses a decimal integer.
func (p *parser) parseInt(s string) (n int, rest string, ok bool) {
	if s == "" || s[0] < '0' || '9' < s[0] {

// Therefore we need to cast a char to unsigned char before calling
// isspace(), etc.

inline bool IsAlpha(char ch) {
  return isalpha(static_cast<unsigned char>(ch)) != 0;
}
inline bool IsAlNum(char ch) {
  return isalnum(static_cast<unsigned char>(ch)) != 0;
}
inline bool IsDigit(char ch) {
  return isdigit(static_cast<unsigned char>(ch)) != 0;
}
inline bool IsLower(char ch) {

// Therefore we need to cast a char to unsigned char before calling
// isspace(), etc.

inline bool IsAlpha(char ch) {
  return isalpha(static_cast<unsigned char>(ch)) != 0;
}
inline bool IsAlNum(char ch) {
  return isalnum(static_cast<unsigned char>(ch)) != 0;
}
inline bool IsDigit(char ch) {
  return isdigit(static_cast<unsigned char>(ch)) != 0;
}
inline bool IsLower(char ch) {

	i := 1
	start := 1
	for i < len(v) && v[i] != '+' {
		if !isIdentChar(v[i]) && v[i] != '.' {
			return
		}
		if v[i] == '.' {
			if start == i || isBadNum(v[start:i]) {
				return
			}
			start = i + 1
		}
		i++
	}
	if start == i || isBadNum(v[start:i]) {
		return
	}
	return v[:i], v[i:], true
}

func parseBuild(v string) (t, rest string, ok bool) {
	if v == "" || v[0] != '+' {

            if (type.isInstance(arg) || arg == null) {
                // Can use arg without conversion
                continue;
            }
            if (!(arg instanceof CharSequence && type.isEnum())) {
                // Cannot convert
                return args;
            }
            needsTransform = true;
        }
        if (!needsTransform) {
            return args;
        }

	0x41, 0x5a,
	0x5f, 0x5f,
	0x61, 0x7a,
}

var code17 = []rune{ /* [:xdigit:] */
	0x30, 0x39,
	0x41, 0x46,
	0x61, 0x66,
}

var posixGroup = map[string]charGroup{
	`[:alnum:]`:   {+1, code4},
	`[:^alnum:]`:  {-1, code4},
	`[:alpha:]`:   {+1, code5},
	`[:^alpha:]`:  {-1, code5},
	`[:ascii:]`:   {+1, code6},
	`[:^ascii:]`:  {-1, code6},
	`[:blank:]`:   {+1, code7},
	`[:^blank:]`:  {-1, code7},

    @Override
    public <T> void extract(ModelSchemaExtractionContext<T> extractionContext) {
        ModelType<T> type = extractionContext.getType();
        if (type.getRawClass().isEnum()) {
            extractionContext.found(new ScalarValueSchema<T>(type));
        }
    }

object EnumCodec : EncodingProducer, Decoding {

    override fun encodingForType(type: Class<*>): Encoding? =
        EnumEncoding.takeIf { type.isEnum }
            ?: EnumSubTypeEncoding.takeIf { type.superclass?.isEnum == true }

    override suspend fun ReadContext.decode(): Any? {
        val enumClass = readClass()
        val enumOrdinal = readSmallInt()

        "Constructor" to "AddedClass(java.lang.String)",
        "Constructor" to "AddedClass()",
        "Class" to "AddedEnum",
        "Field" to "FOO"
    ) + reportedMembersFor("AddedEnum", isEnum = true) + listOf(
        "Method" to "AddedEnum.valueOf(java.lang.String)",
        "Method" to "AddedEnum.values()",
        "Class" to "AddedObject",
        "Field" to "INSTANCE",
        "Field" to "cathedral"

        return value;
    }

    @Nullable
    @Override
    public <S> S coerce(Class<S> type) {
        if (type.isInstance(value)) {
            return type.cast(value);
        }
        if (type.isEnum() && type.getName().equals(value.getDeclaringClass().getName())) {
            return type.cast(Enum.valueOf(Cast.uncheckedNonnullCast(type.asSubclass(Enum.class)), value.name()));
        }
        return null;
    }