// ToSnake is a utility function that converts from camelCase to snake_case.
func ToSnake(in string) string {
if len(in) == 0 {
return ""
}
out := make([]rune, 0, len(in))
foundUpper := false
r := []rune(in)
for i := 0; i < len(r); i++ {
ch := r[i]
if unicode.IsUpper(ch) {
if i > 0 && i < len(in)-1 && !unicode.IsUpper(r[i+1]) {
out = append(out, '_', unicode.ToLower(ch), r[i+1])
i++
continue
foundUpper = false
}
if i > 0 && !foundUpper {
out = append(out, '_')
}
out = append(out, unicode.ToLower(ch))
foundUpper = true
} else {
foundUpper = false
out = append(out, ch)
}
}
return string(out)
}
// Is the item exported from the package?
func (n *Named) Exported() bool {
if n.Imported() {
return false
}
r, _ := utf8.DecodeRuneInString(n.Name)
return unicode.IsUpper(r)
}
// ToLatin returns a string transliterated using provided mapping table.
// Runes that cannot be transliterated inserted as-is.
func ToLatin(s string, table map[int]string) string {
runes := []int(s)
out := make([]int, 0, len(s))
for i, rune := range runes {
if tr, ok := table[unicode.ToLower(rune)]; ok {
if tr == "" {
continue
}
if unicode.IsUpper(rune) {
// Correctly translate case of successive characters:
// ЩИ -> SCHI
// Щи -> Schi
if i+1 < len(runes) && !unicode.IsUpper(runes[i+1]) {
t := []int(tr)
t[0] = unicode.ToUpper(t[0])
out = append(out, t...)
continue
}
out = append(out, []int(strings.ToUpper(tr))...)
continue
}
out = append(out, []int(tr)...)
} else {
out = append(out, rune)
}
}
return string(out)
}
func ConvertToUnderscore(camel string) (string, error) {
var prevRune rune
var underscore []rune
for index, runeChar := range camel {
if index == 0 {
if !unicode.IsLetter(runeChar) {
return "", fmt.Errorf("Table and column names can't start with a character other than a letter.")
}
underscore = append(underscore, unicode.ToLower(runeChar))
prevRune = runeChar
} else {
if runeChar == '_' || unicode.IsLetter(runeChar) || unicode.IsDigit(runeChar) {
//Look for Upper case letters, append _ and make character lower case
if unicode.IsUpper(runeChar) {
if !unicode.IsUpper(prevRune) {
underscore = append(underscore, '_')
}
underscore = append(underscore, unicode.ToLower(runeChar))
} else {
underscore = append(underscore, runeChar)
}
} else {
return "", fmt.Errorf("Table and column names can't contain non-alphanumeric characters.")
}
}
prevRune = runeChar
}
return string(underscore), nil
}
// UnderscoreMapper converts CamelCase strings to their camel_case
// counterpart
func UnderscoreMapper(str string) string {
var (
parts = []string{}
cur = []rune{}
last2 = [2]rune{}
)
for _, c := range str {
if unicode.IsUpper(c) {
if last2[1] != 0 && unicode.IsLower(last2[1]) {
parts = append(parts, string(cur))
cur = nil
}
cur = append(cur, unicode.ToLower(c))
} else {
if last2[0] != 0 && last2[1] != 0 && unicode.IsUpper(last2[0]) && unicode.IsUpper(last2[1]) {
parts = append(parts, string(cur[:len(cur)-1]))
cur = []rune{cur[len(cur)-1]}
}
cur = append(cur, c)
}
last2[0] = last2[1]
last2[1] = c
}
if len(cur) > 0 {
parts = append(parts, string(cur))
}
return strings.Join(parts, "_")
}
func getFuncs(prog *ssa.Program, pkg *ssa.Package) []*ssa.Function {
funcs := make([]*ssa.Function, 0, len(pkg.Members))
for _, mem := range pkg.Members {
fn, ok := mem.(*ssa.Function)
if ok {
if iu := unicode.IsUpper(rune(fn.Name()[0])); iu || *nonExp {
funcs = append(funcs, fn)
}
}
typ, ok := mem.(*ssa.Type)
if ok {
mset := prog.MethodSets.MethodSet(typ.Type())
for i, n := 0, mset.Len(); i < n; i++ {
if mf := prog.MethodValue(mset.At(i)); mf != nil {
if mfn := mf.Name(); len(mfn) > 0 {
if iu := unicode.IsUpper(rune(mfn[0])); iu || *nonExp {
funcs = append(funcs, mf)
//fmt.Printf("DEBUG method %v %v\n", mfn, mf)
}
}
}
}
}
}
return funcs
}
func Rename(filename string, line int, column int, newName string) (ok bool, err *errors.GoRefactorError) {
if ok, err = CheckRenameParameters(filename, line, column, newName); !ok {
return
}
programTree := parseProgram(filename)
var sym st.Symbol
if sym, err = programTree.FindSymbolByPosition(filename, line, column); err == nil {
if _, ok := sym.(*st.PointerTypeSymbol); ok {
panic("find by position returned pointer type!!!")
}
if st.IsPredeclaredIdentifier(sym.Name()) {
return false, errors.UnrenamableIdentifierError(sym.Name(), " It's a basic language symbol")
}
if sym.PackageFrom().IsGoPackage {
return false, errors.UnrenamableIdentifierError(sym.Name(), " It's a symbol,imported from go library")
}
if unicode.IsUpper(int(sym.Name()[0])) && !unicode.IsUpper(int(newName[0])) ||
unicode.IsLower(int(sym.Name()[0])) && !unicode.IsLower(int(newName[0])) {
return false, &errors.GoRefactorError{ErrorType: "Can't rename identifier", Message: "can't change access modifier. Changing first letter's case can cause errors."}
}
if _, ok := sym.Scope().LookUp(newName, filename); ok {
return false, errors.IdentifierAlreadyExistsError(newName)
}
if meth, ok := sym.(*st.FunctionSymbol); ok {
if meth.IsInterfaceMethod {
return false, errors.UnrenamableIdentifierError(sym.Name(), " It's an interface method")
}
}
if ps, ok := sym.(*st.PackageSymbol); ok {
pack, file := programTree.FindPackageAndFileByFilename(filename)
impDecl := findImportDecl(pack, file, ps)
if impDecl == nil {
panic("couldn't find import decl")
}
if impDecl.Name == nil || impDecl.Name.Name == "" {
impDecl.Name = ast.NewIdent(newName)
}
}
fnames, fsets, files, err := renameSymbol(sym, newName, programTree)
if err == nil {
for i, f := range fnames {
programTree.SaveFileExplicit(f, fsets[i], files[i])
}
}
return err == nil, err
} else {
return false, err
}
panic("unreachable code")
}
func Snake(name string) (r string) {
// first two letters are upcase like URL, MD5, HTTPRequest etc, keep it as it is.
if len(name) >= 2 {
if unicode.IsUpper([]rune(name)[0]) && (unicode.IsUpper([]rune(name)[1]) || unicode.IsNumber([]rune(name)[1])) {
return name
}
}
r = strings.ToLower(name[:1]) + name[1:]
return
}
func isUpperFold(rune int) bool {
if unicode.IsUpper(rune) {
return true
}
c := unicode.SimpleFold(rune)
for c != rune {
if unicode.IsUpper(c) {
return true
}
c = unicode.SimpleFold(c)
}
return false
}
func lintCapAndPunct(s string) (isCap, isPunct bool) {
first, firstN := utf8.DecodeRuneInString(s)
last, _ := utf8.DecodeLastRuneInString(s)
isPunct = last == '.' || last == ':' || last == '!'
isCap = unicode.IsUpper(first)
if isCap && len(s) > firstN {
// Don't flag strings starting with something that looks like an initialism.
if second, _ := utf8.DecodeRuneInString(s[firstN:]); unicode.IsUpper(second) {
isCap = false
}
}
return
}
// firstSentenceLen returns the length of the first sentence in s.
// The sentence ends after the first period followed by space and
// not preceded by exactly one uppercase letter.
//
func firstSentenceLen(s string) int {
var ppp, pp, p rune
for i, q := range s {
if q == '\n' || q == '\r' || q == '\t' {
q = ' '
}
if q == ' ' && p == '.' && (!unicode.IsUpper(pp) || unicode.IsUpper(ppp)) {
return i
}
ppp, pp, p = pp, p, q
}
return len(s)
}
func CompareMethodsByVisibility(d1 *ast.FuncDecl, d2 *ast.FuncDecl) int {
n1 := getDeclName(d1)
n2 := getDeclName(d2)
b1 := unicode.IsUpper(int(n1[0]))
b2 := unicode.IsUpper(int(n2[0]))
switch {
case b1 && !b2:
return 1
case !b1 && b2:
return -1
}
return 0
}
func extraUpperCaseEntropy(match match.Match) float64 {
word := match.Token
allLower := true
for _, char := range word {
if unicode.IsUpper(char) {
allLower = false
break
}
}
if allLower {
return float64(0)
}
//a capitalized word is the most common capitalization scheme,
//so it only doubles the search space (uncapitalized + capitalized): 1 extra bit of entropy.
//allcaps and end-capitalized are common enough too, underestimate as 1 extra bit to be safe.
for _, regex := range []string{START_UPPER, END_UPPER, ALL_UPPER} {
matcher := regexp.MustCompile(regex)
if matcher.MatchString(word) {
return float64(1)
}
}
//Otherwise calculate the number of ways to capitalize U+L uppercase+lowercase letters with U uppercase letters or
//less. Or, if there's more uppercase than lower (for e.g. PASSwORD), the number of ways to lowercase U+L letters
//with L lowercase letters or less.
countUpper, countLower := float64(0), float64(0)
for _, char := range word {
if unicode.IsUpper(char) {
countUpper++
} else if unicode.IsLower(char) {
countLower++
}
}
totalLenght := countLower + countUpper
var possibililities float64
for i := float64(0); i <= math.Min(countUpper, countLower); i++ {
possibililities += float64(zxcvbn_math.NChoseK(totalLenght, i))
}
if possibililities < 1 {
return float64(1)
}
return float64(math.Log2(possibililities))
}
func camelToUnderscore(name string) string {
rv := ""
for i, r := range name {
if unicode.IsUpper(r) && i != 0 {
rv += "_"
rv += string(unicode.ToLower(r))
} else if unicode.IsUpper(r) && i == 0 {
rv += string(unicode.ToLower(r))
} else {
rv += string(r)
}
}
return rv
}
// camelToSnakeCase converts a string containing one or more camel
// cased words into their snake cased equivalents. For example,
// "CamelCase" results in "camel_case".
func camelToSnakeCase(s string) string {
result := ""
boundary := true // Are we on a word boundary?
for _, r := range s {
if unicode.IsUpper(r) && !boundary {
result += "_" + string(unicode.ToLower(r))
} else if unicode.IsUpper(r) {
result += string(unicode.ToLower(r))
} else {
result += string(r)
}
boundary = !(unicode.IsLetter(r) || unicode.IsDigit(r))
}
return result
}
func firstSentence(s string) string {
i := -1 // index+1 of first period
j := -1 // index+1 of first period that is followed by white space
prev := 'A'
for k, ch := range s {
k1 := k + 1
if ch == '.' {
if i < 0 {
i = k1 // first period
}
if k1 < len(s) && s[k1] <= ' ' {
if j < 0 {
j = k1 // first period followed by white space
}
if !unicode.IsUpper(prev) {
j = k1
break
}
}
}
prev = ch
}
if j < 0 {
// use the next best period
j = i
if j < 0 {
// no period at all, use the entire string
j = len(s)
}
}
return s[0:j]
}
func firstSentence(s string) string {
i := -1 // index+1 of first terminator (punctuation ending a sentence)
j := -1 // index+1 of first terminator followed by white space
prev := 'A'
for k, ch := range s {
k1 := k + 1
if ch == '.' || ch == '!' || ch == '?' {
if i < 0 {
i = k1 // first terminator
}
if k1 < len(s) && s[k1] <= ' ' {
if j < 0 {
j = k1 // first terminator followed by white space
}
if !unicode.IsUpper(prev) {
j = k1
break
}
}
}
prev = ch
}
if j < 0 {
// use the next best terminator
j = i
if j < 0 {
// no terminator at all, use the entire string
j = len(s)
}
}
return s[0:j]
}
func isSecretStrengthOk(pass string) error {
extraCnt := 0
digitCnt := 0
upperCaseCnt := 0
lowerCaseCnt := 0
for _, c := range extraCharStr {
extraCnt += strings.Count(pass, string(c))
}
for _, c := range pass {
if unicode.IsUpper(c) {
upperCaseCnt++
} else if unicode.IsLower(c) {
lowerCaseCnt++
} else if unicode.IsDigit(c) {
digitCnt++
}
}
if len(pass) < minSecretLen || extraCnt < minExtraChars || digitCnt < minDigits ||
upperCaseCnt < minUpperCase || lowerCaseCnt < minLowerCase {
return fmt.Errorf("The secure storage secret does not pass the secret strength test. In order to be strong, the password must adhere to all of the following:\nContains at least %v characters\nInclude at least: %v digits\nInclude at least %v letters where at least %v must be upper-case and at least %v must be lower-case\nInclude at least %v special characters from the following list:\nSpecial characters: '%v'",
minSecretLen, minDigits, minUpperCase+minLowerCase, minUpperCase, minLowerCase, minExtraChars, extraCharStr)
}
return nil
}
// Exported returns whether the identifier is exported.
func (n *Identifier) Exported() bool {
r, sz := utf8.DecodeRuneInString(n.Name)
if r == utf8.RuneError && sz == 1 {
return false
}
return unicode.IsUpper(r)
}
// SnakeCase produces the snake_case version of the given CamelCase string.
func SnakeCase(name string) string {
for u, l := range toLower {
name = strings.Replace(name, u, l, -1)
}
var b bytes.Buffer
var lastUnderscore bool
ln := len(name)
if ln == 0 {
return ""
}
b.WriteRune(unicode.ToLower(rune(name[0])))
for i := 1; i < ln; i++ {
r := rune(name[i])
nextIsLower := false
if i < ln-1 {
n := rune(name[i+1])
nextIsLower = unicode.IsLower(n) && unicode.IsLetter(n)
}
if unicode.IsUpper(r) {
if !lastUnderscore && nextIsLower {
b.WriteRune('_')
lastUnderscore = true
}
b.WriteRune(unicode.ToLower(r))
} else {
b.WriteRune(r)
lastUnderscore = false
}
}
return b.String()
}
func exportname(s string) bool {
if r := s[0]; r < utf8.RuneSelf {
return 'A' <= r && r <= 'Z'
}
r, _ := utf8.DecodeRuneInString(s)
return unicode.IsUpper(r)
}
func (h *HeaderFile) addBasicMethods(f *Function, fname string, fnamePrefix string, rt Receiver) bool {
if len(f.Parameters) == 0 && h.IsEnumOrStruct(f.ReturnType.GoName) {
rtc := rt
rtc.Type = f.ReturnType
fname = TrimCommonFunctionNamePrefix(fname)
if fname == "" {
fname = f.ReturnType.GoName
}
if strings.HasPrefix(f.CName, "clang_create") || strings.HasPrefix(f.CName, "clang_get") || strings.HasSuffix(f.CName, "_create") {
fname = "New" + fname
}
return h.addMethod(f, fname, fnamePrefix, rtc)
} else if (fname[0] == 'i' && fname[1] == 's' && unicode.IsUpper(rune(fname[2]))) || (fname[0] == 'h' && fname[1] == 'a' && fname[2] == 's' && unicode.IsUpper(rune(fname[3]))) {
f.ReturnType.GoName = "bool"
return h.addMethod(f, fname, fnamePrefix, rt)
} else if len(f.Parameters) == 1 && h.IsEnumOrStruct(f.Parameters[0].Type.GoName) && strings.HasPrefix(fname, "dispose") && f.ReturnType.GoName == "void" {
fname = "Dispose"
return h.addMethod(f, fname, fnamePrefix, rt)
} else if len(f.Parameters) == 2 && strings.HasPrefix(fname, "equal") && h.IsEnumOrStruct(f.Parameters[0].Type.GoName) && f.Parameters[0].Type == f.Parameters[1].Type {
fname = "Equal"
f.Parameters[0].Name = commonReceiverName(f.Parameters[0].Type.GoName)
f.Parameters[1].Name = f.Parameters[0].Name + "2"
f.ReturnType.GoName = "bool"
return h.addMethod(f, fname, fnamePrefix, rt)
}
return false
}
func (p *docPrinter) printExamples(name string) {
for _, e := range p.examples {
if !strings.HasPrefix(e.Name, name) {
continue
}
name := e.Name[len(name):]
if name != "" {
if i := strings.LastIndex(name, "_"); i != 0 {
continue
}
name = name[1:]
if r, _ := utf8.DecodeRuneInString(name); unicode.IsUpper(r) {
continue
}
name = strings.Title(name)
}
var node interface{}
if _, ok := e.Code.(*ast.File); ok {
node = e.Play
} else {
node = &printer.CommentedNode{Node: e.Code, Comments: e.Comments}
}
var buf bytes.Buffer
err := (&printer.Config{Tabwidth: 4}).Fprint(&buf, p.fset, node)
if err != nil {
continue
}
// Additional formatting if this is a function body.
b := buf.Bytes()
if i := len(b); i >= 2 && b[0] == '{' && b[i-1] == '}' {
// Remove surrounding braces.
b = b[1 : i-1]
// Unindent
b = bytes.Replace(b, []byte("\n "), []byte("\n"), -1)
// Remove output comment
if j := exampleOutputRx.FindIndex(b); j != nil {
b = bytes.TrimSpace(b[:j[0]])
}
} else {
// Drop output, as the output comment will appear in the code
e.Output = ""
}
// Hide examples for now. I tried displaying comments inline and folded
// and found them both distracting. Consider includling link from doc
// to examples at the end of the page.
/*
p.buf.Write(b)
p.buf.WriteByte('\n')
if e.Output != "" {
p.buf.WriteString(e.Output)
buf.WriteByte('\n')
}
p.buf.WriteByte('\n')
*/
}
}
func test_password(pass string) bool {
// Windows AD password needs at leat 7 characters password, and must contain characters from three of the following five categories:
// uppercase character
// lowercase character
// digit character
// nonalphanumeric characters
// any Unicode character that is categorized as an alphabetic character but is not uppercase or lowercase
if len(pass) < 7 {
return false
}
d := 0
l := 0
u := 0
p := 0
o := 0
for _, c := range pass {
if unicode.IsDigit(c) { // check digit character
d = 1
} else if unicode.IsLower(c) { // check lowercase character
l = 1
} else if unicode.IsUpper(c) { // check uppercase character
u = 1
} else if unicode.IsPunct(c) { // check nonalphanumeric character
p = 1
} else { // other unicode character
o = 1
}
}
if d+l+u+p+o < 3 {
return false
}
return true
}
// Stat calculates statistics for all runes read from r.
func (m *Main) Stat(r io.RuneReader) (Stats, error) {
var stats Stats
for {
// Read next character.
ch, sz, err := r.ReadRune()
if err == io.EOF {
break
} else if err != nil {
return stats, err
}
// Calculate stats.
stats.TotalN++
if unicode.IsControl(ch) {
stats.ControlN++
}
if unicode.IsDigit(ch) {
stats.DigitN++
}
if unicode.IsGraphic(ch) {
stats.GraphicN++
}
if unicode.IsLetter(ch) {
stats.LetterN++
}
if unicode.IsLower(ch) {
stats.LowerN++
}
if unicode.IsMark(ch) {
stats.MarkN++
}
if unicode.IsNumber(ch) {
stats.NumberN++
}
if unicode.IsPrint(ch) {
stats.PrintN++
}
if unicode.IsPunct(ch) {
stats.PunctN++
}
if unicode.IsSpace(ch) {
stats.SpaceN++
}
if unicode.IsSymbol(ch) {
stats.SymbolN++
}
if unicode.IsTitle(ch) {
stats.TitleN++
}
if unicode.IsUpper(ch) {
stats.UpperN++
}
if sz > 1 {
stats.MultiByteN++
}
}
return stats, nil
}
// Emit the Global declarations, run inside the Go class declaration output.
func emitGlobals() {
allPack := rootProgram.AllPackages()
for pkgIdx := range allPack {
pkg := allPack[pkgIdx]
for mName, mem := range pkg.Members {
if mem.Token() == token.VAR {
glob := mem.(*ssa.Global)
pName := glob.Pkg.Object.Name()
//println("DEBUG processing global:", pName, mName)
posStr := CodePosition(glob.Pos())
MakePosHash(glob.Pos()) // mark that we are dealing with this global
if IsValidInPogo(
glob.Type().(*types.Pointer).Elem(), // globals are always pointers to a global
"Global:"+pName+"."+mName+":"+posStr) {
if !hadErrors { // no point emitting code if we have already encounderd an error
isPublic := unicode.IsUpper(rune(mName[0])) // Object value sometimes not available
l := TargetLang
_, _, isOverloaded := LanguageList[l].PackageOverloaded(pName)
if !isOverloaded &&
!(mName == "init$guard" && strings.HasPrefix(glob.RelString(nil), LibRuntimePath) && isDupPkg(pName)) {
fmt.Fprintln(&LanguageList[l].buffer, LanguageList[l].Global(pName, mName, *glob, posStr, isPublic))
}
}
}
}
}
}
}
func isExported(name string) bool {
if name != "" {
r, _ := utf8.DecodeRuneInString(name)
return r != utf8.RuneError && unicode.IsUpper(r)
}
return false
}
// Emit the Global declarations, run inside the Go class declaration output.
func emitGlobals() {
allPack := rootProgram.AllPackages()
sort.Sort(PackageSorter(allPack))
for pkgIdx := range allPack {
pkg := allPack[pkgIdx]
allMem := MemberNamesSorted(pkg)
for _, mName := range allMem {
mem := pkg.Members[mName]
if mem.Token() == token.VAR {
glob := mem.(*ssa.Global)
pName := glob.Pkg.Object.Path() // was .Name()
//println("DEBUG processing global:", pName, mName)
posStr := CodePosition(glob.Pos())
MakePosHash(glob.Pos()) // mark that we are dealing with this global
if IsValidInPogo(
glob.Type().(*types.Pointer).Elem(), // globals are always pointers to a global
"Global:"+pName+"."+mName+":"+posStr) {
if !hadErrors { // no point emitting code if we have already encounderd an error
isPublic := unicode.IsUpper(rune(mName[0])) // Object value sometimes not available
l := TargetLang
fmt.Fprintln(&LanguageList[l].buffer, LanguageList[l].Global(pName, mName, *glob, posStr, isPublic))
}
}
}
}
}
}
// lintName returns a different name if it should be different.
func lintName(name string) (should string) {
// Fast path for simple cases: "_" and all lowercase.
if name == "_" {
return name
}
allLower := true
for _, r := range name {
if !unicode.IsLower(r) {
allLower = false
break
}
}
if allLower {
return name
}
// Split camelCase at any lower->upper transition, and split on underscores.
// Check each word for common initialisms.
runes := []rune(name)
w, i := 0, 0 // index of start of word, scan
for i+1 <= len(runes) {
eow := false // whether we hit the end of a word
if i+1 == len(runes) {
eow = true
} else if runes[i+1] == '_' {
// underscore; shift the remainder forward over any run of underscores
eow = true
n := 1
for i+n+1 < len(runes) && runes[i+n+1] == '_' {
n++
}
copy(runes[i+1:], runes[i+n+1:])
runes = runes[:len(runes)-n]
} else if unicode.IsLower(runes[i]) && unicode.IsUpper(runes[i+1]) {
// lower->upper
eow = true
}
i++
if !eow {
continue
}
// [w,i) is a word.
word := string(runes[w:i])
if u := strings.ToUpper(word); commonInitialisms[u] {
// Keep consistent case, which is lowercase only at the start.
if w == 0 && unicode.IsLower(runes[w]) {
u = strings.ToLower(u)
}
// All the common initialisms are ASCII,
// so we can replace the bytes exactly.
copy(runes[w:], []rune(u))
} else if w > 0 && strings.ToLower(word) == word {
// already all lowercase, and not the first word, so uppercase the first character.
runes[w] = unicode.ToUpper(runes[w])
}
w = i
}
return string(runes)
}
func NewChain(r io.Reader, prefixSize int) (c *Chain, err error) {
input, err := ioutil.ReadAll(r)
if err != nil {
return nil, err
}
words := strings.Fields(string(input))
c = &Chain{}
c.prefixes = make([]Prefix, 0)
c.chain = make(map[string][]string)
for i := 0; i < len(words)-prefixSize; i++ {
prefix := Prefix(words[i : i+prefixSize])
c.Add(prefix, words[i+prefixSize])
c.prefixes = append(c.prefixes, prefix)
if unicode.IsUpper(rune(prefix[0][0])) {
c.starters = append(c.starters, prefix)
}
}
if len(c.starters) == 0 {
c.starters = c.prefixes
}
return c, nil
}