Repository: Konstantin8105/c4go
Pull request #473 (2019-10-22 13:58:55)

Fix typos in comments, variable and function names

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

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

```diff
@@           Coverage Diff           @@
##           master     #473   +/-   ##
=======================================
  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/473?src=pr&el=tree) | Coverage Δ | |
|---|---|---|
| [program/program.go](https://codecov.io/gh/Konstantin8105/c4go/pull/473/diff?src=pr&el=tree#diff-cHJvZ3JhbS9wcm9ncmFtLmdv) | `78.03% <ø> (ø)` | :arrow_up: |
| [transpiler/unary.go](https://codecov.io/gh/Konstantin8105/c4go/pull/473/diff?src=pr&el=tree#diff-dHJhbnNwaWxlci91bmFyeS5nbw==) | `75.35% <ø> (ø)` | :arrow_up: |
| [types/cast.go](https://codecov.io/gh/Konstantin8105/c4go/pull/473/diff?src=pr&el=tree#diff-dHlwZXMvY2FzdC5nbw==) | `67.76% <ø> (ø)` | :arrow_up: |
| [preprocessor/preprocessor.go](https://codecov.io/gh/Konstantin8105/c4go/pull/473/diff?src=pr&el=tree#diff-cHJlcHJvY2Vzc29yL3ByZXByb2Nlc3Nvci5nbw==) | `82.45% <ø> (ø)` | :arrow_up: |
| [util/diff.go](https://codecov.io/gh/Konstantin8105/c4go/pull/473/diff?src=pr&el=tree#diff-dXRpbC9kaWZmLmdv) | `85% <ø> (ø)` | :arrow_up: |
| [transpiler/binary.go](https://codecov.io/gh/Konstantin8105/c4go/pull/473/diff?src=pr&el=tree#diff-dHJhbnNwaWxlci9iaW5hcnkuZ28=) | `68.32% <ø> (ø)` | :arrow_up: |
| [program/import.go](https://codecov.io/gh/Konstantin8105/c4go/pull/473/diff?src=pr&el=tree#diff-cHJvZ3JhbS9pbXBvcnQuZ28=) | `100% <ø> (ø)` | :arrow_up: |
| [transpiler/operators.go](https://codecov.io/gh/Konstantin8105/c4go/pull/473/diff?src=pr&el=tree#diff-dHJhbnNwaWxlci9vcGVyYXRvcnMuZ28=) | `76.93% <ø> (ø)` | :arrow_up: |
| [program/struct.go](https://codecov.io/gh/Konstantin8105/c4go/pull/473/diff?src=pr&el=tree#diff-cHJvZ3JhbS9zdHJ1Y3QuZ28=) | `72.85% <ø> (ø)` | :arrow_up: |
| [util/errors.go](https://codecov.io/gh/Konstantin8105/c4go/pull/473/diff?src=pr&el=tree#diff-dXRpbC9lcnJvcnMuZ28=) | `100% <ø> (ø)` | :arrow_up: |
| ... and [9 more](https://codecov.io/gh/Konstantin8105/c4go/pull/473/diff?src=pr&el=tree-more) | |

------

[Continue to review full report at Codecov](https://codecov.io/gh/Konstantin8105/c4go/pull/473?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/473?src=pr&el=footer). Last update [e83bf0f...d174567](https://codecov.io/gh/Konstantin8105/c4go/pull/473?src=pr&el=lastupdated). Read the [comment docs](https://docs.codecov.io/docs/pull-request-comments).

Konstantin8105: Thank you.

Patch:
diff --git a/README.md b/README.md
index f0dc212..f33ee63 100644
--- a/README.md
+++ b/README.md
@@ -438,7 +438,7 @@ Now, let's try again and output in file `vi.go`:
 ```bash
 c4go transpile -o vi.go *.c
 ```
-Now tranpiled without `clang` error. Look the result:
+Now transpiled without `clang` error. Look the result:
 ```bash
 less vi.go
 ```
diff --git a/main.go b/main.go
index 08dc6f0..9707b47 100644
--- a/main.go
+++ b/main.go
@@ -504,7 +504,7 @@ func generateGoCode(args ProgramArgs, lines []string, filePP preprocessor.FilePP
 		// Choose inputFile for creating name of output file
 		input := args.inputFiles[0]
 		// We choose name for output Go code at the base
-		// on filename for choosed input file
+		// on filename for chased input file
 		cleanFileName := filepath.Clean(filepath.Base(input))
 		extension := filepath.Ext(input)
 		outputFilePath = cleanFileName[0:len(cleanFileName)-len(extension)] +
@@ -594,7 +594,7 @@ func runCommand() int {
 		debugVerboseFlag = debugCommand.Bool(
 			"V", false, "print progress as comments")
 		prefixDebugFlag = debugCommand.String(
-			"p", "debug.", "prefix of output C filename with addition debug informations")
+			"p", "debug.", "prefix of output C filename with addition debug information")
 		debugHelpFlag = debugCommand.Bool(
 			"h", false, "print help information")
 	)
diff --git a/preprocessor/preprocessor.go b/preprocessor/preprocessor.go
index 03d0773..9bebe8c 100644
--- a/preprocessor/preprocessor.go
+++ b/preprocessor/preprocessor.go
@@ -157,7 +157,7 @@ func NewFilePP(inputFiles, clangFlags []string, cppCode bool) (
 	for i := range allItems {
 		// If found same part of preprocess code, then
 		// don't include in result buffer for transpiling
-		// for avoid dublicate of code
+		// for avoid duplicate of code
 		var found bool
 		for j := 0; j < i; j++ {
 			if allItems[i].isSame(&allItems[j]) {
@@ -439,7 +439,7 @@ func analyzeFiles(inputFiles, clangFlags []string, cppCode bool) (
 			}
 			if item.positionInSource == 0 {
 				// cannot by less 1 for avoid problem with
-				// indentification of "0" AST base element
+				// identification of "0" AST base element
 				item.positionInSource = 1
 			}
 			item.lines = make([]*string, 0)
diff --git a/program/definition_type.go b/program/definition_type.go
index 2348cb5..a353dc2 100644
--- a/program/definition_type.go
+++ b/program/definition_type.go
@@ -1,6 +1,6 @@
 package program
 
-// DefinitionType - conversion map from C standart library structures to
+// DefinitionType - conversion map from C standard library structures to
 // c4go structures
 var DefinitionType = map[string]string{
 	// time.h
@@ -50,7 +50,7 @@ var DefinitionType = map[string]string{
 	"void*":  "interface{}",
 	"void *": "interface{}",
 
-	// null is a special case (it should probably have a less ambiguos name)
+	// null is a special case (it should probably have a less ambiguous name)
 	// when using the NULL macro.
 	"null": "null",
 
diff --git a/program/definition_variable.go b/program/definition_variable.go
index 5b06971..d0d967a 100644
--- a/program/definition_variable.go
+++ b/program/definition_variable.go
@@ -1,6 +1,6 @@
 package program
 
-// DefinitionVariable is map of convertion from C var to C4go variable
+// DefinitionVariable is map of conversion from C var to C4go variable
 var DefinitionVariable = map[string]string{
 	// stdio.h
 	"stdin":  "github.com/Konstantin8105/c4go/noarch.Stdin",
diff --git a/program/import.go b/program/import.go
index eda00d9..0bfb58f 100644
--- a/program/import.go
+++ b/program/import.go
@@ -29,7 +29,7 @@ func (p *Program) AddImport(importPath string) {
 	p.imports = append(p.imports, quotedImportPath)
 }
 
-// AddImports is a convienience method for adding multiple imports.
+// AddImports is a convenience method for adding multiple imports.
 func (p *Program) AddImports(importPaths ...string) {
 	for _, importPath := range importPaths {
 		p.AddImport(importPath)
diff --git a/program/program.go b/program/program.go
index 23f5d84..9cca6d5 100644
--- a/program/program.go
+++ b/program/program.go
@@ -174,7 +174,7 @@ func (p *Program) AddMessage(message string) bool {
 			new  = len(p.messages) - 1
 			last = len(p.messages) - 2
 		)
-		// Warning collapsing for minimaze warnings
+		// Warning collapsing for minimize warnings
 		warning := "// Warning"
 		if strings.HasPrefix(p.messages[last], warning) {
 			l := p.messages[last][len(warning):]
diff --git a/program/struct.go b/program/struct.go
index 8e99628..8b0d1af 100644
--- a/program/struct.go
+++ b/program/struct.go
@@ -23,7 +23,7 @@ type Struct struct {
 	// IsGlobal is true for case global struct
 	IsGlobal bool
 
-	// This field is used to avoid to dupplicate code for union case the type is the same.
+	// This field is used to avoid to duplicate code for union case the type is the same.
 	Type TypeOfStruct
 
 	// Each of the fields and their C type. The field may be a string or an
diff --git a/transpiler/binary.go b/transpiler/binary.go
index 78fade6..ecf46e9 100644
--- a/transpiler/binary.go
+++ b/transpiler/binary.go
@@ -18,8 +18,8 @@ import (
 // for (int i=0,j=0;i+=1,j<5;i++,j++){...}
 // For solving - we have to separate the
 // binary operator "," to 2 parts:
-// part 1(pre ): left part  - typically one or more some expessions
-// part 2(stmt): right part - always only one expression, with or witout
+// part 1(pre ): left part  - typically one or more some expressions
+// part 2(stmt): right part - always only one expression, with or without
 //               logical operators like "==", "!=", ...
 func transpileBinaryOperatorComma(n *ast.BinaryOperator, p *program.Program) (
 	stmt goast.Stmt, preStmts []goast.Stmt, err error) {
@@ -126,7 +126,7 @@ func transpileBinaryOperator(n *ast.BinaryOperator, p *program.Program, exprIsSt
 	// // Operation equal transpile from right to left
 	// Solving:
 	// b = 1, a = b
-	// // Operation comma tranpile from left to right
+	// // Operation comma transpile from left to right
 	// If we have for example:
 	// a = b = c = 1
 	// then solution is:
diff --git a/transpiler/bind.go b/transpiler/bind.go
index 8e61e38..83278b8 100644
--- a/transpiler/bind.go
+++ b/transpiler/bind.go
@@ -365,7 +365,7 @@ func bindFromCtoGo(p *program.Program, cType string, goType string, expr goast.E
 
 // add if`s for nil cases
 //
-// strtok - add c-binding for implemention function
+// strtok - add c-binding for implementation function
 // func strtok(arg0 []byte, arg1 []byte) []byte {
 //	if arg0 == nil {
 //		return []byte{}
diff --git a/transpiler/branch.go b/transpiler/branch.go
index 2091e82..048ee10 100644
--- a/transpiler/branch.go
+++ b/transpiler/branch.go
@@ -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 transpile ForStmt: err = %v", err)
 			p.AddMessage(p.GenerateWarningMessage(err, n))
 		}
 	}()
@@ -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 transpile children[3] : %v", err)
 			return nil, nil, nil, err
 		}
 
@@ -393,7 +393,7 @@ func transpileForStmt(n *ast.ForStmt, p *program.Program) (
 		}, preStmts, postStmts, nil
 	}
 
-	// for avoid dublication of init values for
+	// for avoid duplication of init values for
 	// case with 2 for`s
 	var block goast.BlockStmt
 	var forStmt = goast.ForStmt{
@@ -412,7 +412,7 @@ func transpileForStmt(n *ast.ForStmt, p *program.Program) (
 // We have only operator FOR in Go, but in C we also have
 // operator WHILE. So, we have to convert to operator FOR.
 // We choose directly conversion  from AST C code to AST C code, for
-// - avoid dublicate of code in realization WHILE and FOR.
+// - avoid duplicate of code in realization WHILE and FOR.
 // - create only one operator FOR powerful.
 // Example of C code with operator WHILE:
 //	while(i > 0){
@@ -496,7 +496,7 @@ func transpileWhileStmt(n *ast.WhileStmt, p *program.Program) (
 // We have only operators FOR and IF in Go, but in C we also have
 // operator DO...WHILE. So, we have to convert to operators FOR and IF.
 // We choose directly conversion  from AST C code to AST C code, for:
-// - avoid dublicate of code in realization DO...WHILE and FOR.
+// - avoid duplicate of code in realization DO...WHILE and FOR.
 // - create only one powerful operator FOR.
 // Example of C code with operator DO...WHILE:
 //	do{
diff --git a/transpiler/call.go b/transpiler/call.go
index c20df58..b1b32d4 100644
--- a/transpiler/call.go
+++ b/transpiler/call.go
@@ -115,7 +115,7 @@ func getName(p *program.Program, firstChild ast.Node) (name string, err error) {
 	return "", fmt.Errorf("cannot getName for: %#v", firstChild)
 }
 
-// simplificationCallExprPrintf - minimaze Go code
+// simplificationCallExprPrintf - minimize Go code
 // transpile C code : printf("Hello")
 // to Go code       : fmt_Printf("Hello")
 // AST example :
diff --git a/transpiler/declarations.go b/transpiler/declarations.go
index 12dff0b..9ab3969 100644
--- a/transpiler/declarations.go
+++ b/transpiler/declarations.go
@@ -192,14 +192,14 @@ func transpileRecordDecl(p *program.Program, n *ast.RecordDecl) (
 							" in RecordDecl : `%v`", n.Name), n))
 					continue
 				}
-				// remove dublicates of fields
-				var isDublicate bool
+				// remove duplicates of fields
+				var isDuplicate bool
 				for i := range fields {
 					if fields[i].Names[0].Name == f.Names[0].Name {
-						isDublicate = true
+						isDuplicate = true
 					}
 				}
-				if isDublicate {
+				if isDuplicate {
 					f.Names[0].Name += strconv.Itoa(pos)
 				}
 				fields = append(fields, f)
@@ -209,7 +209,7 @@ func transpileRecordDecl(p *program.Program, n *ast.RecordDecl) (
 			// ignore
 
 		case *ast.TransparentUnionAttr:
-			// Don't do anythink
+			// Don't do anything
 			// Example of AST:
 			// |-RecordDecl 0x3632d78 <...> line:67:9 union definition
 			// | |-TransparentUnionAttr 0x3633050 <...>
@@ -656,7 +656,7 @@ func transpileVarDecl(p *program.Program, n *ast.VarDecl) (
 	}
 	// for ignore zero value. example:
 	// int i = 0;
-	// tranpile to:
+	// transpile to:
 	// var i int // but not "var i int = 0"
 	if len(defaultValue) == 1 && defaultValue[0] != nil {
 		if bl, ok := defaultValue[0].(*goast.BasicLit); ok {
diff --git a/transpiler/functions.go b/transpiler/functions.go
index 70e4670..c5a0283 100644
--- a/transpiler/functions.go
+++ b/transpiler/functions.go
@@ -39,7 +39,7 @@ func getFunctionBody(n *ast.FunctionDecl) *ast.CompoundStmt {
 // The function prototype may also have a body. If it does have a body the whole
 // function will be transpiled into Go.
 //
-// If there is no function body we register the function interally (actually
+// If there is no function body we register the function internally (actually
 // either way the function is registered internally) but we do not do anything
 // because Go does not use or have any use for forward declarations of
 // functions.
diff --git a/transpiler/offset.go b/transpiler/offset.go
index 519519c..53e03fd 100644
--- a/transpiler/offset.go
+++ b/transpiler/offset.go
@@ -12,7 +12,7 @@ import (
 
 func transpileOffsetOfExpr(n *ast.OffsetOfExpr, p *program.Program) (
 	expr goast.Expr, exprType string, err error) {
-	// clang ast haven`t enought information about OffsetOfExpr
+	// clang ast haven`t enough information about OffsetOfExpr
 	defer func() {
 		if err != nil {
 			err = fmt.Errorf("cannot transpile OffsetOfExpr. %v", err)
diff --git a/transpiler/operators.go b/transpiler/operators.go
index d30bfc4..0416b9e 100644
--- a/transpiler/operators.go
+++ b/transpiler/operators.go
@@ -65,7 +65,7 @@ func transpileBinaryConditionalOperator(n *ast.BinaryConditionalOperator, p *pro
 // Since Go does not support the ternary operator or inline "if" statements we
 // use a closure to work the same way.
 //
-// It is also important to note that C only evaulates the "b" or "c" condition
+// It is also important to note that C only evaluates the "b" or "c" condition
 // based on the result of "a" (from the above example).
 //
 // Example AST:
diff --git a/transpiler/switch.go b/transpiler/switch.go
index fd1dd4e..8e578e1 100644
--- a/transpiler/switch.go
+++ b/transpiler/switch.go
@@ -216,7 +216,7 @@ func transpileSwitchStmt(n *ast.SwitchStmt, p *program.Program) (
 		panic(fmt.Sprintf("Less than two children for switch: %#v", n))
 	}
 
-	// The condition is the expression to be evaulated against each of the
+	// The condition is the expression to be evaluated against each of the
 	// cases.
 	condition, conditionType, newPre, newPost, err := atomicOperation(
 		n.Children()[len(n.Children())-2], p)
diff --git a/transpiler/unary.go b/transpiler/unary.go
index 3590dd2..30504c3 100644
--- a/transpiler/unary.go
+++ b/transpiler/unary.go
@@ -225,7 +225,7 @@ func transpileUnaryOperatorNot(n *ast.UnaryOperator, p *program.Program) (
 		eType, preStmts, postStmts, nil
 }
 
-// tranpileUnaryOperatorAmpersant - operator ampersant &
+// transpileUnaryOperatorAmpersant - operator ampersant &
 // Example of AST:
 //
 // UnaryOperator 'int (*)[5]' prefix '&'
diff --git a/transpiler/value_to_pointer.go b/transpiler/value_to_pointer.go
index 7e53a99..42a1150 100644
--- a/transpiler/value_to_pointer.go
+++ b/transpiler/value_to_pointer.go
@@ -616,7 +616,7 @@ func CreateSliceFromReference(goType string, expr goast.Expr) goast.Expr {
 //      'ptr' - left
 //      'int' - leftType transpiled in Go type
 // Note:
-// 1) rigthType MUST be 'int'
+// 1) rightType MUST be 'int'
 // 2) pointerArithmetic - implemented ONLY right part of formula
 // 3) right is MUST be positive value, because impossible multiply uintptr to (-1)
 func pointerArithmetic(p *program.Program,
diff --git a/transpiler/variables.go b/transpiler/variables.go
index ce7cb9d..97daaef 100644
--- a/transpiler/variables.go
+++ b/transpiler/variables.go
@@ -130,7 +130,7 @@ func GenerateFuncType(fields, returns []string) *goast.FuncType {
 	return &ft
 }
 
-// tranpileInitListExpr.
+// transpileInitListExpr.
 //
 // Examples:
 //
diff --git a/types/cast.go b/types/cast.go
index 6ca0e8a..bd6e312 100644
--- a/types/cast.go
+++ b/types/cast.go
@@ -29,7 +29,7 @@ func GetArrayTypeAndSize(s string) (string, int) {
 }
 
 // CastExpr returns an expression that casts one type to another. For
-// reliability and flexability the existing type (fromType) must be structly
+// reliability and flexibility the existing type (fromType) must be structly
 // provided.
 //
 // There are lots of rules about how an expression is cast, but here are some
@@ -43,7 +43,7 @@ func GetArrayTypeAndSize(s string) (string, int) {
 //    guarantee that original C used the NULL macro but it is a safe assumption
 //    for now.
 //
-//    The reason why NULL is special (or at least seamingly) is that it is often
+//    The reason why NULL is special (or at least seemingly) is that it is often
 //    used in different value contexts. As a number, testing pointers and
 //    strings. Being able to better understand the original purpose of the code
 //    helps to generate cleaner and more Go-like output.
@@ -195,7 +195,7 @@ func CastExpr(p *program.Program, expr goast.Expr, cFromType, cToType string) (
 		}
 	}
 
-	// Checking registated typedef types in program
+	// Checking registered typedef types in program
 	if v, ok := p.TypedefType[toType]; ok {
 		if fromType == v {
 			toType, err := ResolveType(p, toType)
@@ -499,7 +499,7 @@ func CastExpr(p *program.Program, expr goast.Expr, cFromType, cToType string) (
 // macro. In C, NULL is actually a macro that produces an expression like "(0)".
 //
 // There are no guarantees if the original C code used the NULL macro, but it is
-// usually a pretty good guess when we see this specific exression signature.
+// usually a pretty good guess when we see this specific expression signature.
 //
 // Either way the return value from IsNullExpr should not change the
 // functionality of the code but can lead to hints that allow the Go produced to
diff --git a/util/diff.go b/util/diff.go
index 1ee70e7..8c8b58a 100644
--- a/util/diff.go
+++ b/util/diff.go
@@ -20,7 +20,7 @@ func ShowDiff(a, b string) string {
 		bLine := ""
 
 		// Replace NULL characters with a dot. Otherwise the strings will look
-		// exactly the same but have different length (and therfore not be
+		// exactly the same but have different length (and therefore not be
 		// equal).
 		if lineNumber < len(aLines) {
 			aLine = strconv.Quote(aLines[lineNumber])
diff --git a/util/errors.go b/util/errors.go
index 5f85f75..946192a 100644
--- a/util/errors.go
+++ b/util/errors.go
@@ -3,7 +3,7 @@ package util
 import "fmt"
 
 // PanicIfNil will panic with the message provided if the check is nil. This is
-// a convieniance method to avoid many similar if statements.
+// a convenience method to avoid many similar if statements.
 func PanicIfNil(check interface{}, message string) {
 	if check == nil {
 		panic(message)


Test patch:
diff --git a/tests/c4go-TestCLI-func1-DebugHelpFlag b/tests/c4go-TestCLI-func1-DebugHelpFlag
index 6bedc72..8a294a2 100644
--- a/tests/c4go-TestCLI-func1-DebugHelpFlag
+++ b/tests/c4go-TestCLI-func1-DebugHelpFlag
@@ -6,5 +6,5 @@
     	transpile CPP code
   -h	print help information
   -p string
-    	prefix of output C filename with addition debug informations (default "debug.")
+    	prefix of output C filename with addition debug information (default "debug.")
 )
diff --git a/tests/c4go-TestCLI-func1-DebugNoFilesHelp b/tests/c4go-TestCLI-func1-DebugNoFilesHelp
index 6bedc72..8a294a2 100644
--- a/tests/c4go-TestCLI-func1-DebugNoFilesHelp
+++ b/tests/c4go-TestCLI-func1-DebugNoFilesHelp
@@ -6,5 +6,5 @@
     	transpile CPP code
   -h	print help information
   -p string
-    	prefix of output C filename with addition debug informations (default "debug.")
+    	prefix of output C filename with addition debug information (default "debug.")
 )
diff --git a/tests/class.cpp.todo b/tests/class.cpp.todo
index e4e8da6..5be7c28 100644
--- a/tests/class.cpp.todo
+++ b/tests/class.cpp.todo
@@ -30,7 +30,7 @@ Rectangle::Rectangle () {
   height = 5;
 }
 
-void defaulf_constructor()
+void default_constructor()
 {
 	Rectangle rec;
 	is_eq(rec.area(),20);
@@ -114,7 +114,7 @@ int main()
     plan(2);
 
 	simple();
-	// defaulf_constructor();
+	// default_constructor();
 	// constructor();
 	// constructor2();
 	// constructor3();