Repository: Konstantin8105/c4go
Pull request #472 (2019-10-21 15:20:23)

Uncapitalize error strings. Add leading whitespace to comments

codecov[bot]: # [Codecov](https://codecov.io/gh/Konstantin8105/c4go/pull/472?src=pr&el=h1) Report
> Merging [#472](https://codecov.io/gh/Konstantin8105/c4go/pull/472?src=pr&el=desc) into [master](https://codecov.io/gh/Konstantin8105/c4go/commit/d6daa32640950f6443c79f2f2c0e7d507b717a7d?src=pr&el=desc) will **not change** coverage.
> The diff coverage is `25.53%`.

[![Impacted file tree graph](https://codecov.io/gh/Konstantin8105/c4go/pull/472/graphs/tree.svg?width=650&token=esH2rHXlZ2&height=150&src=pr)](https://codecov.io/gh/Konstantin8105/c4go/pull/472?src=pr&el=tree)

```diff
@@           Coverage Diff           @@
##           master     #472   +/-   ##
=======================================
  Coverage   84.78%   84.78%           
=======================================
  Files         192      192           
  Lines       11939    11939           
=======================================
  Hits        10123    10123           
  Misses       1324     1324           
  Partials      492      492
```


| [Impacted Files](https://codecov.io/gh/Konstantin8105/c4go/pull/472?src=pr&el=tree) | Coverage Δ | |
|---|---|---|
| [noarch/string.go](https://codecov.io/gh/Konstantin8105/c4go/pull/472/diff?src=pr&el=tree#diff-bm9hcmNoL3N0cmluZy5nbw==) | `83.33% <ø> (ø)` | :arrow_up: |
| [noarch/stdio.go](https://codecov.io/gh/Konstantin8105/c4go/pull/472/diff?src=pr&el=tree#diff-bm9hcmNoL3N0ZGlvLmdv) | `81.45% <ø> (ø)` | :arrow_up: |
| [types/dereference.go](https://codecov.io/gh/Konstantin8105/c4go/pull/472/diff?src=pr&el=tree#diff-dHlwZXMvZGVyZWZlcmVuY2UuZ28=) | `81.25% <0%> (ø)` | :arrow_up: |
| [transpiler/enum.go](https://codecov.io/gh/Konstantin8105/c4go/pull/472/diff?src=pr&el=tree#diff-dHJhbnNwaWxlci9lbnVtLmdv) | `79.6% <0%> (ø)` | :arrow_up: |
| [transpiler/value\_to\_pointer.go](https://codecov.io/gh/Konstantin8105/c4go/pull/472/diff?src=pr&el=tree#diff-dHJhbnNwaWxlci92YWx1ZV90b19wb2ludGVyLmdv) | `82.95% <0%> (ø)` | :arrow_up: |
| [transpiler/vaarg.go](https://codecov.io/gh/Konstantin8105/c4go/pull/472/diff?src=pr&el=tree#diff-dHJhbnNwaWxlci92YWFyZy5nbw==) | `87.87% <0%> (ø)` | :arrow_up: |
| [transpiler/literals.go](https://codecov.io/gh/Konstantin8105/c4go/pull/472/diff?src=pr&el=tree#diff-dHJhbnNwaWxlci9saXRlcmFscy5nbw==) | `91.3% <0%> (ø)` | :arrow_up: |
| [util/util.go](https://codecov.io/gh/Konstantin8105/c4go/pull/472/diff?src=pr&el=tree#diff-dXRpbC91dGlsLmdv) | `84.88% <0%> (ø)` | :arrow_up: |
| [debug.go](https://codecov.io/gh/Konstantin8105/c4go/pull/472/diff?src=pr&el=tree#diff-ZGVidWcuZ28=) | `80.47% <0%> (ø)` | :arrow_up: |
| [transpiler/scope.go](https://codecov.io/gh/Konstantin8105/c4go/pull/472/diff?src=pr&el=tree#diff-dHJhbnNwaWxlci9zY29wZS5nbw==) | `82.85% <0%> (ø)` | :arrow_up: |
| ... and [22 more](https://codecov.io/gh/Konstantin8105/c4go/pull/472/diff?src=pr&el=tree-more) | |

------

[Continue to review full report at Codecov](https://codecov.io/gh/Konstantin8105/c4go/pull/472?src=pr&el=continue).
> **Legend** - [Click here to learn more](https://docs.codecov.io/docs/codecov-delta)
> `Δ = absolute <relative> (impact)`, `ø = not affected`, `? = missing data`
> Powered by [Codecov](https://codecov.io/gh/Konstantin8105/c4go/pull/472?src=pr&el=footer). Last update [d6daa32...bfab887](https://codecov.io/gh/Konstantin8105/c4go/pull/472?src=pr&el=lastupdated). Read the [comment docs](https://docs.codecov.io/docs/pull-request-comments).

Konstantin8105: Hello
Could you clarify the reason for that changes?
alexandear: @Konstantin8105 according to official  golang style "Error strings should not be capitalized" https://github.com/golang/go/wiki/CodeReviewComments#error-strings
Konstantin8105: @alexandear Thank you.

Patch:
diff --git a/ast/ast.go b/ast/ast.go
index 6866b8b..d690473 100644
--- a/ast/ast.go
+++ b/ast/ast.go
@@ -39,7 +39,7 @@ func ParseAddress(address string) Address {
 func Parse(fullline string) (returnNode Node, err error) {
 	defer func() {
 		if r := recover(); r != nil {
-			err = fmt.Errorf("Cannot parse line: `%v`. %v", fullline, r)
+			err = fmt.Errorf("cannot parse line: `%v`. %v", fullline, r)
 			returnNode = C4goErrorNode{}
 		}
 	}()
diff --git a/debug.go b/debug.go
index 6caecdb..b8a5fc7 100644
--- a/debug.go
+++ b/debug.go
@@ -196,7 +196,7 @@ func generateDebugCCode(args ProgramArgs, lines []string, filePP preprocessor.Fi
 			i, errs[i].Error())
 	}
 	if tree == nil {
-		return fmt.Errorf("Cannot create tree: tree is nil. Please try another version of clang")
+		return fmt.Errorf("cannot create tree: tree is nil. Please try another version of clang")
 	}
 
 	// Example of AST:
diff --git a/main.go b/main.go
index 4e5e091..08dc6f0 100644
--- a/main.go
+++ b/main.go
@@ -373,7 +373,7 @@ func Start(args ProgramArgs) (err error) {
 		err = generateDebugCCode(args, lines, filePP)
 
 	default:
-		err = fmt.Errorf("Program state `%d` is not implemented", args.state)
+		err = fmt.Errorf("program state `%d` is not implemented", args.state)
 	}
 
 	return err
@@ -388,7 +388,7 @@ func generateAstLines(args ProgramArgs) (lines []string, filePP preprocessor.Fil
 	for _, in := range args.inputFiles {
 		_, err = os.Stat(in)
 		if err != nil {
-			err = fmt.Errorf("Input file `%s` is not found", in)
+			err = fmt.Errorf("input file `%s` is not found", in)
 			return
 		}
 	}
@@ -411,7 +411,7 @@ func generateAstLines(args ProgramArgs) (lines []string, filePP preprocessor.Fil
 	}
 	dir, err := ioutil.TempDir("", "c4go")
 	if err != nil {
-		err = fmt.Errorf("Cannot create temp folder: %v", err)
+		err = fmt.Errorf("cannot create temp folder: %v", err)
 		return
 	}
 	defer os.RemoveAll(dir) // clean up
@@ -489,7 +489,7 @@ func generateGoCode(args ProgramArgs, lines []string, filePP preprocessor.FilePP
 		p.AddMessage(errs[i].Error())
 	}
 	if tree == nil {
-		return fmt.Errorf("Cannot create tree: tree is nil. Please try another version of clang")
+		return fmt.Errorf("cannot create tree: tree is nil. Please try another version of clang")
 	}
 
 	// avoid Go keywords
diff --git a/noarch/stdio.go b/noarch/stdio.go
index 8015364..57311cd 100644
--- a/noarch/stdio.go
+++ b/noarch/stdio.go
@@ -611,7 +611,7 @@ func Fwrite(str []byte, size1, size2 int32, stream *File) int32 {
 // fsetpos.
 //
 // The ftell function can be used to retrieve the current position in the stream
-//as an integer value.
+// as an integer value.
 func Fgetpos(f *File, pos []int32) int32 {
 	absolutePos := int32(Fseek(f, 0, 1))
 	if pos != nil {
diff --git a/noarch/string.go b/noarch/string.go
index a8e182d..aafbc2a 100644
--- a/noarch/string.go
+++ b/noarch/string.go
@@ -111,7 +111,7 @@ func Strchr(str []byte, ch32 int32) []byte {
 
 // Strstr finds the first occurrence of the null-terminated byte string
 // pointed to by substr in the null-terminated byte string pointed to by str.
-//The terminating null characters are not compared.
+// The terminating null characters are not compared.
 func Strstr(str, subStr []byte) []byte {
 	if subStr == nil {
 		return str
diff --git a/preprocessor/parse_include_list.go b/preprocessor/parse_include_list.go
index 4f3ebb3..e323883 100644
--- a/preprocessor/parse_include_list.go
+++ b/preprocessor/parse_include_list.go
@@ -33,7 +33,7 @@ func parseIncludeList(line string) (lines []string, err error) {
 			}
 			partLines, err = parseIncludeList(block)
 			if err != nil {
-				return lines, fmt.Errorf("Part of lines : %v. %v", i, err)
+				return lines, fmt.Errorf("part of lines : %v. %v", i, err)
 			}
 			lines = append(lines, partLines...)
 		}
@@ -42,7 +42,7 @@ func parseIncludeList(line string) (lines []string, err error) {
 
 	index := strings.Index(line, ":")
 	if index < 0 {
-		err = fmt.Errorf("Cannot find `:` in line : %v", line)
+		err = fmt.Errorf("cannot find `:` in line : %v", line)
 		return
 	}
 	line = line[index+1:]
diff --git a/preprocessor/parse_include_preprocessor_line.go b/preprocessor/parse_include_preprocessor_line.go
index 1425232..1ab1a81 100644
--- a/preprocessor/parse_include_preprocessor_line.go
+++ b/preprocessor/parse_include_preprocessor_line.go
@@ -10,23 +10,23 @@ import (
 // # 11 "/usr/include/x86_64-linux-gnu/gnu/stubs.h" 2 3 4
 func parseIncludePreprocessorLine(line string) (item *entity, err error) {
 	if line[0] != '#' {
-		err = fmt.Errorf("Cannot parse: first symbol is not # in line %s", line)
+		err = fmt.Errorf("cannot parse: first symbol is not # in line %s", line)
 		return
 	}
 	i := strings.Index(line, "\"")
 	if i < 0 {
-		err = fmt.Errorf("First index is not correct on line %s", line)
+		err = fmt.Errorf("first index is not correct on line %s", line)
 		return
 	}
 	l := strings.LastIndex(line, "\"")
 	if i >= l {
-		err = fmt.Errorf("Not allowable positions of symbol \" (%d and %d) in line : %s", i, l, line)
+		err = fmt.Errorf("not allowable positions of symbol \" (%d and %d) in line : %s", i, l, line)
 		return
 	}
 
 	pos, err := strconv.ParseInt(strings.TrimSpace(line[1:i]), 10, 64)
 	if err != nil {
-		err = fmt.Errorf("Cannot parse position in source : %v", err)
+		err = fmt.Errorf("cannot parse position in source : %v", err)
 		return
 	}
 
diff --git a/preprocessor/preprocessor.go b/preprocessor/preprocessor.go
index 6025745..03d0773 100644
--- a/preprocessor/preprocessor.go
+++ b/preprocessor/preprocessor.go
@@ -121,7 +121,7 @@ func NewFilePP(inputFiles, clangFlags []string, cppCode bool) (
 	f FilePP, err error) {
 	defer func() {
 		if err != nil {
-			err = fmt.Errorf("Preprocess error : %v", err)
+			err = fmt.Errorf("preprocess error : %v", err)
 		}
 	}()
 
@@ -388,7 +388,7 @@ again:
 			if col-1 < len([]byte(*l)) {
 				return []byte((*l)[col-1:]), nil
 			}
-			err = fmt.Errorf("Empty snippet")
+			err = fmt.Errorf("empty snippet")
 			return
 		}
 		if col <= 0 {
@@ -400,7 +400,7 @@ again:
 		return []byte((*l)[col-1 : colEnd]), nil
 	}
 
-	err = fmt.Errorf("Snippet is not found")
+	err = fmt.Errorf("snippet is not found")
 	return
 }
 
@@ -434,7 +434,7 @@ func analyzeFiles(inputFiles, clangFlags []string, cppCode bool) (
 			}
 			item, err = parseIncludePreprocessorLine(line)
 			if err != nil {
-				err = fmt.Errorf("Cannot parse line : %s with error: %s", line, err)
+				err = fmt.Errorf("cannot parse line : %s with error: %s", line, err)
 				return
 			}
 			if item.positionInSource == 0 {
@@ -600,7 +600,7 @@ func getIncludeList(inputFiles, clangFlags []string, flag []string, cppCode bool
 	_ string, err error) {
 	defer func() {
 		if err != nil {
-			err = fmt.Errorf("Cannot get Include List : %v", err)
+			err = fmt.Errorf("cannot get Include List : %v", err)
 		}
 	}()
 	var out bytes.Buffer
diff --git a/program/definition_function.go b/program/definition_function.go
index ac1a21f..5024352 100644
--- a/program/definition_function.go
+++ b/program/definition_function.go
@@ -347,7 +347,7 @@ func (p *Program) GetIncludeFileNameByFunctionSignature(
 			rightPart := strings.TrimSpace(baseFunction[pos:])
 			index := strings.LastIndex(leftPart, " ")
 			if index < 0 {
-				err = fmt.Errorf("Cannot found space ` ` in %v", leftPart)
+				err = fmt.Errorf("cannot found space ` ` in %v", leftPart)
 				return
 			}
 			if strings.Replace(functionName, " ", "", -1) !=
diff --git a/program/struct.go b/program/struct.go
index 939b8a0..8e99628 100644
--- a/program/struct.go
+++ b/program/struct.go
@@ -39,7 +39,7 @@ type Struct struct {
 func NewStruct(p *Program, n *ast.RecordDecl) (st *Struct, err error) {
 	defer func() {
 		if err != nil {
-			err = fmt.Errorf("Cannot create new structure : %T. Error : %v",
+			err = fmt.Errorf("cannot create new structure : %T. Error : %v",
 				n, err)
 		} else {
 			p.Structs[n.Name] = st
@@ -89,7 +89,7 @@ func NewStruct(p *Program, n *ast.RecordDecl) (st *Struct, err error) {
 	case "struct":
 		t = StructType
 	default:
-		err = fmt.Errorf("Undefine kind of RecordDecl `%v`", n.Kind)
+		err = fmt.Errorf("undefine kind of RecordDecl `%v`", n.Kind)
 		return
 	}
 
@@ -119,13 +119,13 @@ func (p *Program) IsUnion(cType string) bool {
 	}
 	if t, ok := p.GetBaseTypeOfTypedef(cType); ok {
 		if t == cType {
-			panic(fmt.Errorf("Cannot be same name: %s", t))
+			panic(fmt.Errorf("cannot be same name: %s", t))
 		}
 		if strings.HasPrefix(t, "struct ") {
 			return false
 		}
 		if t == "" {
-			panic(fmt.Errorf("Type cannot be empty"))
+			panic(fmt.Errorf("type cannot be empty"))
 		}
 		return p.IsUnion(t)
 	}
@@ -138,7 +138,7 @@ func (p *Program) GetBaseTypeOfTypedef(cTypedef string) (
 
 	cBase, ok = p.TypedefType[cTypedef]
 	if cBase == "" && ok {
-		panic(fmt.Errorf("Type cannot be empty"))
+		panic(fmt.Errorf("type cannot be empty"))
 	}
 
 	if cBase == cTypedef {
diff --git a/transpiler/binary.go b/transpiler/binary.go
index 556946b..78fade6 100644
--- a/transpiler/binary.go
+++ b/transpiler/binary.go
@@ -25,7 +25,7 @@ func transpileBinaryOperatorComma(n *ast.BinaryOperator, p *program.Program) (
 	stmt goast.Stmt, preStmts []goast.Stmt, err error) {
 	defer func() {
 		if err != nil {
-			err = fmt.Errorf("Cannot transpile operator comma : err = %v", err)
+			err = fmt.Errorf("cannot transpile operator comma : err = %v", err)
 			p.AddMessage(p.GenerateWarningMessage(err, n))
 		}
 	}()
@@ -42,7 +42,7 @@ func transpileBinaryOperatorComma(n *ast.BinaryOperator, p *program.Program) (
 
 	if left == nil || right == nil {
 		return nil, nil,
-			fmt.Errorf("Cannot transpile binary operator comma: right = %v , left = %v",
+			fmt.Errorf("cannot transpile binary operator comma: right = %v , left = %v",
 				right, left)
 	}
 
@@ -64,7 +64,7 @@ func transpileBinaryOperator(n *ast.BinaryOperator, p *program.Program, exprIsSt
 	defer func() {
 		if err != nil {
 			err = fmt.Errorf(
-				"Cannot transpile BinaryOperator with type '%s' :"+
+				"cannot transpile BinaryOperator with type '%s' :"+
 					" result type = {%s}. Error: %v", n.Type, eType, err)
 			p.AddMessage(p.GenerateWarningMessage(err, n))
 		}
@@ -234,7 +234,7 @@ func transpileBinaryOperator(n *ast.BinaryOperator, p *program.Program, exprIsSt
 		// from n.Children()[1]
 		if len(newPre) > 0 || len(newPost) > 0 {
 			p.AddMessage(p.GenerateWarningMessage(
-				fmt.Errorf("Not support length pre or post stmts: {%d,%d}",
+				fmt.Errorf("not support length pre or post stmts: {%d,%d}",
 					len(newPre), len(newPost)), n))
 		}
 		return stmts, st, preStmts, postStmts, nil
@@ -282,7 +282,7 @@ func transpileBinaryOperator(n *ast.BinaryOperator, p *program.Program, exprIsSt
 					return
 				}
 				if expr == nil {
-					return nil, "", nil, nil, fmt.Errorf("Expr is nil")
+					return nil, "", nil, nil, fmt.Errorf("expr is nil")
 				}
 				preStmts, postStmts =
 					combinePreAndPostStmts(preStmts, postStmts, newPre, newPost)
@@ -370,7 +370,7 @@ func transpileBinaryOperator(n *ast.BinaryOperator, p *program.Program, exprIsSt
 			// ignore
 
 		default:
-			err = fmt.Errorf("Not implemented pointer operation: %v", operator)
+			err = fmt.Errorf("not implemented pointer operation: %v", operator)
 			return
 		}
 	}
@@ -464,7 +464,7 @@ func transpileBinaryOperator(n *ast.BinaryOperator, p *program.Program, exprIsSt
 				return
 			}
 			if expr == nil {
-				return nil, "", nil, nil, fmt.Errorf("Expr is nil")
+				return nil, "", nil, nil, fmt.Errorf("expr is nil")
 			}
 			preStmts, postStmts =
 				combinePreAndPostStmts(preStmts, postStmts, newPre, newPost)
diff --git a/transpiler/branch.go b/transpiler/branch.go
index 11866dc..2091e82 100644
--- a/transpiler/branch.go
+++ b/transpiler/branch.go
@@ -22,7 +22,7 @@ func transpileIfStmt(n *ast.IfStmt, p *program.Program) (
 
 	defer func() {
 		if err != nil {
-			err = fmt.Errorf("Cannot transpileIfStmt. %v", err)
+			err = fmt.Errorf("cannot transpileIfStmt. %v", err)
 		}
 	}()
 
@@ -72,7 +72,7 @@ func transpileIfStmt(n *ast.IfStmt, p *program.Program) (
 	// expression - assignment operators need to be wrapped in closures.
 	conditional, conditionalType, newPre, newPost, err := atomicOperation(children[1], p)
 	if err != nil {
-		err = fmt.Errorf("Cannot transpile for condition. %v", err)
+		err = fmt.Errorf("cannot transpile for condition. %v", err)
 		return nil, nil, nil, err
 	}
 	// null in C is false
@@ -102,12 +102,12 @@ func transpileIfStmt(n *ast.IfStmt, p *program.Program) (
 
 		preStmts, postStmts = combinePreAndPostStmts(preStmts, postStmts, newPre, newPost)
 		if body == nil {
-			return nil, nil, nil, fmt.Errorf("Body of If cannot by nil")
+			return nil, nil, nil, fmt.Errorf("body of If cannot by nil")
 		}
 	}
 
 	if boolCondition == nil {
-		return nil, nil, nil, fmt.Errorf("Bool Condition in If cannot by nil")
+		return nil, nil, nil, fmt.Errorf("bool Condition in If cannot by nil")
 	}
 	r := &goast.IfStmt{
 		Cond: boolCondition,
@@ -130,7 +130,7 @@ func transpileIfStmt(n *ast.IfStmt, p *program.Program) (
 				}
 			}
 		} else {
-			return nil, nil, nil, fmt.Errorf("Body of Else in If cannot be nil")
+			return nil, nil, nil, fmt.Errorf("body of Else in If cannot be nil")
 		}
 	}
 
@@ -144,7 +144,7 @@ func transpileForStmt(n *ast.ForStmt, p *program.Program) (
 	// Please remove after solving all problems
 	defer func() {
 		if err != nil {
-			err = fmt.Errorf("Cannot tranpile ForStmt: err = %v", err)
+			err = fmt.Errorf("cannot tranpile ForStmt: err = %v", err)
 			p.AddMessage(p.GenerateWarningMessage(err, n))
 		}
 	}()
@@ -186,7 +186,7 @@ func transpileForStmt(n *ast.ForStmt, p *program.Program) (
 			// for(c = 0 ; a < 5 ; a++)
 			before, newPre, newPost, err := transpileToStmt(children[0], p)
 			if err != nil {
-				err = fmt.Errorf("Cannot transpile comma binaryoperator. %v",
+				err = fmt.Errorf("cannot transpile comma binaryoperator. %v",
 					err)
 				return nil, nil, nil, err
 			}
@@ -283,7 +283,7 @@ func transpileForStmt(n *ast.ForStmt, p *program.Program) (
 	if !transpilate {
 		post, newPre, newPost, err = transpileToStmt(children[3], p)
 		if err != nil {
-			err = fmt.Errorf("Cannot tranpile children[3] : %v", err)
+			err = fmt.Errorf("cannot tranpile children[3] : %v", err)
 			return nil, nil, nil, err
 		}
 
@@ -374,11 +374,11 @@ func transpileForStmt(n *ast.ForStmt, p *program.Program) (
 	}
 	body, newPre, newPost, err := transpileToBlockStmt(children[4], p)
 	if err != nil {
-		err = fmt.Errorf("Cannot transpile body. %v", err)
+		err = fmt.Errorf("cannot transpile body. %v", err)
 		return nil, nil, nil, err
 	}
 	if body == nil {
-		return nil, nil, nil, fmt.Errorf("Body of For cannot be nil")
+		return nil, nil, nil, fmt.Errorf("body of For cannot be nil")
 	}
 
 	preStmts, postStmts = combinePreAndPostStmts(preStmts, postStmts, newPre, newPost)
@@ -604,7 +604,7 @@ func createIfWithNotConditionAndBreak(condition ast.Node) (ifStmt ast.IfStmt) {
 		par.Type = *typ
 		unitary.Type = *typ
 	} else {
-		panic(fmt.Errorf("Type %T is not implemented in createIfWithNotConditionAndBreak", condition))
+		panic(fmt.Errorf("type %T is not implemented in createIfWithNotConditionAndBreak", condition))
 	}
 
 	par.AddChild(condition)
diff --git a/transpiler/call.go b/transpiler/call.go
index db262f7..c20df58 100644
--- a/transpiler/call.go
+++ b/transpiler/call.go
@@ -206,7 +206,7 @@ func transpileCallExpr(n *ast.CallExpr, p *program.Program) (
 	preStmts []goast.Stmt, postStmts []goast.Stmt, err error) {
 	defer func() {
 		if err != nil {
-			err = fmt.Errorf("Error in transpileCallExpr : %v", err)
+			err = fmt.Errorf("error in transpileCallExpr : %v", err)
 		}
 		if resultType == "" {
 			resultType = n.Type
@@ -374,7 +374,7 @@ func transpileCallExpr(n *ast.CallExpr, p *program.Program) (
 				prefix, _, fields, returns, err := util.ParseFunction(t)
 				if err != nil {
 					p.AddMessage(p.GenerateWarningMessage(fmt.Errorf(
-						"Cannot resolve function : %v", err), n))
+						"cannot resolve function : %v", err), n))
 					return nil, "", nil, nil, err
 				}
 				if len(prefix) != 0 {
@@ -495,7 +495,7 @@ func transpileCallExpr(n *ast.CallExpr, p *program.Program) (
 
 			if realArg == nil {
 				return nil, "", preStmts, postStmts,
-					fmt.Errorf("Real argument is nil in function : %s", functionName)
+					fmt.Errorf("real argument is nil in function : %s", functionName)
 			}
 
 			realArgs = append(realArgs, realArg)
@@ -540,7 +540,7 @@ func transpileCallExpr(n *ast.CallExpr, p *program.Program) (
 
 			if a == nil {
 				return nil, "", preStmts, postStmts,
-					fmt.Errorf("Argument is nil in function : %s", functionName)
+					fmt.Errorf("argument is nil in function : %s", functionName)
 			}
 
 			if len(functionDef.ArgumentTypes) > i {
@@ -586,9 +586,9 @@ func findAndReplaceUnaryExprOrTypeTraitExpr(node *ast.Node) (
 
 	defer func() {
 		if err != nil {
-			err = fmt.Errorf("Cannot findAndReplaceUnaryExprOrTypeTraitExpr: err = %v", err)
+			err = fmt.Errorf("cannot findAndReplaceUnaryExprOrTypeTraitExpr: err = %v", err)
 			if (*node) != nil {
-				err = fmt.Errorf("Code line: %d. %v", (*node).Position().Line, err)
+				err = fmt.Errorf("code line: %d. %v", (*node).Position().Line, err)
 			}
 		}
 	}()
@@ -654,7 +654,7 @@ func transpileCallExprCalloc(expression ast.Node, unary *ast.UnaryExprOrTypeTrai
 	expr *goast.CallExpr, resultType string, preStmts []goast.Stmt, postStmts []goast.Stmt, err error) {
 	defer func() {
 		if err != nil {
-			err = fmt.Errorf("Function: calloc. err = %v", err)
+			err = fmt.Errorf("function: calloc. err = %v", err)
 		}
 	}()
 
@@ -683,7 +683,7 @@ func transpileCallExprQsort(n *ast.CallExpr, p *program.Program) (
 	expr *goast.CallExpr, resultType string, preStmts []goast.Stmt, postStmts []goast.Stmt, err error) {
 	defer func() {
 		if err != nil {
-			err = fmt.Errorf("Function: qsort. err = %v", err)
+			err = fmt.Errorf("function: qsort. err = %v", err)
 		}
 		if resultType == "" {
 			resultType = n.Type
diff --git a/transpiler/cast.go b/transpiler/cast.go
index 0db719e..2b5871f 100644
--- a/transpiler/cast.go
+++ b/transpiler/cast.go
@@ -18,7 +18,7 @@ func transpileImplicitCastExpr(n *ast.ImplicitCastExpr, p *program.Program, expr
 	err error) {
 	defer func() {
 		if err != nil {
-			err = fmt.Errorf("Cannot transpileImplicitCastExpr. err = %v", err)
+			err = fmt.Errorf("cannot transpileImplicitCastExpr. err = %v", err)
 		}
 		if exprType == "" {
 			exprType = "ImplicitCastExprWrongType"
@@ -210,7 +210,7 @@ func transpileCStyleCastExpr(n *ast.CStyleCastExpr, p *program.Program, exprIsSt
 	err error) {
 	defer func() {
 		if err != nil {
-			err = fmt.Errorf("Cannot transpileImplicitCastExpr. err = %v", err)
+			err = fmt.Errorf("cannot transpileImplicitCastExpr. err = %v", err)
 		}
 		if exprType == "" {
 			exprType = "CStyleCastExpr"
diff --git a/transpiler/declarations.go b/transpiler/declarations.go
index 38a733e..12dff0b 100644
--- a/transpiler/declarations.go
+++ b/transpiler/declarations.go
@@ -32,11 +32,11 @@ import (
 func newFunctionField(p *program.Program, name, cType string) (
 	_ *goast.Field, err error) {
 	if name == "" {
-		err = fmt.Errorf("Name of function field cannot be empty")
+		err = fmt.Errorf("name of function field cannot be empty")
 		return
 	}
 	if !util.IsFunction(cType) {
-		err = fmt.Errorf("Cannot create function field for type : %s", cType)
+		err = fmt.Errorf("cannot create function field for type : %s", cType)
 		return
 	}
 
@@ -58,7 +58,7 @@ func transpileFieldDecl(p *program.Program, n *ast.FieldDecl) (
 	defer func() {
 		if field != nil {
 			if field.Type == nil {
-				err = fmt.Errorf("Found nil transpileFieldDecl in field Type %v , %v : %v",
+				err = fmt.Errorf("found nil transpileFieldDecl in field Type %v , %v : %v",
 					n, field, err)
 				field.Type = util.NewIdent(n.Type)
 			}
@@ -157,7 +157,7 @@ func transpileRecordDecl(p *program.Program, n *ast.RecordDecl) (
 					rec.Name = types.GetBaseType(util.GenerateCorrectType(v.Type))
 				default:
 					p.AddMessage(p.GenerateWarningMessage(
-						fmt.Errorf("Cannot find name for anon RecordDecl: %T",
+						fmt.Errorf("cannot find name for anon RecordDecl: %T",
 							v), n))
 					rec.Name = "UndefinedNameC2GO"
 				}
@@ -182,7 +182,7 @@ func transpileRecordDecl(p *program.Program, n *ast.RecordDecl) (
 				// ignore fields without name
 				if len(f.Names) != 1 {
 					p.AddMessage(p.GenerateWarningMessage(
-						fmt.Errorf("Ignore FieldDecl with more then 1 names"+
+						fmt.Errorf("ignore FieldDecl with more then 1 names"+
 							" in RecordDecl : `%v`", n.Name), n))
 					continue
 				}
@@ -239,7 +239,7 @@ func transpileRecordDecl(p *program.Program, n *ast.RecordDecl) (
 			var declsIn []goast.Decl
 			declsIn, err = transpileToNode(field, p)
 			if err != nil {
-				err = fmt.Errorf("Cannot transpile %T : %v", field, err)
+				err = fmt.Errorf("cannot transpile %T : %v", field, err)
 				// p.AddMessage(p.GenerateWarningMessage(err, field))
 				return
 			}
@@ -292,7 +292,7 @@ func transpileRecordDecl(p *program.Program, n *ast.RecordDecl) (
 		}
 
 	default:
-		err = fmt.Errorf("Undefine type of struct : %v", s.Type)
+		err = fmt.Errorf("undefine type of struct : %v", s.Type)
 		return
 	}
 
@@ -339,7 +339,7 @@ func transpileRecordDecl(p *program.Program, n *ast.RecordDecl) (
 		})
 
 	default:
-		err = fmt.Errorf("Undefine type of struct : %v", s.Type)
+		err = fmt.Errorf("undefine type of struct : %v", s.Type)
 		return
 	}
 
@@ -404,7 +404,7 @@ func transpileCXXRecordDecl(p *program.Program, n *ast.RecordDecl) (
 
 		default:
 			p.AddMessage(p.GenerateWarningMessage(
-				fmt.Errorf("Cannot transpilation field: %T", v), n))
+				fmt.Errorf("cannot transpilation field: %T", v), n))
 		}
 	}
 
@@ -432,7 +432,7 @@ func transpileTypedefDecl(p *program.Program, n *ast.TypedefDecl) (
 	}
 	defer func() {
 		if err != nil {
-			err = fmt.Errorf("Cannot transpile Typedef Decl : err = %v", err)
+			err = fmt.Errorf("cannot transpile Typedef Decl : err = %v", err)
 		} else {
 			if !p.IncludeHeaderIsExists(n.Pos.File) {
 				// no need add struct from C STD
@@ -573,7 +573,7 @@ func transpileVarDecl(p *program.Program, n *ast.VarDecl) (
 	decls []goast.Decl, theType string, err error) {
 	defer func() {
 		if err != nil {
-			err = fmt.Errorf("Cannot transpileVarDecl : err = %v", err)
+			err = fmt.Errorf("cannot transpileVarDecl : err = %v", err)
 		}
 	}()
 
@@ -609,12 +609,12 @@ func transpileVarDecl(p *program.Program, n *ast.VarDecl) (
 					var fields, returns []string
 					prefix, fields, returns, err = types.SeparateFunction(p, v.Type)
 					if err != nil {
-						err = fmt.Errorf("Cannot resolve function : %v", err)
+						err = fmt.Errorf("cannot resolve function : %v", err)
 						return
 					}
 					if len(prefix) != 0 {
 						p.AddMessage(p.GenerateWarningMessage(
-							fmt.Errorf("Prefix is not used : `%v`", prefix), n))
+							fmt.Errorf("prefix is not used : `%v`", prefix), n))
 					}
 					functionType := GenerateFuncType(fields, returns)
 					nameVar1 := n.Name
@@ -713,7 +713,7 @@ func transpileVarDecl(p *program.Program, n *ast.VarDecl) (
 
 	if len(preStmts) != 0 || len(postStmts) != 0 {
 		p.AddMessage(p.GenerateWarningMessage(
-			fmt.Errorf("Not acceptable length of Stmt : pre(%d), post(%d)",
+			fmt.Errorf("not acceptable length of Stmt : pre(%d), post(%d)",
 				len(preStmts), len(postStmts)), n))
 	}
 
@@ -731,7 +731,7 @@ func transpileVarDecl(p *program.Program, n *ast.VarDecl) (
 	theType, err = types.ResolveType(p, n.Type)
 	if err != nil {
 		p.AddMessage(p.GenerateWarningMessage(
-			fmt.Errorf("Unknown type used C type, because %v", err), n))
+			fmt.Errorf("unknown type used C type, because %v", err), n))
 		err = nil // Error is ignored
 		theType = n.Type
 	}
diff --git a/transpiler/enum.go b/transpiler/enum.go
index 98e6eae..46ddd5f 100644
--- a/transpiler/enum.go
+++ b/transpiler/enum.go
@@ -42,7 +42,7 @@ func transpileEnumDecl(p *program.Program, n *ast.EnumDecl) (
 	decls []goast.Decl, err error) {
 	defer func() {
 		if err != nil {
-			err = fmt.Errorf("Cannot transpileEnumDecl. %v", err)
+			err = fmt.Errorf("cannot transpileEnumDecl. %v", err)
 		}
 	}()
 
@@ -84,7 +84,7 @@ func transpileEnumDeclWithType(p *program.Program, n *ast.EnumDecl, enumType str
 	decls []goast.Decl, err error) {
 	defer func() {
 		if err != nil {
-			err = fmt.Errorf("Cannot transpileEnumDeclWithName. %v", err)
+			err = fmt.Errorf("cannot transpileEnumDeclWithName. %v", err)
 		}
 	}()
 	preStmts := []goast.Stmt{}
@@ -180,7 +180,7 @@ func transpileEnumDeclWithType(p *program.Program, n *ast.EnumDecl, enumType str
 
 		if len(newPre) > 0 || len(newPost) > 0 {
 			p.AddMessage(p.GenerateWarningMessage(
-				fmt.Errorf("Check - added in code : (%d)(%d)",
+				fmt.Errorf("check - added in code : (%d)(%d)",
 					len(newPre), len(newPost)), n))
 		}
 
@@ -256,7 +256,7 @@ func transpileEnumDeclWithType(p *program.Program, n *ast.EnumDecl, enumType str
 		default:
 			e = val
 			p.AddMessage(p.GenerateWarningMessage(
-				fmt.Errorf("Add support of continues counter for Go type : %#v",
+				fmt.Errorf("add support of continues counter for Go type : %#v",
 					v), n))
 		}
 
diff --git a/transpiler/functions.go b/transpiler/functions.go
index b49ed13..70e4670 100644
--- a/transpiler/functions.go
+++ b/transpiler/functions.go
@@ -47,7 +47,7 @@ func transpileFunctionDecl(n *ast.FunctionDecl, p *program.Program) (
 	decls []goast.Decl, err error) {
 	defer func() {
 		if err != nil {
-			err = fmt.Errorf("Cannot transpileFunctionDecl. %v", err)
+			err = fmt.Errorf("cannot transpileFunctionDecl. %v", err)
 		}
 	}()
 
@@ -87,7 +87,7 @@ func transpileFunctionDecl(n *ast.FunctionDecl, p *program.Program) (
 		var f, r []string
 		pr, _, f, r, err = util.ParseFunction(n.Type)
 		if err != nil {
-			err = fmt.Errorf("Cannot get function definition : %v", err)
+			err = fmt.Errorf("cannot get function definition : %v", err)
 			return
 		}
 		if len(pr) != 0 {
@@ -116,7 +116,7 @@ func transpileFunctionDecl(n *ast.FunctionDecl, p *program.Program) (
 		body, pre, post, err = transpileToBlockStmt(functionBody, p)
 		if err != nil || len(pre) > 0 || len(post) > 0 {
 			p.AddMessage(p.GenerateWarningMessage(
-				fmt.Errorf("Not correct result in function %s body: err = %v",
+				fmt.Errorf("not correct result in function %s body: err = %v",
 					n.Name, err), n))
 			err = nil // Error is ignored
 		}
@@ -253,7 +253,7 @@ func getFieldList(p *program.Program, f *ast.FunctionDecl, fieldTypes []string)
 	_ *goast.FieldList, err error) {
 	defer func() {
 		if err != nil {
-			err = fmt.Errorf("Error in function field list. err = %v", err)
+			err = fmt.Errorf("error in function field list. err = %v", err)
 		}
 	}()
 	r := []*goast.Field{}
@@ -298,7 +298,7 @@ func transpileReturnStmt(n *ast.ReturnStmt, p *program.Program) (
 	_ goast.Stmt, preStmts []goast.Stmt, postStmts []goast.Stmt, err error) {
 	defer func() {
 		if err != nil {
-			err = fmt.Errorf("Cannot transpileReturnStmt. err = %v", err)
+			err = fmt.Errorf("cannot transpileReturnStmt. err = %v", err)
 		}
 	}()
 	// There may not be a return value. Then we don't have to both ourselves
@@ -314,7 +314,7 @@ func transpileReturnStmt(n *ast.ReturnStmt, p *program.Program) (
 		return nil, nil, nil, err
 	}
 	if e == nil {
-		return nil, nil, nil, fmt.Errorf("Expr is nil")
+		return nil, nil, nil, fmt.Errorf("expr is nil")
 	}
 
 	f := p.GetFunctionDefinition(p.Function.Name)
diff --git a/transpiler/literals.go b/transpiler/literals.go
index c73566c..63bfc14 100644
--- a/transpiler/literals.go
+++ b/transpiler/literals.go
@@ -66,7 +66,7 @@ func transpileStringLiteral(p *program.Program, n *ast.StringLiteral, arrayToArr
 		if t, ok := p.TypedefType[baseType]; ok {
 			n.Type = t
 		} else {
-			err = fmt.Errorf("Type is not valid : `%v`", n.Type)
+			err = fmt.Errorf("type is not valid : `%v`", n.Type)
 			p.AddMessage(p.GenerateWarningMessage(err, n))
 			return
 		}
diff --git a/transpiler/offset.go b/transpiler/offset.go
index 831d0c6..519519c 100644
--- a/transpiler/offset.go
+++ b/transpiler/offset.go
@@ -31,12 +31,12 @@ func transpileOffsetOfExpr(n *ast.OffsetOfExpr, p *program.Program) (
 	}
 
 	if len(buffer) == 0 {
-		err = fmt.Errorf("Buffer is empty")
+		err = fmt.Errorf("buffer is empty")
 		return
 	}
 
 	if !bytes.HasPrefix(buffer, []byte("__builtin_offsetof(")) {
-		err = fmt.Errorf("Haven`t prefix `__builtin_offsetof(` in buffer `%v`",
+		err = fmt.Errorf("haven`t prefix `__builtin_offsetof(` in buffer `%v`",
 			string(buffer))
 		return
 	}
@@ -46,7 +46,7 @@ func transpileOffsetOfExpr(n *ast.OffsetOfExpr, p *program.Program) (
 	// separate by `,`
 	arguments := bytes.Split(buffer, []byte(","))
 	if len(arguments) != 2 {
-		err = fmt.Errorf("Not correct amount of arguments in `%v` found %v",
+		err = fmt.Errorf("not correct amount of arguments in `%v` found %v",
 			string(buffer), len(arguments))
 		return
 	}
diff --git a/transpiler/operators.go b/transpiler/operators.go
index 1910db4..d30bfc4 100644
--- a/transpiler/operators.go
+++ b/transpiler/operators.go
@@ -38,7 +38,7 @@ func transpileBinaryConditionalOperator(n *ast.BinaryConditionalOperator, p *pro
 	_ *goast.CallExpr, theType string, preStmts []goast.Stmt, postStmts []goast.Stmt, err error) {
 	defer func() {
 		if err != nil {
-			err = fmt.Errorf("Cannot transpile BinaryConditionalOperator : err = %v", err)
+			err = fmt.Errorf("cannot transpile BinaryConditionalOperator : err = %v", err)
 		}
 	}()
 
@@ -87,7 +87,7 @@ func transpileConditionalOperator(n *ast.ConditionalOperator, p *program.Program
 	_ *goast.CallExpr, theType string, preStmts []goast.Stmt, postStmts []goast.Stmt, err error) {
 	defer func() {
 		if err != nil {
-			err = fmt.Errorf("Cannot transpile ConditionalOperator : err = %v", err)
+			err = fmt.Errorf("cannot transpile ConditionalOperator : err = %v", err)
 		}
 	}()
 
@@ -224,7 +224,7 @@ func transpileParenExpr(n *ast.ParenExpr, p *program.Program) (
 	r *goast.ParenExpr, exprType string, preStmts []goast.Stmt, postStmts []goast.Stmt, err error) {
 	defer func() {
 		if err != nil {
-			err = fmt.Errorf("Cannot transpile ParenExpr. err = %v", err)
+			err = fmt.Errorf("cannot transpile ParenExpr. err = %v", err)
 			p.AddMessage(p.GenerateWarningMessage(err, n))
 		}
 	}()
@@ -237,7 +237,7 @@ func transpileParenExpr(n *ast.ParenExpr, p *program.Program) (
 		return
 	}
 	if expr == nil {
-		err = fmt.Errorf("Expr is nil")
+		err = fmt.Errorf("expr is nil")
 		return
 	}
 
@@ -272,7 +272,7 @@ func transpileCompoundAssignOperator(
 
 	defer func() {
 		if err != nil {
-			err = fmt.Errorf("Cannot transpileCompoundAssignOperator. err = %v", err)
+			err = fmt.Errorf("cannot transpileCompoundAssignOperator. err = %v", err)
 		}
 	}()
 
@@ -427,7 +427,7 @@ func atomicOperation(n ast.Node, p *program.Program) (
 
 	defer func() {
 		if err != nil {
-			err = fmt.Errorf("Cannot create atomicOperation |%T|. err = %v", n, err)
+			err = fmt.Errorf("cannot create atomicOperation |%T|. err = %v", n, err)
 		}
 		if exprType == "" {
 			p.AddMessage(p.GenerateWarningMessage(fmt.Errorf("exprType is empty"), n))
diff --git a/transpiler/scope.go b/transpiler/scope.go
index f6041a8..a0e56d8 100644
--- a/transpiler/scope.go
+++ b/transpiler/scope.go
@@ -68,7 +68,7 @@ func transpileToBlockStmt(node ast.Node, p *program.Program) (
 	}
 
 	if stmts == nil {
-		return nil, nil, nil, fmt.Errorf("Stmts inside Block cannot be nil")
+		return nil, nil, nil, fmt.Errorf("stmts inside Block cannot be nil")
 	}
 
 	return &goast.BlockStmt{
diff --git a/transpiler/switch.go b/transpiler/switch.go
index d848ddf..fd1dd4e 100644
--- a/transpiler/switch.go
+++ b/transpiler/switch.go
@@ -196,7 +196,7 @@ func transpileSwitchStmt(n *ast.SwitchStmt, p *program.Program) (
 	_ *goast.SwitchStmt, preStmts []goast.Stmt, postStmts []goast.Stmt, err error) {
 	defer func() {
 		if err != nil {
-			err = fmt.Errorf("Cannot transpileSwitchStmt : err = %v", err)
+			err = fmt.Errorf("cannot transpileSwitchStmt : err = %v", err)
 		}
 	}()
 
@@ -538,7 +538,7 @@ func transpileCaseStmt(n *ast.CaseStmt, p *program.Program) (
 	_ *goast.CaseClause, _ []goast.Stmt, _ []goast.Stmt, err error) {
 	defer func() {
 		if err != nil {
-			err = fmt.Errorf("Cannot transpileCaseStmt: %v", err)
+			err = fmt.Errorf("cannot transpileCaseStmt: %v", err)
 		}
 	}()
 	preStmts := []goast.Stmt{}
diff --git a/transpiler/transpiler.go b/transpiler/transpiler.go
index 09df262..79468d0 100644
--- a/transpiler/transpiler.go
+++ b/transpiler/transpiler.go
@@ -102,7 +102,7 @@ func TranspileAST(fileName, packageName string, withOutsideStructs bool,
 	decls, err := transpileToNode(root, p)
 	if err != nil {
 		p.AddMessage(p.GenerateWarningMessage(
-			fmt.Errorf("Error of transpiling: err = %v", err), root))
+			fmt.Errorf("error of transpiling: err = %v", err), root))
 		err = nil // Error is ignored
 	}
 	p.File.Decls = append(p.File.Decls, decls...)
@@ -185,11 +185,11 @@ func transpileToExpr(node ast.Node, p *program.Program, exprIsStmt bool) (
 	err error) {
 	defer func() {
 		if err != nil {
-			err = fmt.Errorf("Cannot transpileToExpr. err = %v", err)
+			err = fmt.Errorf("cannot transpileToExpr. err = %v", err)
 		}
 	}()
 	if node == nil {
-		err = fmt.Errorf("Not acceptable nil node")
+		err = fmt.Errorf("not acceptable nil node")
 		return
 	}
 	defer func() {
@@ -312,7 +312,7 @@ func transpileToStmts(node ast.Node, p *program.Program) (
 		stmts, err = transpileDeclStmt(n, p)
 		if err != nil {
 			p.AddMessage(p.GenerateWarningMessage(
-				fmt.Errorf("Error in DeclStmt: %v", err), n))
+				fmt.Errorf("error in DeclStmt: %v", err), n))
 			err = nil // Error is ignored
 		}
 		return
@@ -326,7 +326,7 @@ func transpileToStmts(node ast.Node, p *program.Program) (
 	stmt, preStmts, postStmts, err = transpileToStmt(node, p)
 	if err != nil {
 		p.AddMessage(p.GenerateWarningMessage(
-			fmt.Errorf("Error in DeclStmt: %v", err), node))
+			fmt.Errorf("error in DeclStmt: %v", err), node))
 		err = nil // Error is ignored
 	}
 	return combineStmts(stmt, preStmts, postStmts), err
@@ -340,7 +340,7 @@ func transpileToStmt(node ast.Node, p *program.Program) (
 
 	defer func() {
 		if err != nil {
-			err = fmt.Errorf("Cannot transpileToStmt : %v", err)
+			err = fmt.Errorf("cannot transpileToStmt : %v", err)
 			p.AddMessage(p.GenerateWarningMessage(err, node))
 			err = nil // Error is ignored
 		}
@@ -482,7 +482,7 @@ func transpileToStmt(node ast.Node, p *program.Program) (
 
 	// For all other cases
 	if expr == nil {
-		err = fmt.Errorf("Expr is nil")
+		err = fmt.Errorf("expr is nil")
 		return
 	}
 	stmt = util.NewExprStmt(expr)
@@ -676,7 +676,7 @@ func transpileStmts(nodes []ast.Node, p *program.Program) (stmts []goast.Stmt, e
 	defer func() {
 		if err != nil {
 			p.AddMessage(p.GenerateWarningMessage(
-				fmt.Errorf("Error in transpileToStmts: %v", err), nodes[0]))
+				fmt.Errorf("error in transpileToStmts: %v", err), nodes[0]))
 			err = nil // Error is ignored
 		}
 	}()
diff --git a/transpiler/unary.go b/transpiler/unary.go
index b0da56d..3590dd2 100644
--- a/transpiler/unary.go
+++ b/transpiler/unary.go
@@ -20,7 +20,7 @@ func transpileUnaryOperatorInc(n *ast.UnaryOperator, p *program.Program, operato
 	expr goast.Expr, eType string, preStmts []goast.Stmt, postStmts []goast.Stmt, err error) {
 	defer func() {
 		if err != nil {
-			err = fmt.Errorf("Cannot transpileUnaryOperatorInc. err = %v", err)
+			err = fmt.Errorf("cannot transpileUnaryOperatorInc. err = %v", err)
 		}
 		if eType == "" {
 			eType = "EmptyTypeInUnaryOperatorInc"
@@ -240,7 +240,7 @@ func transpileUnaryOperatorAmpersant(n *ast.UnaryOperator, p *program.Program) (
 	expr goast.Expr, eType string, preStmts []goast.Stmt, postStmts []goast.Stmt, err error) {
 	defer func() {
 		if err != nil {
-			err = fmt.Errorf("Cannot transpileUnaryOperatorAmpersant : err = %v", err)
+			err = fmt.Errorf("cannot transpileUnaryOperatorAmpersant : err = %v", err)
 		}
 	}()
 
@@ -249,7 +249,7 @@ func transpileUnaryOperatorAmpersant(n *ast.UnaryOperator, p *program.Program) (
 		return
 	}
 	if expr == nil {
-		err = fmt.Errorf("Expr is nil")
+		err = fmt.Errorf("expr is nil")
 		return
 	}
 
@@ -364,9 +364,9 @@ func pointerParts(node *ast.Node, p *program.Program) (
 	pnt ast.Node, value ast.Node, back func(), undefineIndex bool, err error) {
 	defer func() {
 		if err != nil {
-			err = fmt.Errorf("Cannot pointerParts: err = %v", err)
+			err = fmt.Errorf("cannot pointerParts: err = %v", err)
 			if (*node) != nil {
-				err = fmt.Errorf("Code line: %d. %v", (*node).Position().Line, err)
+				err = fmt.Errorf("code line: %d. %v", (*node).Position().Line, err)
 			}
 		}
 	}()
@@ -390,7 +390,7 @@ func pointerParts(node *ast.Node, p *program.Program) (
 		// save types of all nodes
 		t, ok := ast.GetTypeIfExist(*node)
 		if !ok {
-			panic(fmt.Errorf("Not support parent type %T in pointer seaching", node))
+			panic(fmt.Errorf("not support parent type %T in pointer seaching", node))
 		}
 		baseTypes = append(baseTypes, t)
 
@@ -487,7 +487,7 @@ func transpilePointerArith(n *ast.UnaryOperator, p *program.Program) (
 	expr goast.Expr, eType string, preStmts []goast.Stmt, postStmts []goast.Stmt, err error) {
 	defer func() {
 		if err != nil {
-			err = fmt.Errorf("Cannot transpilePointerArith: err = %v", err)
+			err = fmt.Errorf("cannot transpilePointerArith: err = %v", err)
 		}
 	}()
 
@@ -566,14 +566,14 @@ func transpilePointerArith(n *ast.UnaryOperator, p *program.Program) (
 		}, eType, preStmts, postStmts, err
 
 	}
-	return nil, "", nil, nil, fmt.Errorf("Cannot found : %#v", pnt)
+	return nil, "", nil, nil, fmt.Errorf("cannot found : %#v", pnt)
 }
 
 func transpileUnaryOperator(n *ast.UnaryOperator, p *program.Program) (
 	_ goast.Expr, theType string, preStmts []goast.Stmt, postStmts []goast.Stmt, err error) {
 	defer func() {
 		if err != nil {
-			err = fmt.Errorf("Cannot transpile UnaryOperator: err = %v", err)
+			err = fmt.Errorf("cannot transpile UnaryOperator: err = %v", err)
 			p.AddMessage(p.GenerateWarningMessage(err, n))
 		}
 	}()
diff --git a/transpiler/union.go b/transpiler/union.go
index 450de21..d4fd0ab 100644
--- a/transpiler/union.go
+++ b/transpiler/union.go
@@ -20,7 +20,7 @@ func transpileUnion(name string, size int, fields []*goast.Field) (
 
 	defer func() {
 		if err != nil {
-			err = fmt.Errorf("Cannot transpileUnion : err = %v", err)
+			err = fmt.Errorf("cannot transpileUnion : err = %v", err)
 			if strings.Contains(err.Error(), "\n") {
 				err = fmt.Errorf("%v", strings.Replace(err.Error(), "\n", "||", -1))
 			}
diff --git a/transpiler/vaarg.go b/transpiler/vaarg.go
index 781337b..629cb40 100644
--- a/transpiler/vaarg.go
+++ b/transpiler/vaarg.go
@@ -20,7 +20,7 @@ func transpileVAArgExpr(n *ast.VAArgExpr, p *program.Program) (
 	err error) {
 	defer func() {
 		if err != nil {
-			err = fmt.Errorf("Cannot transpileVAArgExpr. %v", err)
+			err = fmt.Errorf("cannot transpileVAArgExpr. %v", err)
 		}
 	}()
 	// -VAArgExpr 'int'
diff --git a/transpiler/value_to_pointer.go b/transpiler/value_to_pointer.go
index c5da925..7e53a99 100644
--- a/transpiler/value_to_pointer.go
+++ b/transpiler/value_to_pointer.go
@@ -180,7 +180,7 @@ func GetPointerAddress(expr goast.Expr, cType string, sizeof int) (
 	rs goast.Expr, postStmts []goast.Stmt, err error) {
 
 	if expr == nil {
-		err = fmt.Errorf("Cannot get pointer address for nil expr")
+		err = fmt.Errorf("cannot get pointer address for nil expr")
 		return
 	}
 
@@ -313,7 +313,7 @@ func GetPointerAddress(expr goast.Expr, cType string, sizeof int) (
 	// prepare postStmts
 
 	if sizeof < 1 {
-		err = fmt.Errorf("Not valid sizeof `%s`: %d", cType, sizeof)
+		err = fmt.Errorf("not valid sizeof `%s`: %d", cType, sizeof)
 		return
 	}
 
@@ -491,7 +491,7 @@ func PntBitCast(expr goast.Expr, cFrom, cTo string, p *program.Program) (
 	rs goast.Expr, toCtype string, postStmts []goast.Stmt, err error) {
 	defer func() {
 		if err != nil {
-			err = fmt.Errorf("Cannot PntBitCast : %v", err)
+			err = fmt.Errorf("cannot PntBitCast : %v", err)
 			p.AddMessage(p.GenerateWarningMessage(err, nil))
 		}
 	}()
@@ -501,7 +501,7 @@ func PntBitCast(expr goast.Expr, cFrom, cTo string, p *program.Program) (
 	toCtype = cTo
 
 	if !types.IsPointer(cFrom, p) || !types.IsPointer(cTo, p) {
-		err = fmt.Errorf("Some type is not pointer `%s` or `%s`", cFrom, cTo)
+		err = fmt.Errorf("some type is not pointer `%s` or `%s`", cFrom, cTo)
 		return
 	}
 
@@ -626,7 +626,7 @@ func pointerArithmetic(p *program.Program,
 	_ goast.Expr, _ string, preStmts []goast.Stmt, postStmts []goast.Stmt, err error) {
 	defer func() {
 		if err != nil {
-			err = fmt.Errorf("Cannot transpile pointerArithmetic. err = %v", err)
+			err = fmt.Errorf("cannot transpile pointerArithmetic. err = %v", err)
 		}
 	}()
 
@@ -747,7 +747,7 @@ func main(){
 	var source bytes.Buffer
 	err = tmpl.Execute(&source, s)
 	if err != nil {
-		err = fmt.Errorf("Cannot execute template. err = %v", err)
+		err = fmt.Errorf("cannot execute template. err = %v", err)
 		return
 	}
 
@@ -763,7 +763,7 @@ func main(){
 	f, err := parser.ParseFile(fset, "", body, 0)
 	if err != nil {
 		body = strings.Replace(body, "\n", "", -1)
-		err = fmt.Errorf("Cannot parse file. err = %v. body = `%s`", err, body)
+		err = fmt.Errorf("cannot parse file. err = %v. body = `%s`", err, body)
 		return
 	}
 
diff --git a/transpiler/variables.go b/transpiler/variables.go
index 1f91e67..ce7cb9d 100644
--- a/transpiler/variables.go
+++ b/transpiler/variables.go
@@ -53,7 +53,7 @@ func getDefaultValueForVar(p *program.Program, a *ast.VarDecl) (
 	expr []goast.Expr, _ string, preStmts []goast.Stmt, postStmts []goast.Stmt, err error) {
 	defer func() {
 		if err != nil {
-			err = fmt.Errorf("Cannot getDefaultValueForVar : err = %v", err)
+			err = fmt.Errorf("cannot getDefaultValueForVar : err = %v", err)
 		}
 	}()
 	if len(a.Children()) == 0 {
@@ -146,7 +146,7 @@ func transpileInitListExpr(e *ast.InitListExpr, p *program.Program) (
 	expr goast.Expr, exprType string, err error) {
 	defer func() {
 		if err != nil {
-			err = fmt.Errorf("Cannot transpileInitListExpr. err = %v", err)
+			err = fmt.Errorf("cannot transpileInitListExpr. err = %v", err)
 		}
 	}()
 	resp := []goast.Expr{}
@@ -315,7 +315,7 @@ func transpileArraySubscriptExpr(n *ast.ArraySubscriptExpr, p *program.Program)
 	_ *goast.IndexExpr, theType string, preStmts []goast.Stmt, postStmts []goast.Stmt, err error) {
 	defer func() {
 		if err != nil {
-			err = fmt.Errorf("Cannot transpile ArraySubscriptExpr. err = %v", err)
+			err = fmt.Errorf("cannot transpile ArraySubscriptExpr. err = %v", err)
 			p.AddMessage(p.GenerateWarningMessage(err, n))
 		}
 	}()
@@ -382,7 +382,7 @@ func transpileMemberExpr(n *ast.MemberExpr, p *program.Program) (
 	_ goast.Expr, _ string, preStmts []goast.Stmt, postStmts []goast.Stmt, err error) {
 	defer func() {
 		if err != nil {
-			err = fmt.Errorf("Cannot transpile MemberExpr. err = %v", err)
+			err = fmt.Errorf("cannot transpile MemberExpr. err = %v", err)
 			p.AddMessage(p.GenerateWarningMessage(err, n))
 		}
 	}()
@@ -559,7 +559,7 @@ func transpileImplicitValueInitExpr(n *ast.ImplicitValueInitExpr, p *program.Pro
 
 	defer func() {
 		if err != nil {
-			err = fmt.Errorf("Cannot transpileImplicitValueInitExpr. err = %v", err)
+			err = fmt.Errorf("cannot transpileImplicitValueInitExpr. err = %v", err)
 		}
 	}()
 	expr, exprType = zeroValue(p, n.Type1)
diff --git a/types/cast.go b/types/cast.go
index 0b659c3..6ca0e8a 100644
--- a/types/cast.go
+++ b/types/cast.go
@@ -68,7 +68,7 @@ func CastExpr(p *program.Program, expr goast.Expr, cFromType, cToType string) (
 	defer func() {
 		if err2 != nil {
 			err2 = fmt.Errorf(
-				"Cannot casting {%s -> %s}. err = %v", cFromType, cToType, err2)
+				"cannot casting {%s -> %s}. err = %v", cFromType, cToType, err2)
 		}
 	}()
 
@@ -84,12 +84,12 @@ func CastExpr(p *program.Program, expr goast.Expr, cFromType, cToType string) (
 
 	// Uncomment only for debugging
 	if strings.Contains(cFromType, ":") {
-		err2 = fmt.Errorf("Found mistake `cFromType` `%v` C type : %#v",
+		err2 = fmt.Errorf("found mistake `cFromType` `%v` C type : %#v",
 			cFromType, expr)
 		return
 	}
 	if strings.Contains(cToType, ":") {
-		err2 = fmt.Errorf("Found mistake `cToType` `%v` C type: %#v",
+		err2 = fmt.Errorf("found mistake `cToType` `%v` C type: %#v",
 			cToType, expr)
 		return
 	}
@@ -105,7 +105,7 @@ func CastExpr(p *program.Program, expr goast.Expr, cFromType, cToType string) (
 	}
 
 	if expr == nil {
-		return nil, fmt.Errorf("Expr is nil")
+		return nil, fmt.Errorf("expr is nil")
 	}
 
 	if util.IsFunction(cFromType) && toType == "bool" {
@@ -490,7 +490,7 @@ func CastExpr(p *program.Program, expr goast.Expr, cFromType, cToType string) (
 		return expr, nil
 	}
 
-	p.GenerateWarningMessage(fmt.Errorf("Cannot cast types `%s`->`%s`", cFromType, cToType), nil)
+	p.GenerateWarningMessage(fmt.Errorf("cannot cast types `%s`->`%s`", cFromType, cToType), nil)
 
 	return expr, nil
 }
diff --git a/types/dereference.go b/types/dereference.go
index a081ed5..276c5ee 100644
--- a/types/dereference.go
+++ b/types/dereference.go
@@ -25,7 +25,7 @@ func IsDereferenceType(cType string) bool {
 func GetDereferenceType(cType string) (_ string, err error) {
 	defer func() {
 		if err != nil {
-			err = fmt.Errorf("Error in GetDereferenceType : %v", err)
+			err = fmt.Errorf("error in GetDereferenceType : %v", err)
 		}
 	}()
 
diff --git a/types/resolve.go b/types/resolve.go
index d6a8544..5c36b8f 100644
--- a/types/resolve.go
+++ b/types/resolve.go
@@ -130,7 +130,7 @@ func ResolveType(p *program.Program, s string) (resolveResult string, err error)
 	defer func() {
 		resolveResult = strings.TrimSpace(resolveResult)
 		if err != nil {
-			err = fmt.Errorf("Cannot resolve type '%s' : %v", s, err)
+			err = fmt.Errorf("cannot resolve type '%s' : %v", s, err)
 		}
 	}()
 
@@ -219,13 +219,13 @@ func ResolveType(p *program.Program, s string) (resolveResult string, err error)
 	if s[len(s)-1] == ']' {
 		index := strings.LastIndex(s, "[")
 		if index < 0 {
-			err = fmt.Errorf("Cannot found [ in type : %v", s)
+			err = fmt.Errorf("cannot found [ in type : %v", s)
 			return
 		}
 		r := strings.TrimSpace(s[:index])
 		r, err = ResolveType(p, r)
 		if err != nil {
-			err = fmt.Errorf("Cannot []: %v", err)
+			err = fmt.Errorf("cannot []: %v", err)
 			return
 		}
 		return "[]" + r, nil
@@ -275,7 +275,7 @@ func ResolveType(p *program.Program, s string) (resolveResult string, err error)
 			prefix = "*"
 		}
 		if err != nil {
-			err = fmt.Errorf("Cannot resolve star `*` for %v : %v", s, err)
+			err = fmt.Errorf("cannot resolve star `*` for %v : %v", s, err)
 		}
 		return prefix + r, err
 	}
@@ -375,7 +375,7 @@ func SeparateFunction(p *program.Program, s string) (
 	prefix string, fields []string, returns []string, err error) {
 	defer func() {
 		if err != nil {
-			err = fmt.Errorf("Cannot separate function '%s' : %v", s, err)
+			err = fmt.Errorf("cannot separate function '%s' : %v", s, err)
 		}
 	}()
 	pr, _, f, r, err := util.ParseFunction(s)
@@ -389,7 +389,7 @@ func SeparateFunction(p *program.Program, s string) (
 		var t string
 		t, err = ResolveType(p, f[i])
 		if err != nil {
-			err = fmt.Errorf("Error in field %s. err = %v", t, err)
+			err = fmt.Errorf("error in field %s. err = %v", t, err)
 			return
 		}
 		fields = append(fields, t)
@@ -398,7 +398,7 @@ func SeparateFunction(p *program.Program, s string) (
 		var t string
 		t, err = ResolveType(p, r[i])
 		if err != nil {
-			err = fmt.Errorf("Error in return field %s. err = %v", t, err)
+			err = fmt.Errorf("error in return field %s. err = %v", t, err)
 			return
 		}
 		returns = append(returns, t)
@@ -425,7 +425,7 @@ func IsTypedefFunction(p *program.Program, s string) bool {
 // Out : 40
 func GetAmountArraySize(cType string, p *program.Program) (size int, err error) {
 	if !IsCArray(cType, p) {
-		err = fmt.Errorf("Is not array: `%s`", cType)
+		err = fmt.Errorf("is not array: `%s`", cType)
 		return
 	}
 
@@ -433,7 +433,7 @@ func GetAmountArraySize(cType string, p *program.Program) (size int, err error)
 	match := reg.FindStringSubmatch(cType)
 
 	if reg.NumSubexp() != 1 {
-		err = fmt.Errorf("Cannot found size of array in type : %s", cType)
+		err = fmt.Errorf("cannot found size of array in type : %s", cType)
 		return
 	}
 
@@ -506,7 +506,7 @@ func IsPointer(s string, p *program.Program) bool {
 	return IsCPointer(s, p) || IsCArray(s, p)
 }
 
-//IsCPointer - check C type is pointer
+// IsCPointer - check C type is pointer
 func IsCPointer(s string, p *program.Program) bool {
 	if len(s) == 0 {
 		return false
diff --git a/types/sizeof.go b/types/sizeof.go
index 955cb19..ea72862 100644
--- a/types/sizeof.go
+++ b/types/sizeof.go
@@ -15,7 +15,7 @@ var sizeofStack []string
 func SizeOf(p *program.Program, cType string) (size int, err error) {
 	defer func() {
 		if err != nil {
-			err = fmt.Errorf("Cannot determine sizeof : |%s|. err = %v", cType, err)
+			err = fmt.Errorf("cannot determine sizeof : |%s|. err = %v", cType, err)
 		}
 	}()
 
@@ -111,7 +111,7 @@ func SizeOf(p *program.Program, cType string) (size int, err error) {
 
 			if err != nil {
 				err = fmt.Errorf(
-					"Cannot calculate `struct` sizeof for `%T`. bytes = '%v'. %v",
+					"cannot calculate `struct` sizeof for `%T`. bytes = '%v'. %v",
 					t, bytes, err)
 				return 0, err
 			}
@@ -164,7 +164,7 @@ func SizeOf(p *program.Program, cType string) (size int, err error) {
 			}
 
 			if err != nil {
-				err = fmt.Errorf("Cannot canculate `union` sizeof for `%T`. %v",
+				err = fmt.Errorf("cannot canculate `union` sizeof for `%T`. %v",
 					t, err)
 				return 0, err
 			}
diff --git a/util/util.go b/util/util.go
index 87cf1f1..2f49f51 100644
--- a/util/util.go
+++ b/util/util.go
@@ -87,7 +87,7 @@ func IsLastArray(s string) bool {
 func ParseFunction(s string) (prefix string, funcname string, f []string, r []string, err error) {
 	defer func() {
 		if err != nil {
-			err = fmt.Errorf("Cannot parse function '%s' : %v", s, err)
+			err = fmt.Errorf("cannot parse function '%s' : %v", s, err)
 		} else {
 			prefix = strings.TrimSpace(prefix)
 			funcname = strings.TrimSpace(funcname)
@@ -105,7 +105,7 @@ func ParseFunction(s string) (prefix string, funcname string, f []string, r []st
 
 	s = strings.TrimSpace(s)
 	if !IsFunction(s) {
-		err = fmt.Errorf("Is not function : %s", s)
+		err = fmt.Errorf("is not function : %s", s)
 		return
 	}
 	var returns string
@@ -124,7 +124,7 @@ func ParseFunction(s string) (prefix string, funcname string, f []string, r []st
 		var pos int
 		for i := len(s) - 2; i >= 0; i-- {
 			if i == 0 {
-				err = fmt.Errorf("Don't found '(' in type : %s", s)
+				err = fmt.Errorf("don't found '(' in type : %s", s)
 				return
 			}
 			if s[i] == ')' {
@@ -153,7 +153,7 @@ func ParseFunction(s string) (prefix string, funcname string, f []string, r []st
 		arguments = strings.TrimSpace(s[pos:])
 	}
 	if arguments == "" {
-		err = fmt.Errorf("Cannot parse (right part is nil) : %v", s)
+		err = fmt.Errorf("cannot parse (right part is nil) : %v", s)
 		return
 	}
 	// separate fields of arguments
@@ -240,7 +240,7 @@ func ParseFunction(s string) (prefix string, funcname string, f []string, r []st
 		block = block[1 : len(block)-1]
 		index := strings.Index(block, "(")
 		if index < 0 {
-			err = fmt.Errorf("Cannot found '(' in block")
+			err = fmt.Errorf("cannot found '(' in block")
 			return
 		}
 		returns = returns + block[index:]
@@ -248,7 +248,7 @@ func ParseFunction(s string) (prefix string, funcname string, f []string, r []st
 		if strings.Contains(prefix, "*") {
 			prefix = strings.Replace(prefix, "*", "", 1)
 		} else {
-			err = fmt.Errorf("Undefined situation")
+			err = fmt.Errorf("undefined situation")
 			return
 		}
 		r = append(r, returns)
@@ -263,7 +263,7 @@ func ParseFunction(s string) (prefix string, funcname string, f []string, r []st
 		block = block[1 : len(block)-1]
 		index := strings.Index(block, "(")
 		if index < 0 {
-			err = fmt.Errorf("Cannot found '(' in block")
+			err = fmt.Errorf("cannot found '(' in block")
 			return
 		}
 


Test patch:
diff --git a/cstd_test.go b/cstd_test.go
index 23ea517..be4da46 100644
--- a/cstd_test.go
+++ b/cstd_test.go
@@ -68,7 +68,7 @@ var cstd = map[string][]string{
 	"ctype.h": {
 		"isalnum",
 		"isalpha",
-		//c++ "isblank",
+		// c++ "isblank",
 		"iscntrl",
 		"isdigit",
 		"isgraph",
@@ -93,62 +93,62 @@ var cstd = map[string][]string{
 	"math.h": {
 		"abs",
 		"acos",
-		//c++ "acosh",
+		// c++ "acosh",
 		"asin",
-		//c++ "asinh",
+		// c++ "asinh",
 		"atan",
 		"atan2",
-		//c++ "atanh",
-		//c++ "cbrt",
+		// c++ "atanh",
+		// c++ "cbrt",
 		"ceil",
-		//c++ "copysign",
+		// c++ "copysign",
 		"cos",
 		"cosh",
-		//c++ "erf",
-		//c++ "erfc",
+		// c++ "erf",
+		// c++ "erfc",
 		"exp",
-		//c++ "exp2",
-		//c++ "expm1",
+		// c++ "exp2",
+		// c++ "expm1",
 		"fabs",
-		//c++ "fdim",
+		// c++ "fdim",
 		"floor",
-		//c++ "fma",
-		//c++ "fmax",
-		//c++ "fmin",
+		// c++ "fma",
+		// c++ "fmax",
+		// c++ "fmin",
 		"fmod",
 		"frexp",
-		//c++ "hypot",
-		//c++ "ilogb",
+		// c++ "hypot",
+		// c++ "ilogb",
 		"ldexp",
-		//c++ "lgamma",
-		//c++ "llrint",
-		//c++ "llround",
+		// c++ "lgamma",
+		// c++ "llrint",
+		// c++ "llround",
 		"log",
 		"log10",
-		//c++ "log1p",
-		//c++ "log2",
-		//c++ "logb",
-		//c++ "lrint",
-		//c++ "lround",
+		// c++ "log1p",
+		// c++ "log2",
+		// c++ "logb",
+		// c++ "lrint",
+		// c++ "lround",
 		"modf",
-		//c++ "nan",
-		//c++ "nearbyint",
-		//c++ "nextafter",
-		//c++ "nexttoward",
+		// c++ "nan",
+		// c++ "nearbyint",
+		// c++ "nextafter",
+		// c++ "nexttoward",
 		"pow",
-		//c++ "remainder",
-		//c++ "remquo",
-		//c++ "rint",
-		//c++ "round",
-		//c++ "scalbln",
-		//c++ "scalbn",
+		// c++ "remainder",
+		// c++ "remquo",
+		// c++ "rint",
+		// c++ "round",
+		// c++ "scalbln",
+		// c++ "scalbn",
 		"sin",
 		"sinh",
 		"sqrt",
 		"tan",
 		"tanh",
-		//c++ "tgamma",
-		//c++ "trunc",
+		// c++ "tgamma",
+		// c++ "trunc",
 	},
 	"setjmp.h": {
 		"jmp_buf",
@@ -163,14 +163,14 @@ var cstd = map[string][]string{
 	"stdarg.h": {
 		"va_arg",
 		"va_end",
-		//c++ "va_copy",
+		// c++ "va_copy",
 		"va_list",
 		"va_start",
 	},
 	"stddef.h": {
 		"NULL",
-		//c++ "max_align_t",
-		//c++ "nullptr_t",
+		// c++ "max_align_t",
+		// c++ "nullptr_t",
 		"offsetof",
 		"ptrdiff_t",
 		"size_t",
@@ -181,15 +181,15 @@ var cstd = map[string][]string{
 		"MB_CUR_MAX",
 		"NULL",
 		"RAND_MAX",
-		//c++ "_Exit",
+		// c++ "_Exit",
 		"abort",
 		"abs",
 		"atexit",
 		"atof",
 		"atoi",
 		"atol",
-		//c++ "atoll",
-		//c++ "at_quick_exit",
+		// c++ "atoll",
+		// c++ "at_quick_exit",
 		"bsearch",
 		"calloc",
 		"div",
@@ -200,26 +200,26 @@ var cstd = map[string][]string{
 		"labs",
 		"ldiv",
 		"ldiv_t",
-		//c++ "llabs",
-		//c++ "lldiv",
+		// c++ "llabs",
+		// c++ "lldiv",
 		"lldiv_t",
 		"malloc",
 		"mblen",
 		"mbstowcs",
 		"mbtowc",
 		"qsort",
-		//c++ "quick_exit",
+		// c++ "quick_exit",
 		"rand",
 		"realloc",
 		"size_t",
 		"srand",
 		"strtod",
-		//c++ "strtof",
+		// c++ "strtof",
 		"strtol",
-		//c++ "strtold",
-		//c++ "strtoll",
+		// c++ "strtold",
+		// c++ "strtoll",
 		"strtoul",
-		//c++ "strtoull",
+		// c++ "strtoull",
 		"system",
 		"wcstombs",
 		"wctomb",
@@ -295,11 +295,11 @@ var cstd = map[string][]string{
 		"tm", // "struct tm",
 		"ungetwc",
 		"vfwprintf",
-		//c++ "vfwscanf",
-		//c++ "vswprintf",
-		//c++ "vswscanf",
+		// c++ "vfwscanf",
+		// c++ "vswprintf",
+		// c++ "vswscanf",
 		"vwprintf",
-		//c++ "vwscanf",
+		// c++ "vwscanf",
 		"wchar_t",
 		"wcrtomb",
 		"wcscat",
@@ -319,13 +319,13 @@ var cstd = map[string][]string{
 		"wcsspn",
 		"wcsstr",
 		"wcstod",
-		//c++ "wcstof",
+		// c++ "wcstof",
 		"wcstok",
 		"wcstol",
-		//c++ "wcstold",
-		//c++ "wcstoll",
+		// c++ "wcstold",
+		// c++ "wcstoll",
 		"wcstoul",
-		//c++ "wcstoull",
+		// c++ "wcstoull",
 		"wcsxfrm",
 		"wctob",
 		"wint_t",
@@ -341,7 +341,7 @@ var cstd = map[string][]string{
 		"WEOF",
 		"iswalnum",
 		"iswalpha",
-		//c++ "iswblank",
+		// c++ "iswblank",
 		"iswcntrl",
 		"iswctype",
 		"iswdigit",
diff --git a/other_test.go b/other_test.go
index 3d3371f..46eb81d 100644
--- a/other_test.go
+++ b/other_test.go
@@ -32,7 +32,7 @@ func getFileList(prefix, gitSource string) (fileList []string, err error) {
 	if _, err = os.Stat(folder); os.IsNotExist(err) {
 		err = os.MkdirAll(folder, os.ModePerm)
 		if err != nil {
-			err = fmt.Errorf("Cannot create folder %v . %v", folder, err)
+			err = fmt.Errorf("cannot create folder %v . %v", folder, err)
 			return
 		}
 
@@ -40,7 +40,7 @@ func getFileList(prefix, gitSource string) (fileList []string, err error) {
 		args := []string{"clone", gitSource, folder}
 		err = exec.Command("git", args...).Run()
 		if err != nil {
-			err = fmt.Errorf("Cannot clone git repository with args `%v`: %v",
+			err = fmt.Errorf("cannot clone git repository with args `%v`: %v",
 				args, err)
 			return
 		}
@@ -54,7 +54,7 @@ func getFileList(prefix, gitSource string) (fileList []string, err error) {
 		return nil
 	})
 	if err != nil {
-		err = fmt.Errorf("Cannot walk: %v", err)
+		err = fmt.Errorf("cannot walk: %v", err)
 		return
 	}
 
diff --git a/util/errors_test.go b/util/errors_test.go
index 70997c6..b063eec 100644
--- a/util/errors_test.go
+++ b/util/errors_test.go
@@ -20,5 +20,5 @@ func TestPanicOnError(t *testing.T) {
 			t.Errorf("Cannot check panic")
 		}
 	}()
-	PanicOnError(fmt.Errorf("Some error"), "Check on nil : PanicOnError")
+	PanicOnError(fmt.Errorf("some error"), "Check on nil : PanicOnError")
 }