Update Travis configuration.

Create MO parser

.github/ISSUE_TEMPLATE.md

@@ -0,0 +1,14 @@
+# Please describe your issue
+
+### Is this a bug, an improvement, a proposal or something else? Describe it.
+
+...
+
+
+### What's the expected behaviour, the current behaviour and the steps to reproduce it?
+
+... 
+
+
+### Comments
+

.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,23 @@
+# Before creating your Pull Request...
+
+- New Pull Requests should include a good description of what's being merged. 
+- Ideally, all Pull Requests are preceded by a discussion initiated in an Issue on this repository. 
+- For bug fixes is mandatory to have tests that cover and fail when the bug is present and will pass after this Pull Request.
+- For changes and improvements, new tests have to be provided to cover the new features.
+
+
+## Is this a fix, improvement or something else?
+
+...
+
+
+## What does this change implement/fix?
+
+... 
+
+
+## I have ...
+
+- [ ] answered the 2 questions above,
+- [ ] discussed this change in an issue,
+- [ ] included tests to cover this changes.

.gitignore

@@ -3,6 +3,9 @@
 .settings
 .buildpath
 
+# golang jetbrains shit
+.idea
+
 # Compiled Object files, Static and Dynamic libs (Shared Objects)
 *.o
 *.a

.travis.yml

@@ -1,10 +1,13 @@
 language: go
 
 go:
-  - 1.6
+  - "1.6"
-  - 1.7
+  - "1.7"
-  - 1.8
+  - "1.8"
-  - tip
+  - "1.9"
+  - "1.10"
+  - "1.11"
+  - "tip"
 
 before_install:
   - go get -t -v ./...

CODE_OF_CONDUCT.md

@@ -0,0 +1,46 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as contributors and maintainers pledge to making participation in our project and our community a harassment-free experience for everyone, regardless of age, body size, disability, ethnicity, gender identity and expression, level of experience, nationality, personal appearance, race, religion, or sexual identity and orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable behavior and are expected to take appropriate and fair corrective action in response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, or to ban temporarily or permanently any contributor for other behaviors that they deem inappropriate, threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces when an individual is representing the project or its community. Examples of representing a project or community include using an official project e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event. Representation of a project may be further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the project team at leonel.quinteros@gmail.com. The project team will review and investigate all complaints, and will respond in a way that it deems appropriate to the circumstances. The project team is obligated to maintain confidentiality with regard to the reporter of an incident. Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good faith may face temporary or permanent repercussions as determined by other members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

CONTRIBUTING.md

@@ -0,0 +1,19 @@
+# CONTRIBUTING
+
+This open source project welcomes everybody that wants to contribute to it by implementing new features, fixing bugs, testing, creating documentation or simply talk about it. 
+
+Most contributions will start by creating a new Issue to discuss what is the contribution about and to agree on the steps to move forward. 
+
+## Issues
+
+All issues reports are welcome. Open a new Issue whenever you want to report a bug, request a change or make a proposal.
+
+This should be your start point of contribution. 
+
+
+## Pull Requests
+
+If you have any changes that can be merged, feel free to send a Pull Request. 
+
+Usually, you'd want to create a new Issue to discuss about the change you want to merge and why it's needed or what it solves. 
+

Godeps/Godeps.json

@@ -1,18 +0,0 @@
-{
-	"ImportPath": "github.com/leonelquinteros/gotext",
-	"GoVersion": "devel +be9d7f6d87 Fri Jun 16 00:31:25 2017 +0000",
-	"Deps": [
-		{
-			"ImportPath": "github.com/mattn/kinako/ast",
-			"Rev": "fbc18625ec69b28ae03b4eea4c349f215840ee09"
-		},
-		{
-			"ImportPath": "github.com/mattn/kinako/parser",
-			"Rev": "fbc18625ec69b28ae03b4eea4c349f215840ee09"
-		},
-		{
-			"ImportPath": "github.com/mattn/kinako/vm",
-			"Rev": "fbc18625ec69b28ae03b4eea4c349f215840ee09"
-		}
-	]
-}

Godeps/Readme

@@ -1,5 +0,0 @@
-This directory tree is generated automatically by godep.
-
-Please do not edit.
-
-See https://github.com/tools/godep for more information.

Gopkg.lock

@@ -0,0 +1,9 @@
+# This file is autogenerated, do not edit; changes may be undone by the next 'dep ensure'.
+
+
+[solve-meta]
+  analyzer-name = "dep"
+  analyzer-version = 1
+  inputs-digest = "ab4fef131ee828e96ba67d31a7d690bd5f2f42040c6766b1b12fe856f87e0ff7"
+  solver-name = "gps-cdcl"
+  solver-version = 1

Gopkg.toml

@@ -0,0 +1,30 @@
+# Gopkg.toml example
+#
+# Refer to https://golang.github.io/dep/docs/Gopkg.toml.html
+# for detailed Gopkg.toml documentation.
+#
+# required = ["github.com/user/thing/cmd/thing"]
+# ignored = ["github.com/user/project/pkgX", "bitbucket.org/user/project/pkgA/pkgY"]
+#
+# [[constraint]]
+#   name = "github.com/user/project"
+#   version = "1.0.0"
+#
+# [[constraint]]
+#   name = "github.com/user/project2"
+#   branch = "dev"
+#   source = "github.com/myfork/project2"
+#
+# [[override]]
+#   name = "github.com/x/y"
+#   version = "2.4.0"
+#
+# [prune]
+#   non-go = false
+#   go-tests = true
+#   unused-packages = true
+
+
+[prune]
+  go-tests = true
+  unused-packages = true

README.md

@@ -18,11 +18,13 @@
   - Support for variables inside translation strings using Go's [fmt syntax](https://golang.org/pkg/fmt/).
   - Support for [pluralization rules](https://www.gnu.org/software/gettext/manual/html_node/Translating-plural-forms.html).
   - Support for [message contexts](https://www.gnu.org/software/gettext/manual/html_node/Contexts.html).
+- Support for MO files. 
 - Thread-safe: This package is safe for concurrent use across multiple goroutines. 
 - It works with UTF-8 encoding as it's the default for Go language.
 - Unit tests available.
 - Language codes are automatically simplified from the form `en_UK` to `en` if the first isn't available.
 - Ready to use inside Go templates.
+- Objects are serializable to []byte to store them in cache.
 
 
 # License
@@ -46,14 +48,29 @@ go get github.com/leonelquinteros/gotext
 - No need for environment variables. Some naming conventions are applied but not needed.  
 
 
-#### Version vendoring
+### Version vendoring
 
 Stable releases use [semantic versioning](http://semver.org/spec/v2.0.0.html) tagging on this repository.
 
 You can rely on this to use your preferred vendoring tool or to manually retrieve the corresponding release tag from the GitHub repository.
 
 
-##### Vendoring with [gopkg.in](http://labix.org/gopkg.in)
+#### Vendoring with [dep](https://golang.github.io/dep/)
+
+To use last stable version (v1.3.1 at the moment of writing)
+
+```
+dep ensure -add github.com/leonelquinteros/gotext@v1.3.1
+```
+
+Import as
+
+```go
+import "github.com/leonelquinteros/gotext"
+```
+
+
+#### Vendoring with [gopkg.in](http://labix.org/gopkg.in)
 
 [http://gopkg.in/leonelquinteros/gotext.v1](http://gopkg.in/leonelquinteros/gotext.v1)
 
@@ -63,7 +80,7 @@ To get the latest v1 package stable release, execute:
 go get gopkg.in/leonelquinteros/gotext.v1
 ```
 
-To import this package, add the following line to your code:
+Import as
 
 ```go
 import "gopkg.in/leonelquinteros/gotext.v1"
@@ -116,39 +133,6 @@ A library directory structure can look like:
 And so on...
 
 
-
-# About translation function names
-
-The standard GNU gettext defines helper functions that maps to the `gettext()` function and it's widely adopted by most implementations. 
-
-The basic translation function is usually `_()` in the form: 
-
-```
-_("Translate this")
-``` 
-
-In Go, this can't be implemented by a reusable package as the function name has to start with a capital letter in order to be exported. 
-
-Each implementation of this package can declare this helper functions inside their own packages if this function naming are desired/needed: 
-
-```go
-package main
-
-import "github.com/leonelquinteros/gotext"
-
-func _(str string, vars ...interface{}) string {
-    return gotext.Get(str, vars...)
-}
-
-``` 
-
-This is valid and can be used within a package.
-
-In normal conditions the Go compiler will optimize the calls to `_()` by replacing its content in place of the function call to reduce the function calling overhead. 
-This is a normal Go compiler behavior.  
-
-
-
 # Usage examples
 
 ## Using package for single language/domain settings
@@ -261,7 +245,7 @@ msgstr "This one sets the var: %s"
 `
     
     // Create Po object
-    po := new(Po)
+    po := new(gotext.Po)
     po.Parse(str)
     
     fmt.Println(po.Get("Translate this"))
@@ -305,7 +289,7 @@ msgstr[1] "This one is the plural: %s"
 `
     
     // Create Po object
-    po := new(Po)
+    po := new(gotext.Po)
     po.Parse(str)
     
     fmt.Println(po.GetN("One with var: %s", "Several with vars: %s", 54, v))

fixtures/ar/categories.po

@@ -0,0 +1,6 @@
+msgid ""
+msgstr ""
+"Plural-Forms: nplurals=2; plural=(n != 1);\n"
+
+msgid "Alcohol & Tobacco"
+msgstr "الكحول والتبغ"

fixtures/de/default.po

@@ -0,0 +1,77 @@
+msgid ""
+msgstr ""
+"Plural-Forms: nplurals=2; plural=(n != 1);\n"
+"Project-Id-Version: \n"
+"POT-Creation-Date: \n"
+"PO-Revision-Date: \n"
+"Last-Translator: Josef Fröhle <froehle@b1-systems.de>\n"
+"Language-Team: \n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Language: de\n"
+"X-Generator: Poedit 2.0.6\n"
+"X-Poedit-SourceCharset: UTF-8\n"
+
+# Initial comment
+# Headers below
+msgid "language"
+msgstr "de"
+
+# Some comment
+msgid "My text"
+msgstr "Translated text"
+
+# More comments
+msgid "Another string"
+msgstr ""
+
+# Multi-line msgid
+msgid ""
+"multi\n"
+"line\n"
+"id"
+msgstr "id with multiline content"
+
+# Multi-line msgid_plural
+msgid ""
+"multi\n"
+"line\n"
+"plural\n"
+"id"
+msgstr "plural id with multiline content"
+
+# Multi-line string
+msgid "Multi-line"
+msgstr ""
+"Multi \n"
+"line"
+
+msgid "One with var: %s"
+msgid_plural "Several with vars: %s"
+msgstr[0] "This one is the singular: %s"
+msgstr[1] "This one is the plural: %s"
+
+msgctxt "Ctx"
+msgid "One with var: %s"
+msgid_plural "Several with vars: %s"
+msgstr[0] "This one is the singular in a Ctx context: %s"
+msgstr[1] "This one is the plural in a Ctx context: %s"
+
+msgid "Some random"
+msgstr "Some random translation"
+
+msgctxt "Ctx"
+msgid "Some random in a context"
+msgstr "Some random translation in a context"
+
+msgid "Empty translation"
+msgstr ""
+
+msgid "Empty plural form singular"
+msgid_plural "Empty plural form"
+msgstr[0] "Singular translated"
+msgstr[1] ""
+
+msgid "More"
+msgstr "More translation"

fixtures/de_DE/LC_MESSAGES/default.po

@@ -0,0 +1,77 @@
+msgid ""
+msgstr ""
+"Plural-Forms: nplurals=2; plural=(n != 1);\n"
+"Project-Id-Version: \n"
+"POT-Creation-Date: \n"
+"PO-Revision-Date: \n"
+"Last-Translator: Josef Fröhle <froehle@b1-systems.de>\n"
+"Language-Team: \n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Language: de_DE\n"
+"X-Generator: Poedit 2.0.6\n"
+"X-Poedit-SourceCharset: UTF-8\n"
+
+# Initial comment
+# Headers below
+msgid "language"
+msgstr "de_DE"
+
+# Some comment
+msgid "My text"
+msgstr "Translated text"
+
+# More comments
+msgid "Another string"
+msgstr ""
+
+# Multi-line msgid
+msgid ""
+"multi\n"
+"line\n"
+"id"
+msgstr "id with multiline content"
+
+# Multi-line msgid_plural
+msgid ""
+"multi\n"
+"line\n"
+"plural\n"
+"id"
+msgstr "plural id with multiline content"
+
+# Multi-line string
+msgid "Multi-line"
+msgstr ""
+"Multi \n"
+"line"
+
+msgid "One with var: %s"
+msgid_plural "Several with vars: %s"
+msgstr[0] "This one is the singular: %s"
+msgstr[1] "This one is the plural: %s"
+
+msgctxt "Ctx"
+msgid "One with var: %s"
+msgid_plural "Several with vars: %s"
+msgstr[0] "This one is the singular in a Ctx context: %s"
+msgstr[1] "This one is the plural in a Ctx context: %s"
+
+msgid "Some random"
+msgstr "Some random translation"
+
+msgctxt "Ctx"
+msgid "Some random in a context"
+msgstr "Some random translation in a context"
+
+msgid "Empty translation"
+msgstr ""
+
+msgid "Empty plural form singular"
+msgid_plural "Empty plural form"
+msgstr[0] "Singular translated"
+msgstr[1] ""
+
+msgid "More"
+msgstr "More translation"

fixtures/en_AU/default.po

@@ -0,0 +1,68 @@
+msgid ""
+msgstr ""
+"Plural-Forms: nplurals=2; plural=(n != 1);\n"
+"Project-Id-Version: \n"
+"POT-Creation-Date: \n"
+"PO-Revision-Date: \n"
+"Last-Translator: Josef Fröhle <froehle@b1-systems.de>\n"
+"Language-Team: \n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Language: en_US\n"
+"X-Generator: Poedit 2.0.6\n"
+"X-Poedit-SourceCharset: UTF-8\n"
+
+# Initial comment
+# Headers below
+msgid "language"
+msgstr "en_AU"
+
+# Some comment
+msgid "My text"
+msgstr "Translated text"
+
+# More comments
+msgid "Another string"
+msgstr ""
+
+# Multi-line msgid
+msgid "multilineid"
+msgstr "id with multiline content"
+
+# Multi-line msgid_plural
+msgid "multilinepluralid"
+msgstr "plural id with multiline content"
+
+# Multi-line string
+msgid "Multi-line"
+msgstr "Multi line"
+
+msgid "One with var: %s"
+msgid_plural "Several with vars: %s"
+msgstr[0] "This one is the singular: %s"
+msgstr[1] "This one is the plural: %s"
+
+msgctxt "Ctx"
+msgid "One with var: %s"
+msgid_plural "Several with vars: %s"
+msgstr[0] "This one is the singular in a Ctx context: %s"
+msgstr[1] "This one is the plural in a Ctx context: %s"
+
+msgid "Some random"
+msgstr "Some random translation"
+
+msgctxt "Ctx"
+msgid "Some random in a context"
+msgstr "Some random translation in a context"
+
+msgid "Empty translation"
+msgstr ""
+
+msgid "Empty plural form singular"
+msgid_plural "Empty plural form"
+msgstr[0] "Singular translated"
+msgstr[1] ""
+
+msgid "More"
+msgstr "More translation"

fixtures/en_US/default.po

@@ -0,0 +1,68 @@
+msgid ""
+msgstr ""
+"Plural-Forms: nplurals=2; plural=(n != 1);\n"
+"Project-Id-Version: \n"
+"POT-Creation-Date: \n"
+"PO-Revision-Date: \n"
+"Last-Translator: Josef Fröhle <froehle@b1-systems.de>\n"
+"Language-Team: \n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Language: en_US\n"
+"X-Generator: Poedit 2.0.6\n"
+"X-Poedit-SourceCharset: UTF-8\n"
+
+# Initial comment
+# Headers below
+msgid "language"
+msgstr "en_US"
+
+# Some comment
+msgid "My text"
+msgstr "Translated text"
+
+# More comments
+msgid "Another string"
+msgstr ""
+
+# Multi-line msgid
+msgid "multilineid"
+msgstr "id with multiline content"
+
+# Multi-line msgid_plural
+msgid "multilinepluralid"
+msgstr "plural id with multiline content"
+
+# Multi-line string
+msgid "Multi-line"
+msgstr "Multi line"
+
+msgid "One with var: %s"
+msgid_plural "Several with vars: %s"
+msgstr[0] "This one is the singular: %s"
+msgstr[1] "This one is the plural: %s"
+
+msgctxt "Ctx"
+msgid "One with var: %s"
+msgid_plural "Several with vars: %s"
+msgstr[0] "This one is the singular in a Ctx context: %s"
+msgstr[1] "This one is the plural in a Ctx context: %s"
+
+msgid "Some random"
+msgstr "Some random translation"
+
+msgctxt "Ctx"
+msgid "Some random in a context"
+msgstr "Some random translation in a context"
+
+msgid "Empty translation"
+msgstr ""
+
+msgid "Empty plural form singular"
+msgid_plural "Empty plural form"
+msgstr[0] "Singular translated"
+msgstr[1] ""
+
+msgid "More"
+msgstr "More translation"

fixtures/fr/LC_MESSAGES/default.po

@@ -0,0 +1,77 @@
+msgid ""
+msgstr ""
+"Plural-Forms: nplurals=2; plural=(n > 1);\n"
+"Project-Id-Version: \n"
+"POT-Creation-Date: \n"
+"PO-Revision-Date: \n"
+"Last-Translator: Josef Fröhle <froehle@b1-systems.de>\n"
+"Language-Team: \n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Language: fr\n"
+"X-Generator: Poedit 2.0.6\n"
+"X-Poedit-SourceCharset: UTF-8\n"
+
+# Initial comment
+# Headers below
+msgid "language"
+msgstr "fr"
+
+# Some comment
+msgid "My text"
+msgstr "Translated text"
+
+# More comments
+msgid "Another string"
+msgstr ""
+
+# Multi-line msgid
+msgid ""
+"multi\n"
+"line\n"
+"id"
+msgstr "id with multiline content"
+
+# Multi-line msgid_plural
+msgid ""
+"multi\n"
+"line\n"
+"plural\n"
+"id"
+msgstr "plural id with multiline content"
+
+# Multi-line string
+msgid "Multi-line"
+msgstr ""
+"Multi \n"
+"line"
+
+msgid "One with var: %s"
+msgid_plural "Several with vars: %s"
+msgstr[0] "This one is the singular: %s"
+msgstr[1] "This one is the plural: %s"
+
+msgctxt "Ctx"
+msgid "One with var: %s"
+msgid_plural "Several with vars: %s"
+msgstr[0] "This one is the singular in a Ctx context: %s"
+msgstr[1] "This one is the plural in a Ctx context: %s"
+
+msgid "Some random"
+msgstr "Some random translation"
+
+msgctxt "Ctx"
+msgid "Some random in a context"
+msgstr "Some random translation in a context"
+
+msgid "Empty translation"
+msgstr ""
+
+msgid "Empty plural form singular"
+msgid_plural "Empty plural form"
+msgstr[0] "Singular translated"
+msgstr[1] ""
+
+msgid "More"
+msgstr "More translation"

go.mod

@@ -0,0 +1,3 @@
+module github.com/leonelquinteros/gotext
+
+// go: no requirements found in Gopkg.lock

gotext.go

@@ -22,133 +22,200 @@ For quick/simple translations you can use the package level functions directly.
 */
 package gotext
 
+import (
+	"encoding/gob"
+	"sync"
+)
+
 // Global environment variables
-var (
+type config struct {
+	sync.RWMutex
+
 	// Default domain to look at when no domain is specified. Used by package level functions.
-	domain = "default"
+	domain string
 
 	// Language set.
-	language = "en_US"
+	language string
 
-	// Path to library directory where all locale directories and translation files are.
+	// Path to library directory where all locale directories and Translation files are.
-	library = "/usr/local/share/locale"
+	library string
 
 	// Storage for package level methods
 	storage *Locale
-)
+}
+
+var globalConfig *config
+
+func init() {
+	// Init default configuration
+	globalConfig = &config{
+		domain:   "default",
+		language: "en_US",
+		library:  "/usr/local/share/locale",
+		storage:  nil,
+	}
+
+	// Register Translator types for gob encoding
+	gob.Register(TranslatorEncoding{})
+}
 
 // loadStorage creates a new Locale object at package level based on the Global variables settings.
 // It's called automatically when trying to use Get or GetD methods.
 func loadStorage(force bool) {
-	if storage == nil || force {
+	globalConfig.Lock()
-		storage = NewLocale(library, language)
+
+	if globalConfig.storage == nil || force {
+		globalConfig.storage = NewLocale(globalConfig.library, globalConfig.language)
 	}
 
-	if _, ok := storage.domains[domain]; !ok || force {
+	if _, ok := globalConfig.storage.Domains[globalConfig.domain]; !ok || force {
-		storage.AddDomain(domain)
+		globalConfig.storage.AddDomain(globalConfig.domain)
 	}
+	globalConfig.storage.SetDomain(globalConfig.domain)
+
+	globalConfig.Unlock()
 }
 
 // GetDomain is the domain getter for the package configuration
 func GetDomain() string {
-	return domain
+	var dom string
+	globalConfig.RLock()
+	if globalConfig.storage != nil {
+		dom = globalConfig.storage.GetDomain()
+	}
+	if dom == "" {
+		dom = globalConfig.domain
+	}
+	globalConfig.RUnlock()
+
+	return dom
 }
 
 // SetDomain sets the name for the domain to be used at package level.
-// It reloads the corresponding translation file.
+// It reloads the corresponding Translation file.
 func SetDomain(dom string) {
-	domain = dom
+	globalConfig.Lock()
+	globalConfig.domain = dom
+	if globalConfig.storage != nil {
+		globalConfig.storage.SetDomain(dom)
+	}
+	globalConfig.Unlock()
+
 	loadStorage(true)
 }
 
 // GetLanguage is the language getter for the package configuration
 func GetLanguage() string {
-	return language
+	globalConfig.RLock()
+	lang := globalConfig.language
+	globalConfig.RUnlock()
+
+	return lang
 }
 
 // SetLanguage sets the language code to be used at package level.
-// It reloads the corresponding translation file.
+// It reloads the corresponding Translation file.
 func SetLanguage(lang string) {
-	language = lang
+	globalConfig.Lock()
+	globalConfig.language = SimplifiedLocale(lang)
+	globalConfig.Unlock()
+
 	loadStorage(true)
 }
 
 // GetLibrary is the library getter for the package configuration
 func GetLibrary() string {
-	return library
+	globalConfig.RLock()
+	lib := globalConfig.library
+	globalConfig.RUnlock()
+
+	return lib
 }
 
 // SetLibrary sets the root path for the loale directories and files to be used at package level.
-// It reloads the corresponding translation file.
+// It reloads the corresponding Translation file.
 func SetLibrary(lib string) {
-	library = lib
+	globalConfig.Lock()
+	globalConfig.library = lib
+	globalConfig.Unlock()
+
 	loadStorage(true)
 }
 
-// Configure sets all configuration variables to be used at package level and reloads the corresponding translation file.
+// Configure sets all configuration variables to be used at package level and reloads the corresponding Translation file.
 // It receives the library path, language code and domain name.
 // This function is recommended to be used when changing more than one setting,
-// as using each setter will introduce a I/O overhead because the translation file will be loaded after each set.
+// as using each setter will introduce a I/O overhead because the Translation file will be loaded after each set.
 func Configure(lib, lang, dom string) {
-	library = lib
+	globalConfig.Lock()
-	language = lang
+	globalConfig.library = lib
-	domain = dom
+	globalConfig.language = SimplifiedLocale(lang)
+	globalConfig.domain = dom
+	globalConfig.Unlock()
 
 	loadStorage(true)
 }
 
-// Get uses the default domain globally set to return the corresponding translation of a given string.
+// Get uses the default domain globally set to return the corresponding Translation of a given string.
 // Supports optional parameters (vars... interface{}) to be inserted on the formatted string using the fmt.Printf syntax.
 func Get(str string, vars ...interface{}) string {
-	return GetD(domain, str, vars...)
+	return GetD(GetDomain(), str, vars...)
 }
 
-// GetN retrieves the (N)th plural form of translation for the given string in the "default" domain.
+// GetN retrieves the (N)th plural form of Translation for the given string in the default domain.
 // Supports optional parameters (vars... interface{}) to be inserted on the formatted string using the fmt.Printf syntax.
 func GetN(str, plural string, n int, vars ...interface{}) string {
-	return GetND("default", str, plural, n, vars...)
+	return GetND(GetDomain(), str, plural, n, vars...)
 }
 
-// GetD returns the corresponding translation in the given domain for a given string.
+// GetD returns the corresponding Translation in the given domain for a given string.
 // Supports optional parameters (vars... interface{}) to be inserted on the formatted string using the fmt.Printf syntax.
 func GetD(dom, str string, vars ...interface{}) string {
 	return GetND(dom, str, str, 1, vars...)
 }
 
-// GetND retrieves the (N)th plural form of translation in the given domain for a given string.
+// GetND retrieves the (N)th plural form of Translation in the given domain for a given string.
 // Supports optional parameters (vars... interface{}) to be inserted on the formatted string using the fmt.Printf syntax.
 func GetND(dom, str, plural string, n int, vars ...interface{}) string {
 	// Try to load default package Locale storage
 	loadStorage(false)
 
-	// Return translation
+	// Return Translation
-	return storage.GetND(dom, str, plural, n, vars...)
+	globalConfig.RLock()
+	tr := globalConfig.storage.GetND(dom, str, plural, n, vars...)
+	globalConfig.RUnlock()
+
+	return tr
 }
 
-// GetC uses the default domain globally set to return the corresponding translation of the given string in the given context.
+// GetC uses the default domain globally set to return the corresponding Translation of the given string in the given context.
 // Supports optional parameters (vars... interface{}) to be inserted on the formatted string using the fmt.Printf syntax.
 func GetC(str, ctx string, vars ...interface{}) string {
-	return GetDC(domain, str, ctx, vars...)
+	return GetDC(GetDomain(), str, ctx, vars...)
 }
 
-// GetNC retrieves the (N)th plural form of translation for the given string in the given context in the "default" domain.
+// GetNC retrieves the (N)th plural form of Translation for the given string in the given context in the default domain.
 // Supports optional parameters (vars... interface{}) to be inserted on the formatted string using the fmt.Printf syntax.
 func GetNC(str, plural string, n int, ctx string, vars ...interface{}) string {
-	return GetNDC("default", str, plural, n, ctx, vars...)
+	return GetNDC(GetDomain(), str, plural, n, ctx, vars...)
 }
 
-// GetDC returns the corresponding translation in the given domain for the given string in the given context.
+// GetDC returns the corresponding Translation in the given domain for the given string in the given context.
 // Supports optional parameters (vars... interface{}) to be inserted on the formatted string using the fmt.Printf syntax.
 func GetDC(dom, str, ctx string, vars ...interface{}) string {
 	return GetNDC(dom, str, str, 1, ctx, vars...)
 }
 
-// GetNDC retrieves the (N)th plural form of translation in the given domain for a given string.
+// GetNDC retrieves the (N)th plural form of Translation in the given domain for a given string.
 // Supports optional parameters (vars... interface{}) to be inserted on the formatted string using the fmt.Printf syntax.
 func GetNDC(dom, str, plural string, n int, ctx string, vars ...interface{}) string {
 	// Try to load default package Locale storage
 	loadStorage(false)
 
-	// Return translation
+	// Return Translation
-	return storage.GetNDC(dom, str, plural, n, ctx, vars...)
+	globalConfig.RLock()
+	tr := globalConfig.storage.GetNDC(dom, str, plural, n, ctx, vars...)
+	globalConfig.RUnlock()
+
+	return tr
 }

gotext_test.go

@@ -3,6 +3,8 @@ package gotext
 import (
 	"os"
 	"path"
+	"path/filepath"
+	"sync"
 	"testing"
 )
 
@@ -32,10 +34,12 @@ func TestGettersSetters(t *testing.T) {
 func TestPackageFunctions(t *testing.T) {
 	// Set PO content
 	str := `
-# msgid ""
+msgid   ""
-# msgstr ""
+msgstr  "Project-Id-Version: %s\n"
+        "Report-Msgid-Bugs-To: %s\n"
+        
 # Initial comment
-# Headers below
+# More Headers below
 "Language: en\n"
 "Content-Type: text/plain; charset=UTF-8\n"
 "Content-Transfer-Encoding: 8bit\n"
@@ -55,14 +59,6 @@ msgstr[0] "This one is the singular: %s"
 msgstr[1] "This one is the plural: %s"
 msgstr[2] "And this is the second plural form: %s"
 
-msgid "This one has invalid syntax translations"
-msgid_plural "Plural index"
-msgstr[abc] "Wrong index"
-msgstr[1 "Forgot to close brackets"
-msgstr[0] "Badly formatted string'
-
-msgid "Invalid formatted id[] with no translations
-
 msgctxt "Ctx"
 msgid "One with var: %s"
 msgid_plural "Several with vars: %s"
@@ -70,14 +66,14 @@ msgstr[0] "This one is the singular in a Ctx context: %s"
 msgstr[1] "This one is the plural in a Ctx context: %s"
 
 msgid "Some random"
-msgstr "Some random translation"
+msgstr "Some random Translation"
 
 msgctxt "Ctx"
 msgid "Some random in a context"
-msgstr "Some random translation in a context"
+msgstr "Some random Translation in a context"
 
 msgid "More"
-msgstr "More translation"
+msgstr "More Translation"
 
 msgid "Untranslated"
 msgid_plural "Several untranslated"
@@ -87,26 +83,28 @@ msgstr[1] ""
 	`
 
 	// Create Locales directory on default location
-	dirname := path.Clean("/tmp" + string(os.PathSeparator) + "en_US")
+	dirname := path.Join("/tmp", "en_US")
 	err := os.MkdirAll(dirname, os.ModePerm)
 	if err != nil {
 		t.Fatalf("Can't create test directory: %s", err.Error())
 	}
 
 	// Write PO content to default domain file
-	filename := path.Clean(dirname + string(os.PathSeparator) + "default.po")
+	filename := path.Join(dirname, "default.po")
 
 	f, err := os.Create(filename)
 	if err != nil {
 		t.Fatalf("Can't create test file: %s", err.Error())
 	}
-	defer f.Close()
 
 	_, err = f.WriteString(str)
 	if err != nil {
 		t.Fatalf("Can't write to test file: %s", err.Error())
 	}
 
+	// Move file close to write the file, so we can use it in the next step
+	f.Close()
+
 	// Set package configuration
 	Configure("/tmp", "en_US", "default")
 
@@ -130,8 +128,8 @@ msgstr[1] ""
 
 	// Test context translations
 	tr = GetC("Some random in a context", "Ctx")
-	if tr != "Some random translation in a context" {
+	if tr != "Some random Translation in a context" {
-		t.Errorf("Expected 'Some random translation in a context' but got '%s'", tr)
+		t.Errorf("Expected 'Some random Translation in a context' but got '%s'", tr)
 	}
 
 	v = "Variable"
@@ -149,8 +147,8 @@ msgstr[1] ""
 func TestUntranslated(t *testing.T) {
 	// Set PO content
 	str := `
-# msgid ""
+msgid ""
-# msgstr ""
+msgstr ""
 # Initial comment
 # Headers below
 "Language: en\n"
@@ -166,14 +164,14 @@ msgstr[1] ""
 	`
 
 	// Create Locales directory on default location
-	dirname := path.Clean("/tmp" + string(os.PathSeparator) + "en_US")
+	dirname := path.Join("/tmp", "en_US")
 	err := os.MkdirAll(dirname, os.ModePerm)
 	if err != nil {
 		t.Fatalf("Can't create test directory: %s", err.Error())
 	}
 
 	// Write PO content to default domain file
-	filename := path.Clean(dirname + string(os.PathSeparator) + "default.po")
+	filename := path.Join(dirname, "default.po")
 
 	f, err := os.Create(filename)
 	if err != nil {
@@ -219,6 +217,140 @@ msgstr[1] ""
 	}
 }
 
+func TestMoAndPoTranslator(t *testing.T) {
+
+	fixPath, _ := filepath.Abs("./fixtures/")
+
+	Configure(fixPath, "en_GB", "default")
+
+	// Check default domain Translation
+	SetDomain("default")
+	tr := Get("My text")
+	if tr != "Translated text" {
+		t.Errorf("Expected 'Translated text'. Got '%s'", tr)
+	}
+	tr = Get("language")
+	if tr != "en_GB" {
+		t.Errorf("Expected 'en_GB'. Got '%s'", tr)
+	}
+
+	// Change Language (locale)
+	SetLanguage("en_AU")
+
+	// Check default domain Translation
+	SetDomain("default")
+	tr = Get("My text")
+	if tr != "Translated text" {
+		t.Errorf("Expected 'Translated text'. Got '%s'", tr)
+	}
+	tr = Get("language")
+	if tr != "en_AU" {
+		t.Errorf("Expected 'en_AU'. Got '%s'", tr)
+	}
+}
+
+func TestDomains(t *testing.T) {
+	// Set PO content
+	strDefault := `
+msgid ""
+msgstr "Plural-Forms: nplurals=2; plural=(n != 1);\n"
+
+msgid "Default text"
+msgid_plural "Default texts"
+msgstr[0] "Default Translation"
+msgstr[1] "Default translations"
+
+msgctxt "Ctx"
+msgid "Default context"
+msgid_plural "Default contexts"
+msgstr[0] "Default ctx Translation"
+msgstr[1] "Default ctx translations"
+	`
+
+	strCustom := `
+msgid ""
+msgstr "Plural-Forms: nplurals=2; plural=(n != 1);\n"
+
+msgid "Custom text"
+msgid_plural "Custom texts"
+msgstr[0] "Custom Translation"
+msgstr[1] "Custom translations"
+
+msgctxt "Ctx"
+msgid "Custom context"
+msgid_plural "Custom contexts"
+msgstr[0] "Custom ctx Translation"
+msgstr[1] "Custom ctx translations"
+	`
+
+	// Create Locales directory and files on temp location
+	dirname := path.Join("/tmp", "en_US")
+	err := os.MkdirAll(dirname, os.ModePerm)
+	if err != nil {
+		t.Fatalf("Can't create test directory: %s", err.Error())
+	}
+
+	fDefault, err := os.Create(path.Join(dirname, "default.po"))
+	if err != nil {
+		t.Fatalf("Can't create test file: %s", err.Error())
+	}
+	defer fDefault.Close()
+
+	fCustom, err := os.Create(path.Join(dirname, "custom.po"))
+	if err != nil {
+		t.Fatalf("Can't create test file: %s", err.Error())
+	}
+	defer fCustom.Close()
+
+	_, err = fDefault.WriteString(strDefault)
+	if err != nil {
+		t.Fatalf("Can't write to test file: %s", err.Error())
+	}
+	_, err = fCustom.WriteString(strCustom)
+	if err != nil {
+		t.Fatalf("Can't write to test file: %s", err.Error())
+	}
+
+	Configure("/tmp", "en_US", "default")
+
+	// Check default domain Translation
+	SetDomain("default")
+	tr := Get("Default text")
+	if tr != "Default Translation" {
+		t.Errorf("Expected 'Default Translation'. Got '%s'", tr)
+	}
+	tr = GetN("Default text", "Default texts", 23)
+	if tr != "Default translations" {
+		t.Errorf("Expected 'Default translations'. Got '%s'", tr)
+	}
+	tr = GetC("Default context", "Ctx")
+	if tr != "Default ctx Translation" {
+		t.Errorf("Expected 'Default ctx Translation'. Got '%s'", tr)
+	}
+	tr = GetNC("Default context", "Default contexts", 23, "Ctx")
+	if tr != "Default ctx translations" {
+		t.Errorf("Expected 'Default ctx translations'. Got '%s'", tr)
+	}
+
+	SetDomain("custom")
+	tr = Get("Custom text")
+	if tr != "Custom Translation" {
+		t.Errorf("Expected 'Custom Translation'. Got '%s'", tr)
+	}
+	tr = GetN("Custom text", "Custom texts", 23)
+	if tr != "Custom translations" {
+		t.Errorf("Expected 'Custom translations'. Got '%s'", tr)
+	}
+	tr = GetC("Custom context", "Ctx")
+	if tr != "Custom ctx Translation" {
+		t.Errorf("Expected 'Custom ctx Translation'. Got '%s'", tr)
+	}
+	tr = GetNC("Custom context", "Custom contexts", 23, "Ctx")
+	if tr != "Custom ctx translations" {
+		t.Errorf("Expected 'Custom ctx translations'. Got '%s'", tr)
+	}
+}
+
 func TestPackageRace(t *testing.T) {
 	// Set PO content
 	str := `# Some comment
@@ -235,17 +367,21 @@ msgstr[0] "This one is the singular: %s"
 msgstr[1] "This one is the plural: %s"
 msgstr[2] "And this is the second plural form: %s"
 
+msgctxt "Ctx"
+msgid "Some random in a context"
+msgstr "Some random Translation in a context"
+
 	`
 
 	// Create Locales directory on default location
-	dirname := path.Clean(library + string(os.PathSeparator) + "en_US")
+	dirname := path.Join("/tmp", "en_US")
 	err := os.MkdirAll(dirname, os.ModePerm)
 	if err != nil {
 		t.Fatalf("Can't create test directory: %s", err.Error())
 	}
 
 	// Write PO content to default domain file
-	filename := path.Clean(dirname + string(os.PathSeparator) + domain + ".po")
+	filename := path.Join("/tmp", GetDomain()+".po")
 
 	f, err := os.Create(filename)
 	if err != nil {
@@ -258,22 +394,27 @@ msgstr[2] "And this is the second plural form: %s"
 		t.Fatalf("Can't write to test file: %s", err.Error())
 	}
 
-	// Init sync channels
+	var wg sync.WaitGroup
-	c1 := make(chan bool)
-	c2 := make(chan bool)
 
-	for i := 0; i < 100; i++ {
+	for i := 0; i < 1000; i++ {
+		wg.Add(1)
 		// Test translations
-		go func(done chan bool) {
+		go func() {
-			Get("My text")
+			defer wg.Done()
-			done <- true
-		}(c1)
 
-		go func(done chan bool) {
+			GetLibrary()
-			Get("My text")
+			SetLibrary(path.Join("/tmp", "gotextlib"))
-			done <- true
+			GetDomain()
-		}(c2)
+			SetDomain("default")
+			GetLanguage()
+			SetLanguage("en_US")
+			Configure("/tmp", "en_US", "default")
 
-		Get("My text")
+			Get("My text")
+			GetN("One with var: %s", "Several with vars: %s", 0, "test")
+			GetC("Some random in a context", "Ctx")
+		}()
 	}
+
+	wg.Wait()
 }

helper.go

@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) 2018 DeineAgentur UG https://www.deineagentur.com. All rights reserved.
+ * Licensed under the MIT License. See LICENSE file in the project root for full license information.
+ */
+
+package gotext
+
+import (
+	"fmt"
+	"regexp"
+	"strings"
+)
+
+var re = regexp.MustCompile(`%\(([a-zA-Z0-9_]+)\)[.0-9]*[svTtbcdoqXxUeEfFgGp]`)
+
+// SimplifiedLocale simplified locale like " en_US"/"de_DE "/en_US.UTF-8/zh_CN/zh_TW/el_GR@euro/... to en_US, de_DE, zh_CN, el_GR...
+func SimplifiedLocale(lang string) string {
+	// en_US/en_US.UTF-8/zh_CN/zh_TW/el_GR@euro/...
+	if idx := strings.Index(lang, ":"); idx != -1 {
+		lang = lang[:idx]
+	}
+	if idx := strings.Index(lang, "@"); idx != -1 {
+		lang = lang[:idx]
+	}
+	if idx := strings.Index(lang, "."); idx != -1 {
+		lang = lang[:idx]
+	}
+	return strings.TrimSpace(lang)
+}
+
+// Printf applies text formatting only when needed to parse variables.
+func Printf(str string, vars ...interface{}) string {
+	if len(vars) > 0 {
+		return fmt.Sprintf(str, vars...)
+	}
+
+	return str
+}
+
+// NPrintf support named format
+// NPrintf("%(name)s is Type %(type)s", map[string]interface{}{"name": "Gotext", "type": "struct"})
+func NPrintf(format string, params map[string]interface{}) {
+	f, p := parseSprintf(format, params)
+	fmt.Printf(f, p...)
+}
+
+// Sprintf support named format
+//      Sprintf("%(name)s is Type %(type)s", map[string]interface{}{"name": "Gotext", "type": "struct"})
+func Sprintf(format string, params map[string]interface{}) string {
+	f, p := parseSprintf(format, params)
+	return fmt.Sprintf(f, p...)
+}
+
+func parseSprintf(format string, params map[string]interface{}) (string, []interface{}) {
+	f, n := reformatSprintf(format)
+	var p []interface{}
+	for _, v := range n {
+		p = append(p, params[v])
+	}
+	return f, p
+}
+
+func reformatSprintf(f string) (string, []string) {
+	m := re.FindAllStringSubmatch(f, -1)
+	i := re.FindAllStringSubmatchIndex(f, -1)
+
+	ord := []string{}
+	for _, v := range m {
+		ord = append(ord, v[1])
+	}
+
+	pair := []int{0}
+	for _, v := range i {
+		pair = append(pair, v[2]-1)
+		pair = append(pair, v[3]+1)
+	}
+	pair = append(pair, len(f))
+	plen := len(pair)
+
+	out := ""
+	for n := 0; n < plen; n += 2 {
+		out += f[pair[n]:pair[n+1]]
+	}
+
+	return out, ord
+}

helper_test.go

@@ -0,0 +1,112 @@
+/*
+ * Copyright (c) 2018 DeineAgentur UG https://www.deineagentur.com. All rights reserved.
+ * Licensed under the MIT License. See LICENSE file in the project root for full license information.
+ */
+
+package gotext
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestSimplifiedLocale(t *testing.T) {
+	tr :=SimplifiedLocale("de_DE@euro")
+	if tr != "de_DE" {
+		t.Errorf("Expected 'de_DE' but got '%s'", tr)
+	}
+
+	tr =SimplifiedLocale("de_DE.UTF-8")
+	if tr != "de_DE" {
+		t.Errorf("Expected 'de_DE' but got '%s'", tr)
+	}
+
+	tr =SimplifiedLocale("de_DE:latin1")
+	if tr != "de_DE" {
+		t.Errorf("Expected 'de_DE' but got '%s'", tr)
+	}
+}
+
+func TestReformattingSingleNamedPattern(t *testing.T) {
+	pat := "%(name_me)x"
+
+	f, n := reformatSprintf(pat)
+
+	if f != "%x" {
+		t.Errorf("pattern should be %%x but %v", f)
+	}
+
+	if !reflect.DeepEqual(n, []string{"name_me"}) {
+		t.Errorf("named var should be {name_me} but %v", n)
+	}
+}
+
+func TestReformattingMultipleNamedPattern(t *testing.T) {
+	pat := "%(name_me)x and %(another_name)v"
+
+	f, n := reformatSprintf(pat)
+
+	if f != "%x and %v" {
+		t.Errorf("pattern should be %%x and %%v but %v", f)
+	}
+
+	if !reflect.DeepEqual(n, []string{"name_me", "another_name"}) {
+		t.Errorf("named var should be {name_me, another_name} but %v", n)
+	}
+}
+
+func TestReformattingRepeatedNamedPattern(t *testing.T) {
+	pat := "%(name_me)x and %(another_name)v and %(name_me)v"
+
+	f, n := reformatSprintf(pat)
+
+	if f != "%x and %v and %v" {
+		t.Errorf("pattern should be %%x and %%v and %%v but %v", f)
+	}
+
+	if !reflect.DeepEqual(n, []string{"name_me", "another_name", "name_me"}) {
+		t.Errorf("named var should be {name_me, another_name, name_me} but %v", n)
+	}
+}
+
+func TestSprintf(t *testing.T) {
+	pat := "%(brother)s loves %(sister)s. %(sister)s also loves %(brother)s."
+	params := map[string]interface{}{
+		"sister":  "Susan",
+		"brother": "Louis",
+	}
+
+	s := Sprintf(pat, params)
+
+	if s != "Louis loves Susan. Susan also loves Louis." {
+		t.Errorf("result should be Louis loves Susan. Susan also love Louis. but %v", s)
+	}
+}
+
+func TestNPrintf(t *testing.T) {
+	pat := "%(brother)s loves %(sister)s. %(sister)s also loves %(brother)s.\n"
+	params := map[string]interface{}{
+		"sister":  "Susan",
+		"brother": "Louis",
+	}
+
+	NPrintf(pat, params)
+
+}
+
+func TestSprintfFloatsWithPrecision(t *testing.T) {
+	pat := "%(float)f / %(floatprecision).1f / %(long)g / %(longprecision).3g"
+	params := map[string]interface{}{
+		"float": 5.034560,
+		"floatprecision": 5.03456,
+		"long": 5.03456,
+		"longprecision": 5.03456,
+	}
+
+	s := Sprintf(pat, params)
+
+	expectedresult := "5.034560 / 5.0 / 5.03456 / 5.03"
+	if s != expectedresult {
+		t.Errorf("result should be (%v) but is (%v)", expectedresult, s)
+	}
+}

locale.go

@@ -1,7 +1,13 @@
+/*
+ * Copyright (c) 2018 DeineAgentur UG https://www.deineagentur.com. All rights reserved.
+ * Licensed under the MIT License. See LICENSE file in the project root for full license information.
+ */
+
 package gotext
 
 import (
-	"fmt"
+	"bytes"
+	"encoding/gob"
 	"os"
 	"path"
 	"sync"
@@ -15,6 +21,8 @@ multiple languages at the same time by working with this object.
 Example:
 
     import (
+	"encoding/gob"
+	"bytes"
 	    "fmt"
 	    "github.com/leonelquinteros/gotext"
     )
@@ -23,13 +31,13 @@ Example:
         // Create Locale with library path and language code
         l := gotext.NewLocale("/path/to/i18n/dir", "en_US")
 
-        // Load domain '/path/to/i18n/dir/en_US/LC_MESSAGES/default.po'
+        // Load domain '/path/to/i18n/dir/en_US/LC_MESSAGES/default.{po,mo}'
         l.AddDomain("default")
 
         // Translate text from default domain
         fmt.Println(l.Get("Translate this"))
 
-        // Load different domain ('/path/to/i18n/dir/en_US/LC_MESSAGES/extras.po')
+        // Load different domain ('/path/to/i18n/dir/en_US/LC_MESSAGES/extras.{po,mo}')
         l.AddDomain("extras")
 
         // Translate text from domain
@@ -44,136 +52,253 @@ type Locale struct {
 	// Language for this Locale
 	lang string
 
-	// List of available domains for this locale.
+	// List of available Domains for this locale.
-	domains map[string]*Po
+	Domains map[string]Translator
+
+	// First AddDomain is default Domain
+	defaultDomain string
 
 	// Sync Mutex
 	sync.RWMutex
 }
 
 // NewLocale creates and initializes a new Locale object for a given language.
-// It receives a path for the i18n files directory (p) and a language code to use (l).
+// It receives a path for the i18n .po/.mo files directory (p) and a language code to use (l).
 func NewLocale(p, l string) *Locale {
 	return &Locale{
 		path:    p,
-		lang:    l,
+		lang:    SimplifiedLocale(l),
-		domains: make(map[string]*Po),
+		Domains: make(map[string]Translator),
 	}
 }
 
-func (l *Locale) findPO(dom string) string {
+func (l *Locale) findExt(dom, ext string) string {
-	filename := path.Join(l.path, l.lang, "LC_MESSAGES", dom+".po")
+	filename := path.Join(l.path, l.lang, "LC_MESSAGES", dom+"."+ext)
 	if _, err := os.Stat(filename); err == nil {
 		return filename
 	}
 
 	if len(l.lang) > 2 {
-		filename = path.Join(l.path, l.lang[:2], "LC_MESSAGES", dom+".po")
+		filename = path.Join(l.path, l.lang[:2], "LC_MESSAGES", dom+"."+ext)
 		if _, err := os.Stat(filename); err == nil {
 			return filename
 		}
 	}
 
-	filename = path.Join(l.path, l.lang, dom+".po")
+	filename = path.Join(l.path, l.lang, dom+"."+ext)
 	if _, err := os.Stat(filename); err == nil {
 		return filename
 	}
 
 	if len(l.lang) > 2 {
-		filename = path.Join(l.path, l.lang[:2], dom+".po")
+		filename = path.Join(l.path, l.lang[:2], dom+"."+ext)
+		if _, err := os.Stat(filename); err == nil {
+			return filename
+		}
 	}
 
-	return filename
+	return ""
 }
 
 // AddDomain creates a new domain for a given locale object and initializes the Po object.
 // If the domain exists, it gets reloaded.
 func (l *Locale) AddDomain(dom string) {
-	po := new(Po)
+	var poObj Translator
 
-	// Parse file.
+	file := l.findExt(dom, "po")
-	po.ParseFile(l.findPO(dom))
+	if file != "" {
+		poObj = new(Po)
+		// Parse file.
+		poObj.ParseFile(file)
+	} else {
+		file = l.findExt(dom, "mo")
+		if file != "" {
+			poObj = new(Mo)
+			// Parse file.
+			poObj.ParseFile(file)
+		} else {
+			// fallback return if no file found with
+			return
+		}
+	}
 
 	// Save new domain
 	l.Lock()
-	defer l.Unlock()
 
-	if l.domains == nil {
+	if l.Domains == nil {
-		l.domains = make(map[string]*Po)
+		l.Domains = make(map[string]Translator)
 	}
-	l.domains[dom] = po
+	if l.defaultDomain == "" {
+		l.defaultDomain = dom
+	}
+	l.Domains[dom] = poObj
+
+	// Unlock "Save new domain"
+	l.Unlock()
 }
 
-// Get uses a domain "default" to return the corresponding translation of a given string.
+// AddTranslator takes a domain name and a Translator object to make it available in the Locale object.
+func (l *Locale) AddTranslator(dom string, tr Translator) {
+	l.Lock()
+
+	if l.Domains == nil {
+		l.Domains = make(map[string]Translator)
+	}
+	if l.defaultDomain == "" {
+		l.defaultDomain = dom
+	}
+	l.Domains[dom] = tr
+
+	l.Unlock()
+}
+
+// GetDomain is the domain getter for the package configuration
+func (l *Locale) GetDomain() string {
+	l.RLock()
+	dom := l.defaultDomain
+	l.RUnlock()
+	return dom
+}
+
+// SetDomain sets the name for the domain to be used.
+func (l *Locale) SetDomain(dom string) {
+	l.Lock()
+	l.defaultDomain = dom
+	l.Unlock()
+}
+
+// Get uses a domain "default" to return the corresponding Translation of a given string.
 // Supports optional parameters (vars... interface{}) to be inserted on the formatted string using the fmt.Printf syntax.
 func (l *Locale) Get(str string, vars ...interface{}) string {
-	return l.GetD("default", str, vars...)
+	return l.GetD(l.GetDomain(), str, vars...)
 }
 
-// GetN retrieves the (N)th plural form of translation for the given string in the "default" domain.
+// GetN retrieves the (N)th plural form of Translation for the given string in the "default" domain.
 // Supports optional parameters (vars... interface{}) to be inserted on the formatted string using the fmt.Printf syntax.
 func (l *Locale) GetN(str, plural string, n int, vars ...interface{}) string {
-	return l.GetND("default", str, plural, n, vars...)
+	return l.GetND(l.GetDomain(), str, plural, n, vars...)
 }
 
-// GetD returns the corresponding translation in the given domain for the given string.
+// GetD returns the corresponding Translation in the given domain for the given string.
 // Supports optional parameters (vars... interface{}) to be inserted on the formatted string using the fmt.Printf syntax.
 func (l *Locale) GetD(dom, str string, vars ...interface{}) string {
 	return l.GetND(dom, str, str, 1, vars...)
 }
 
-// GetND retrieves the (N)th plural form of translation in the given domain for the given string.
+// GetND retrieves the (N)th plural form of Translation in the given domain for the given string.
 // Supports optional parameters (vars... interface{}) to be inserted on the formatted string using the fmt.Printf syntax.
 func (l *Locale) GetND(dom, str, plural string, n int, vars ...interface{}) string {
 	// Sync read
 	l.RLock()
 	defer l.RUnlock()
 
-	if l.domains != nil {
+	if l.Domains != nil {
-		if _, ok := l.domains[dom]; ok {
+		if _, ok := l.Domains[dom]; ok {
-			if l.domains[dom] != nil {
+			if l.Domains[dom] != nil {
-				return l.domains[dom].GetN(str, plural, n, vars...)
+				return l.Domains[dom].GetN(str, plural, n, vars...)
 			}
 		}
 	}
 
 	// Return the same we received by default
-	return fmt.Sprintf(plural, vars...)
+	return Printf(plural, vars...)
 }
 
-// GetC uses a domain "default" to return the corresponding translation of the given string in the given context.
+// GetC uses a domain "default" to return the corresponding Translation of the given string in the given context.
 // Supports optional parameters (vars... interface{}) to be inserted on the formatted string using the fmt.Printf syntax.
 func (l *Locale) GetC(str, ctx string, vars ...interface{}) string {
-	return l.GetDC("default", str, ctx, vars...)
+	return l.GetDC(l.GetDomain(), str, ctx, vars...)
 }
 
-// GetNC retrieves the (N)th plural form of translation for the given string in the given context in the "default" domain.
+// GetNC retrieves the (N)th plural form of Translation for the given string in the given context in the "default" domain.
 // Supports optional parameters (vars... interface{}) to be inserted on the formatted string using the fmt.Printf syntax.
 func (l *Locale) GetNC(str, plural string, n int, ctx string, vars ...interface{}) string {
-	return l.GetNDC("default", str, plural, n, ctx, vars...)
+	return l.GetNDC(l.GetDomain(), str, plural, n, ctx, vars...)
 }
 
-// GetDC returns the corresponding translation in the given domain for the given string in the given context.
+// GetDC returns the corresponding Translation in the given domain for the given string in the given context.
 // Supports optional parameters (vars... interface{}) to be inserted on the formatted string using the fmt.Printf syntax.
 func (l *Locale) GetDC(dom, str, ctx string, vars ...interface{}) string {
 	return l.GetNDC(dom, str, str, 1, ctx, vars...)
 }
 
-// GetNDC retrieves the (N)th plural form of translation in the given domain for the given string in the given context.
+// GetNDC retrieves the (N)th plural form of Translation in the given domain for the given string in the given context.
 // Supports optional parameters (vars... interface{}) to be inserted on the formatted string using the fmt.Printf syntax.
 func (l *Locale) GetNDC(dom, str, plural string, n int, ctx string, vars ...interface{}) string {
 	// Sync read
 	l.RLock()
 	defer l.RUnlock()
 
-	if l.domains != nil {
+	if l.Domains != nil {
-		if _, ok := l.domains[dom]; ok {
+		if _, ok := l.Domains[dom]; ok {
-			if l.domains[dom] != nil {
+			if l.Domains[dom] != nil {
-				return l.domains[dom].GetNC(str, plural, n, ctx, vars...)
+				return l.Domains[dom].GetNC(str, plural, n, ctx, vars...)
 			}
 		}
 	}
 
 	// Return the same we received by default
-	return fmt.Sprintf(plural, vars...)
+	return Printf(plural, vars...)
+}
+
+// LocaleEncoding is used as intermediary storage to encode Locale objects to Gob.
+type LocaleEncoding struct {
+	Path          string
+	Lang          string
+	Domains       map[string][]byte
+	DefaultDomain string
+}
+
+// MarshalBinary implements encoding BinaryMarshaler interface
+func (l *Locale) MarshalBinary() ([]byte, error) {
+	obj := new(LocaleEncoding)
+	obj.DefaultDomain = l.defaultDomain
+	obj.Domains = make(map[string][]byte)
+	for k, v := range l.Domains {
+		var err error
+		obj.Domains[k], err = v.MarshalBinary()
+		if err != nil {
+			return nil, err
+		}
+	}
+	obj.Lang = l.lang
+	obj.Path = l.path
+
+	var buff bytes.Buffer
+	encoder := gob.NewEncoder(&buff)
+	err := encoder.Encode(obj)
+
+	return buff.Bytes(), err
+}
+
+// UnmarshalBinary implements encoding BinaryUnmarshaler interface
+func (l *Locale) UnmarshalBinary(data []byte) error {
+	buff := bytes.NewBuffer(data)
+	obj := new(LocaleEncoding)
+
+	decoder := gob.NewDecoder(buff)
+	err := decoder.Decode(obj)
+	if err != nil {
+		return err
+	}
+
+	l.defaultDomain = obj.DefaultDomain
+	l.lang = obj.Lang
+	l.path = obj.Path
+
+	// Decode Domains
+	l.Domains = make(map[string]Translator)
+	for k, v := range obj.Domains {
+		var tr TranslatorEncoding
+		buff := bytes.NewBuffer(v)
+		trDecoder := gob.NewDecoder(buff)
+		err := trDecoder.Decode(&tr)
+		if err != nil {
+			return err
+		}
+
+		l.Domains[k] = tr.GetTranslator()
+	}
+
+	return nil
 }

locale_test.go

@@ -1,3 +1,8 @@
+/*
+ * Copyright (c) 2018 DeineAgentur UG https://www.deineagentur.com. All rights reserved.
+ * Licensed under the MIT License. See LICENSE file in the project root for full license information.
+ */
+
 package gotext
 
 import (
@@ -9,8 +14,8 @@ import (
 func TestLocale(t *testing.T) {
 	// Set PO content
 	str := `
-# msgid ""
+msgid ""
-# msgstr ""
+msgstr ""
 # Initial comment
 # Headers below
 "Language: en\n"
@@ -38,8 +43,6 @@ msgstr[abc] "Wrong index"
 msgstr[1 "Forgot to close brackets"
 msgstr[0] "Badly formatted string'
 
-msgid "Invalid formatted id[] with no translations
-
 msgctxt "Ctx"
 msgid "One with var: %s"
 msgid_plural "Several with vars: %s"
@@ -47,14 +50,14 @@ msgstr[0] "This one is the singular in a Ctx context: %s"
 msgstr[1] "This one is the plural in a Ctx context: %s"
 
 msgid "Some random"
-msgstr "Some random translation"
+msgstr "Some random Translation"
 
 msgctxt "Ctx"
 msgid "Some random in a context"
-msgstr "Some random translation in a context"
+msgstr "Some random Translation in a context"
 
 msgid "More"
-msgstr "More translation"
+msgstr "More Translation"
 
 	`
 
@@ -83,7 +86,7 @@ msgstr "More translation"
 	l := NewLocale("/tmp", "en_US")
 
 	// Force nil domain storage
-	l.domains = nil
+	l.Domains = nil
 
 	// Add domain
 	l.AddDomain("my_domain")
@@ -107,7 +110,17 @@ msgstr "More translation"
 	}
 
 	// Test context translations
+	tr = l.GetC("Some random in a context", "Ctx")
+	if tr != "Some random Translation in a context" {
+		t.Errorf("Expected 'Some random Translation in a context'. Got '%s'", tr)
+	}
+
 	v = "Test"
+	tr = l.GetNC("One with var: %s", "Several with vars: %s", 23, "Ctx", v)
+	if tr != "This one is the plural in a Ctx context: Test" {
+		t.Errorf("Expected 'This one is the plural in a Ctx context: Test'. Got '%s'", tr)
+	}
+
 	tr = l.GetDC("my_domain", "One with var: %s", "Ctx", v)
 	if tr != "This one is the singular in a Ctx context: Test" {
 		t.Errorf("Expected 'This one is the singular in a Ctx context: Test' but got '%s'", tr)
@@ -119,10 +132,10 @@ msgstr "More translation"
 		t.Errorf("Expected 'This one is the plural in a Ctx context: Test' but got '%s'", tr)
 	}
 
-	// Test last translation
+	// Test last Translation
 	tr = l.GetD("my_domain", "More")
-	if tr != "More translation" {
+	if tr != "More Translation" {
-		t.Errorf("Expected 'More translation' but got '%s'", tr)
+		t.Errorf("Expected 'More Translation' but got '%s'", tr)
 	}
 }
 
@@ -167,14 +180,14 @@ msgstr[0] "This one is the singular in a Ctx context: %s"
 msgstr[1] "This one is the plural in a Ctx context: %s"
 
 msgid "Some random"
-msgstr "Some random translation"
+msgstr "Some random Translation"
 
 msgctxt "Ctx"
 msgid "Some random in a context"
-msgstr "Some random translation in a context"
+msgstr "Some random Translation in a context"
 
 msgid "More"
-msgstr "More translation"
+msgstr "More Translation"
 
 	`
 
@@ -203,13 +216,28 @@ msgstr "More translation"
 	l := NewLocale("/tmp", "en_US")
 
 	// Force nil domain storage
-	l.domains = nil
+	l.Domains = nil
 
 	// Add domain
 	l.AddDomain("my_domain")
 
-	// Test non-existent "deafult" domain responses
+	// Test non-existent "default" domain responses
-	tr := l.Get("My text")
+	tr := l.GetDomain()
+	if tr != "my_domain" {
+		t.Errorf("Expected 'my_domain' but got '%s'", tr)
+	}
+
+	// Set default domain to make it fail
+	l.SetDomain("default")
+
+	// Test non-existent "default" domain responses
+	tr = l.GetDomain()
+	if tr != "default" {
+		t.Errorf("Expected 'default' but got '%s'", tr)
+	}
+
+	// Test non-existent "default" domain responses
+	tr = l.Get("My text")
 	if tr != "My text" {
 		t.Errorf("Expected 'My text' but got '%s'", tr)
 	}
@@ -241,6 +269,116 @@ msgstr "More translation"
 	if tr != "This are tests" {
 		t.Errorf("Expected 'Plural index' but got '%s'", tr)
 	}
+
+	// Create Locale with full language code
+	l = NewLocale("/tmp", "golem")
+
+	// Force nil domain storage
+	l.Domains = nil
+
+	// Add domain
+	l.SetDomain("my_domain")
+
+	// Test non-existent "default" domain responses
+	tr = l.GetDomain()
+	if tr != "my_domain" {
+		t.Errorf("Expected 'my_domain' but got '%s'", tr)
+	}
+
+	// Test syntax error parsed translations
+	tr = l.Get("This one has invalid syntax translations")
+	if tr != "This one has invalid syntax translations" {
+		t.Errorf("Expected 'This one has invalid syntax translations' but got '%s'", tr)
+	}
+
+	tr = l.GetN("This one has invalid syntax translations", "This are tests", 1)
+	if tr != "This are tests" {
+		t.Errorf("Expected 'Plural index' but got '%s'", tr)
+	}
+
+	// Create Locale with full language code
+	l = NewLocale("fixtures/", "fr_FR")
+
+	// Force nil domain storage
+	l.Domains = nil
+
+	// Add domain
+	l.SetDomain("default")
+
+	// Test non-existent "default" domain responses
+	tr = l.GetDomain()
+	if tr != "default" {
+		t.Errorf("Expected 'my_domain' but got '%s'", tr)
+	}
+
+	// Test syntax error parsed translations
+	tr = l.Get("This one has invalid syntax translations")
+	if tr != "This one has invalid syntax translations" {
+		t.Errorf("Expected 'This one has invalid syntax translations' but got '%s'", tr)
+	}
+
+	tr = l.GetN("This one has invalid syntax translations", "This are tests", 1)
+	if tr != "This are tests" {
+		t.Errorf("Expected 'Plural index' but got '%s'", tr)
+	}
+
+	// Create Locale with full language code
+	l = NewLocale("fixtures/", "de_DE")
+
+	// Force nil domain storage
+	l.Domains = nil
+
+	// Add domain
+	l.SetDomain("default")
+
+	// Test non-existent "default" domain responses
+	tr = l.GetDomain()
+	if tr != "default" {
+		t.Errorf("Expected 'my_domain' but got '%s'", tr)
+	}
+
+	// Test syntax error parsed translations
+	tr = l.Get("This one has invalid syntax translations")
+	if tr != "This one has invalid syntax translations" {
+		t.Errorf("Expected 'This one has invalid syntax translations' but got '%s'", tr)
+	}
+
+	tr = l.GetN("This one has invalid syntax translations", "This are tests", 1)
+	if tr != "This are tests" {
+		t.Errorf("Expected 'Plural index' but got '%s'", tr)
+	}
+
+	// Create Locale with full language code
+	l = NewLocale("fixtures/", "de_AT")
+
+	// Force nil domain storage
+	l.Domains = nil
+
+	// Add domain
+	l.SetDomain("default")
+
+	// Test non-existent "default" domain responses
+	tr = l.GetDomain()
+	if tr != "default" {
+		t.Errorf("Expected 'my_domain' but got '%s'", tr)
+	}
+
+	// Test syntax error parsed translations
+	tr = l.Get("This one has invalid syntax translations")
+	if tr != "This one has invalid syntax translations" {
+		t.Errorf("Expected 'This one has invalid syntax translations' but got '%s'", tr)
+	}
+
+	// Test syntax error parsed translations
+	tr = l.GetNDC("mega", "This one has invalid syntax translations", "plural", 2, "ctx")
+	if tr != "plural" {
+		t.Errorf("Expected 'plural' but got '%s'", tr)
+	}
+
+	tr = l.GetN("This one has invalid syntax translations", "This are tests", 1)
+	if tr != "This are tests" {
+		t.Errorf("Expected 'Plural index' but got '%s'", tr)
+	}
 }
 
 func TestLocaleRace(t *testing.T) {
@@ -282,7 +420,7 @@ msgstr[2] "And this is the second plural form: %s"
 		t.Fatalf("Can't write to test file: %s", err.Error())
 	}
 
-	// Create Locale with full language code
+	// Create Locale
 	l := NewLocale("/tmp", "es")
 
 	// Init sync channels
@@ -308,3 +446,81 @@ msgstr[2] "And this is the second plural form: %s"
 	<-ac
 	<-rc
 }
+
+func TestAddTranslator(t *testing.T) {
+	// Create po object
+	po := new(Po)
+
+	// Parse file
+	po.ParseFile("fixtures/en_US/default.po")
+
+	// Create Locale
+	l := NewLocale("", "en")
+
+	// Add PO Translator to Locale object
+	l.AddTranslator("default", po)
+
+	// Test translations
+	tr := l.Get("My text")
+	if tr != "Translated text" {
+		t.Errorf("Expected 'Translated text' but got '%s'", tr)
+	}
+	// Test translations
+	tr = l.Get("language")
+	if tr != "en_US" {
+		t.Errorf("Expected 'en_US' but got '%s'", tr)
+	}
+}
+
+func TestArabicTranslation(t *testing.T) {
+	// Create Locale
+	l := NewLocale("fixtures/", "ar")
+
+	// Add domain
+	l.AddDomain("categories")
+
+	// Get translation
+	tr := l.GetD("categories", "Alcohol & Tobacco")
+	if tr != "الكحول والتبغ" {
+		t.Errorf("Expected to get 'الكحول والتبغ', but got '%s'", tr)
+	}
+}
+
+func TestLocaleBinaryEncoding(t *testing.T) {
+	// Create Locale
+	l := NewLocale("fixtures/", "en_US")
+	l.AddDomain("default")
+
+	buff, err := l.MarshalBinary()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	l2 := new(Locale)
+	err = l2.UnmarshalBinary(buff)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// Check object properties
+	if l.path != l2.path {
+		t.Fatalf("path doesn't match: '%s' vs '%s'", l.path, l2.path)
+	}
+	if l.lang != l2.lang {
+		t.Fatalf("lang doesn't match: '%s' vs '%s'", l.lang, l2.lang)
+	}
+	if l.defaultDomain != l2.defaultDomain {
+		t.Fatalf("defaultDomain doesn't match: '%s' vs '%s'", l.defaultDomain, l2.defaultDomain)
+	}
+
+	// Check translations
+	if l.Get("My text") != l2.Get("My text") {
+		t.Errorf("'%s' is different from '%s", l.Get("My text"), l2.Get("My text"))
+	}
+	if l.Get("More") != l2.Get("More") {
+		t.Errorf("'%s' is different from '%s", l.Get("More"), l2.Get("More"))
+	}
+	if l.GetN("One with var: %s", "Several with vars: %s", 3, "VALUE") != l2.GetN("One with var: %s", "Several with vars: %s", 3, "VALUE") {
+		t.Errorf("'%s' is different from '%s", l.GetN("One with var: %s", "Several with vars: %s", 3, "VALUE"), l2.GetN("One with var: %s", "Several with vars: %s", 3, "VALUE"))
+	}
+}

mo.go

@@ -0,0 +1,472 @@
+/*
+ * Copyright (c) 2018 DeineAgentur UG https://www.deineagentur.com. All rights reserved.
+ * Licensed under the MIT License. See LICENSE file in the project root for full license information.
+ */
+
+package gotext
+
+import (
+	"bufio"
+	"bytes"
+	"encoding/binary"
+	"encoding/gob"
+	"io/ioutil"
+	"net/textproto"
+	"os"
+	"strconv"
+	"strings"
+	"sync"
+
+	"github.com/leonelquinteros/gotext/plurals"
+)
+
+const (
+	// MoMagicLittleEndian encoding
+	MoMagicLittleEndian = 0x950412de
+	// MoMagicBigEndian encoding
+	MoMagicBigEndian = 0xde120495
+
+	// EotSeparator msgctxt and msgid separator
+	EotSeparator = "\x04"
+	// NulSeparator msgid and msgstr separator
+	NulSeparator = "\x00"
+)
+
+/*
+Mo parses the content of any MO file and provides all the Translation functions needed.
+It's the base object used by all package methods.
+And it's safe for concurrent use by multiple goroutines by using the sync package for locking.
+
+Example:
+
+	import (
+		"fmt"
+		"github.com/leonelquinteros/gotext"
+	)
+
+	func main() {
+		// Create po object
+		po := gotext.NewMoTranslator()
+
+		// Parse .po file
+		po.ParseFile("/path/to/po/file/translations.mo")
+
+		// Get Translation
+		fmt.Println(po.Get("Translate this"))
+	}
+
+*/
+type Mo struct {
+	// Headers storage
+	Headers textproto.MIMEHeader
+
+	// Language header
+	Language string
+
+	// Plural-Forms header
+	PluralForms string
+
+	// Parsed Plural-Forms header values
+	nplurals    int
+	plural      string
+	pluralforms plurals.Expression
+
+	// Storage
+	translations map[string]*Translation
+	contexts     map[string]map[string]*Translation
+
+	// Sync Mutex
+	sync.RWMutex
+
+	// Parsing buffers
+	trBuffer  *Translation
+	ctxBuffer string
+}
+
+// NewMoTranslator creates a new Mo object with the Translator interface
+func NewMoTranslator() Translator {
+	return new(Mo)
+}
+
+// ParseFile tries to read the file by its provided path (f) and parse its content as a .po file.
+func (mo *Mo) ParseFile(f string) {
+	// Check if file exists
+	info, err := os.Stat(f)
+	if err != nil {
+		return
+	}
+
+	// Check that isn't a directory
+	if info.IsDir() {
+		return
+	}
+
+	// Parse file content
+	data, err := ioutil.ReadFile(f)
+	if err != nil {
+		return
+	}
+
+	mo.Parse(data)
+}
+
+// Parse loads the translations specified in the provided string (str)
+func (mo *Mo) Parse(buf []byte) {
+	// Lock while parsing
+	mo.Lock()
+
+	// Init storage
+	if mo.translations == nil {
+		mo.translations = make(map[string]*Translation)
+		mo.contexts = make(map[string]map[string]*Translation)
+	}
+
+	r := bytes.NewReader(buf)
+
+	var magicNumber uint32
+	if err := binary.Read(r, binary.LittleEndian, &magicNumber); err != nil {
+		return
+		// return fmt.Errorf("gettext: %v", err)
+	}
+	var bo binary.ByteOrder
+	switch magicNumber {
+	case MoMagicLittleEndian:
+		bo = binary.LittleEndian
+	case MoMagicBigEndian:
+		bo = binary.BigEndian
+	default:
+		return
+		// return fmt.Errorf("gettext: %v", "invalid magic number")
+	}
+
+	var header struct {
+		MajorVersion uint16
+		MinorVersion uint16
+		MsgIDCount   uint32
+		MsgIDOffset  uint32
+		MsgStrOffset uint32
+		HashSize     uint32
+		HashOffset   uint32
+	}
+	if err := binary.Read(r, bo, &header); err != nil {
+		return
+		// return fmt.Errorf("gettext: %v", err)
+	}
+	if v := header.MajorVersion; v != 0 && v != 1 {
+		return
+		// return fmt.Errorf("gettext: %v", "invalid version number")
+	}
+	if v := header.MinorVersion; v != 0 && v != 1 {
+		return
+		// return fmt.Errorf("gettext: %v", "invalid version number")
+	}
+
+	msgIDStart := make([]uint32, header.MsgIDCount)
+	msgIDLen := make([]uint32, header.MsgIDCount)
+	if _, err := r.Seek(int64(header.MsgIDOffset), 0); err != nil {
+		return
+		// return fmt.Errorf("gettext: %v", err)
+	}
+	for i := 0; i < int(header.MsgIDCount); i++ {
+		if err := binary.Read(r, bo, &msgIDLen[i]); err != nil {
+			return
+			// return fmt.Errorf("gettext: %v", err)
+		}
+		if err := binary.Read(r, bo, &msgIDStart[i]); err != nil {
+			return
+			// return fmt.Errorf("gettext: %v", err)
+		}
+	}
+
+	msgStrStart := make([]int32, header.MsgIDCount)
+	msgStrLen := make([]int32, header.MsgIDCount)
+	if _, err := r.Seek(int64(header.MsgStrOffset), 0); err != nil {
+		return
+		// return fmt.Errorf("gettext: %v", err)
+	}
+	for i := 0; i < int(header.MsgIDCount); i++ {
+		if err := binary.Read(r, bo, &msgStrLen[i]); err != nil {
+			return
+			// return fmt.Errorf("gettext: %v", err)
+		}
+		if err := binary.Read(r, bo, &msgStrStart[i]); err != nil {
+			return
+			// return fmt.Errorf("gettext: %v", err)
+		}
+	}
+
+	for i := 0; i < int(header.MsgIDCount); i++ {
+		if _, err := r.Seek(int64(msgIDStart[i]), 0); err != nil {
+			return
+			// return fmt.Errorf("gettext: %v", err)
+		}
+		msgIDData := make([]byte, msgIDLen[i])
+		if _, err := r.Read(msgIDData); err != nil {
+			return
+			// return fmt.Errorf("gettext: %v", err)
+		}
+
+		if _, err := r.Seek(int64(msgStrStart[i]), 0); err != nil {
+			return
+			// return fmt.Errorf("gettext: %v", err)
+		}
+		msgStrData := make([]byte, msgStrLen[i])
+		if _, err := r.Read(msgStrData); err != nil {
+			return
+			// return fmt.Errorf("gettext: %v", err)
+		}
+
+		if len(msgIDData) == 0 {
+			mo.addTranslation(msgIDData, msgStrData)
+		} else {
+			mo.addTranslation(msgIDData, msgStrData)
+		}
+	}
+
+	// Unlock to parse headers
+	mo.Unlock()
+
+	// Parse headers
+	mo.parseHeaders()
+	return
+	// return nil
+}
+
+func (mo *Mo) addTranslation(msgid, msgstr []byte) {
+	translation := NewTranslation()
+	var msgctxt []byte
+	var msgidPlural []byte
+
+	d := bytes.Split(msgid, []byte(EotSeparator))
+	if len(d) == 1 {
+		msgid = d[0]
+	} else {
+		msgid, msgctxt = d[1], d[0]
+	}
+
+	dd := bytes.Split(msgid, []byte(NulSeparator))
+	if len(dd) > 1 {
+		msgid = dd[0]
+		dd = dd[1:]
+	}
+
+	translation.ID = string(msgid)
+
+	msgidPlural = bytes.Join(dd, []byte(NulSeparator))
+	if len(msgidPlural) > 0 {
+		translation.PluralID = string(msgidPlural)
+	}
+
+	ddd := bytes.Split(msgstr, []byte(NulSeparator))
+	if len(ddd) > 0 {
+		for i, s := range ddd {
+			translation.Trs[i] = string(s)
+		}
+	}
+
+	if len(msgctxt) > 0 {
+		// With context...
+		if _, ok := mo.contexts[string(msgctxt)]; !ok {
+			mo.contexts[string(msgctxt)] = make(map[string]*Translation)
+		}
+		mo.contexts[string(msgctxt)][translation.ID] = translation
+	} else {
+		mo.translations[translation.ID] = translation
+	}
+}
+
+// parseHeaders retrieves data from previously parsed headers
+func (mo *Mo) parseHeaders() {
+	// Make sure we end with 2 carriage returns.
+	raw := mo.Get("") + "\n\n"
+
+	// Read
+	reader := bufio.NewReader(strings.NewReader(raw))
+	tp := textproto.NewReader(reader)
+
+	var err error
+
+	// Sync Headers write.
+	mo.Lock()
+	defer mo.Unlock()
+
+	mo.Headers, err = tp.ReadMIMEHeader()
+	if err != nil {
+		return
+	}
+
+	// Get/save needed headers
+	mo.Language = mo.Headers.Get("Language")
+	mo.PluralForms = mo.Headers.Get("Plural-Forms")
+
+	// Parse Plural-Forms formula
+	if mo.PluralForms == "" {
+		return
+	}
+
+	// Split plural form header value
+	pfs := strings.Split(mo.PluralForms, ";")
+
+	// Parse values
+	for _, i := range pfs {
+		vs := strings.SplitN(i, "=", 2)
+		if len(vs) != 2 {
+			continue
+		}
+
+		switch strings.TrimSpace(vs[0]) {
+		case "nplurals":
+			mo.nplurals, _ = strconv.Atoi(vs[1])
+
+		case "plural":
+			mo.plural = vs[1]
+
+			if expr, err := plurals.Compile(mo.plural); err == nil {
+				mo.pluralforms = expr
+			}
+
+		}
+	}
+}
+
+// pluralForm calculates the plural form index corresponding to n.
+// Returns 0 on error
+func (mo *Mo) pluralForm(n int) int {
+	mo.RLock()
+	defer mo.RUnlock()
+
+	// Failure fallback
+	if mo.pluralforms == nil {
+		/* Use the Germanic plural rule.  */
+		if n == 1 {
+			return 0
+		}
+		return 1
+
+	}
+	return mo.pluralforms.Eval(uint32(n))
+}
+
+// Get retrieves the corresponding Translation for the given string.
+// Supports optional parameters (vars... interface{}) to be inserted on the formatted string using the fmt.Printf syntax.
+func (mo *Mo) Get(str string, vars ...interface{}) string {
+	// Sync read
+	mo.RLock()
+	defer mo.RUnlock()
+
+	if mo.translations != nil {
+		if _, ok := mo.translations[str]; ok {
+			return Printf(mo.translations[str].Get(), vars...)
+		}
+	}
+
+	// Return the same we received by default
+	return Printf(str, vars...)
+}
+
+// GetN retrieves the (N)th plural form of Translation for the given string.
+// Supports optional parameters (vars... interface{}) to be inserted on the formatted string using the fmt.Printf syntax.
+func (mo *Mo) GetN(str, plural string, n int, vars ...interface{}) string {
+	// Sync read
+	mo.RLock()
+	defer mo.RUnlock()
+
+	if mo.translations != nil {
+		if _, ok := mo.translations[str]; ok {
+			return Printf(mo.translations[str].GetN(mo.pluralForm(n)), vars...)
+		}
+	}
+
+	if n == 1 {
+		return Printf(str, vars...)
+	}
+	return Printf(plural, vars...)
+}
+
+// GetC retrieves the corresponding Translation for a given string in the given context.
+// Supports optional parameters (vars... interface{}) to be inserted on the formatted string using the fmt.Printf syntax.
+func (mo *Mo) GetC(str, ctx string, vars ...interface{}) string {
+	// Sync read
+	mo.RLock()
+	defer mo.RUnlock()
+
+	if mo.contexts != nil {
+		if _, ok := mo.contexts[ctx]; ok {
+			if mo.contexts[ctx] != nil {
+				if _, ok := mo.contexts[ctx][str]; ok {
+					return Printf(mo.contexts[ctx][str].Get(), vars...)
+				}
+			}
+		}
+	}
+
+	// Return the string we received by default
+	return Printf(str, vars...)
+}
+
+// GetNC retrieves the (N)th plural form of Translation for the given string in the given context.
+// Supports optional parameters (vars... interface{}) to be inserted on the formatted string using the fmt.Printf syntax.
+func (mo *Mo) GetNC(str, plural string, n int, ctx string, vars ...interface{}) string {
+	// Sync read
+	mo.RLock()
+	defer mo.RUnlock()
+
+	if mo.contexts != nil {
+		if _, ok := mo.contexts[ctx]; ok {
+			if mo.contexts[ctx] != nil {
+				if _, ok := mo.contexts[ctx][str]; ok {
+					return Printf(mo.contexts[ctx][str].GetN(mo.pluralForm(n)), vars...)
+				}
+			}
+		}
+	}
+
+	if n == 1 {
+		return Printf(str, vars...)
+	}
+	return Printf(plural, vars...)
+}
+
+// MarshalBinary implements encoding.BinaryMarshaler interface
+func (mo *Mo) MarshalBinary() ([]byte, error) {
+	obj := new(TranslatorEncoding)
+	obj.Headers = mo.Headers
+	obj.Language = mo.Language
+	obj.PluralForms = mo.PluralForms
+	obj.Nplurals = mo.nplurals
+	obj.Plural = mo.plural
+	obj.Translations = mo.translations
+	obj.Contexts = mo.contexts
+
+	var buff bytes.Buffer
+	encoder := gob.NewEncoder(&buff)
+	err := encoder.Encode(obj)
+
+	return buff.Bytes(), err
+}
+
+// UnmarshalBinary implements encoding.BinaryUnmarshaler interface
+func (mo *Mo) UnmarshalBinary(data []byte) error {
+	buff := bytes.NewBuffer(data)
+	obj := new(TranslatorEncoding)
+
+	decoder := gob.NewDecoder(buff)
+	err := decoder.Decode(obj)
+	if err != nil {
+		return err
+	}
+
+	mo.Headers = obj.Headers
+	mo.Language = obj.Language
+	mo.PluralForms = obj.PluralForms
+	mo.nplurals = obj.Nplurals
+	mo.plural = obj.Plural
+	mo.translations = obj.Translations
+	mo.contexts = obj.Contexts
+
+	if expr, err := plurals.Compile(mo.plural); err == nil {
+		mo.pluralforms = expr
+	}
+
+	return nil
+}

mo_test.go

@@ -0,0 +1,234 @@
+/*
+ * Copyright (c) 2018 DeineAgentur UG https://www.deineagentur.com. All rights reserved.
+ * Licensed under the MIT License. See LICENSE file in the project root for full license information.
+ */
+
+package gotext
+
+import (
+	"os"
+	"path"
+	"testing"
+)
+
+func TestMo_Get(t *testing.T) {
+
+	// Create po object
+	mo := new(Mo)
+
+	// Try to parse a directory
+	mo.ParseFile(path.Clean(os.TempDir()))
+
+	// Parse file
+	mo.ParseFile("fixtures/en_US/default.mo")
+
+	// Test translations
+	tr := mo.Get("My text")
+	if tr != "Translated text" {
+		t.Errorf("Expected 'Translated text' but got '%s'", tr)
+	}
+	// Test translations
+	tr = mo.Get("language")
+	if tr != "en_US" {
+		t.Errorf("Expected 'en_US' but got '%s'", tr)
+	}
+}
+
+func TestMo(t *testing.T) {
+
+	// Create po object
+	mo := new(Mo)
+
+	// Try to parse a directory
+	mo.ParseFile(path.Clean(os.TempDir()))
+
+	// Parse file
+	mo.ParseFile("fixtures/en_US/default.mo")
+
+	// Test translations
+	tr := mo.Get("My text")
+	if tr != "Translated text" {
+		t.Errorf("Expected 'Translated text' but got '%s'", tr)
+	}
+
+	v := "Variable"
+	tr = mo.Get("One with var: %s", v)
+	if tr != "This one is the singular: Variable" {
+		t.Errorf("Expected 'This one is the singular: Variable' but got '%s'", tr)
+	}
+
+	// Test multi-line id
+	tr = mo.Get("multilineid")
+	if tr != "id with multiline content" {
+		t.Errorf("Expected 'id with multiline content' but got '%s'", tr)
+	}
+
+	// Test multi-line plural id
+	tr = mo.Get("multilinepluralid")
+	if tr != "plural id with multiline content" {
+		t.Errorf("Expected 'plural id with multiline content' but got '%s'", tr)
+	}
+
+	// Test multi-line
+	tr = mo.Get("Multi-line")
+	if tr != "Multi line" {
+		t.Errorf("Expected 'Multi line' but got '%s'", tr)
+	}
+
+	// Test plural
+	tr = mo.GetN("One with var: %s", "Several with vars: %s", 2, v)
+	if tr != "This one is the plural: Variable" {
+		t.Errorf("Expected 'This one is the plural: Variable' but got '%s'", tr)
+	}
+
+	// Test not existent translations
+	tr = mo.Get("This is a test")
+	if tr != "This is a test" {
+		t.Errorf("Expected 'This is a test' but got '%s'", tr)
+	}
+
+	tr = mo.GetN("This is a test", "This are tests", 100)
+	if tr != "This are tests" {
+		t.Errorf("Expected 'This are tests' but got '%s'", tr)
+	}
+
+	// Test context translations
+	v = "Test"
+	tr = mo.GetC("One with var: %s", "Ctx", v)
+	if tr != "This one is the singular in a Ctx context: Test" {
+		t.Errorf("Expected 'This one is the singular in a Ctx context: Test' but got '%s'", tr)
+	}
+
+	// Test plural
+	tr = mo.GetNC("One with var: %s", "Several with vars: %s", 17, "Ctx", v)
+	if tr != "This one is the plural in a Ctx context: Test" {
+		t.Errorf("Expected 'This one is the plural in a Ctx context: Test' but got '%s'", tr)
+	}
+
+	// Test default plural vs singular return responses
+	tr = mo.GetN("Original", "Original plural", 4)
+	if tr != "Original plural" {
+		t.Errorf("Expected 'Original plural' but got '%s'", tr)
+	}
+	tr = mo.GetN("Original", "Original plural", 1)
+	if tr != "Original" {
+		t.Errorf("Expected 'Original' but got '%s'", tr)
+	}
+
+	// Test empty Translation strings
+	tr = mo.Get("Empty Translation")
+	if tr != "Empty Translation" {
+		t.Errorf("Expected 'Empty Translation' but got '%s'", tr)
+	}
+
+	tr = mo.Get("Empty plural form singular")
+	if tr != "Singular translated" {
+		t.Errorf("Expected 'Singular translated' but got '%s'", tr)
+	}
+
+	tr = mo.GetN("Empty plural form singular", "Empty plural form", 1)
+	if tr != "Singular translated" {
+		t.Errorf("Expected 'Singular translated' but got '%s'", tr)
+	}
+
+	tr = mo.GetN("Empty plural form singular", "Empty plural form", 2)
+	if tr != "Empty plural form" {
+		t.Errorf("Expected 'Empty plural form' but got '%s'", tr)
+	}
+
+	// Test last Translation
+	tr = mo.Get("More")
+	if tr != "More translation" {
+		t.Errorf("Expected 'More translation' but got '%s'", tr)
+	}
+}
+
+func TestMoRace(t *testing.T) {
+
+	// Create Po object
+	mo := new(Mo)
+
+	// Create sync channels
+	pc := make(chan bool)
+	rc := make(chan bool)
+
+	// Parse po content in a goroutine
+	go func(mo *Mo, done chan bool) {
+		// Parse file
+		mo.ParseFile("fixtures/en_US/default.mo")
+		done <- true
+	}(mo, pc)
+
+	// Read some Translation on a goroutine
+	go func(mo *Mo, done chan bool) {
+		mo.Get("My text")
+		done <- true
+	}(mo, rc)
+
+	// Read something at top level
+	mo.Get("My text")
+
+	// Wait for goroutines to finish
+	<-pc
+	<-rc
+}
+
+func TestNewMoTranslatorRace(t *testing.T) {
+
+	// Create Po object
+	mo := NewMoTranslator()
+
+	// Create sync channels
+	pc := make(chan bool)
+	rc := make(chan bool)
+
+	// Parse po content in a goroutine
+	go func(mo Translator, done chan bool) {
+		// Parse file
+		mo.ParseFile("fixtures/en_US/default.mo")
+		done <- true
+	}(mo, pc)
+
+	// Read some Translation on a goroutine
+	go func(mo Translator, done chan bool) {
+		mo.Get("My text")
+		done <- true
+	}(mo, rc)
+
+	// Read something at top level
+	mo.Get("My text")
+
+	// Wait for goroutines to finish
+	<-pc
+	<-rc
+}
+
+func TestMoBinaryEncoding(t *testing.T) {
+	// Create mo objects
+	mo := new(Mo)
+	mo2 := new(Mo)
+
+	// Parse file
+	mo.ParseFile("fixtures/en_US/default.mo")
+
+	buff, err := mo.MarshalBinary()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = mo2.UnmarshalBinary(buff)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// Test translations
+	tr := mo2.Get("My text")
+	if tr != "Translated text" {
+		t.Errorf("Expected 'Translated text' but got '%s'", tr)
+	}
+	// Test translations
+	tr = mo2.Get("language")
+	if tr != "en_US" {
+		t.Errorf("Expected 'en_US' but got '%s'", tr)
+	}
+}

plurals/compiler.go

@@ -0,0 +1,429 @@
+/*
+ * Copyright (c) 2018 DeineAgentur UG https://www.deineagentur.com. All rights reserved.
+ * Licensed under the MIT License. See LICENSE file in the project root for full license information.
+ */
+
+/*
+ Package plurals is the pluralform compiler to get the correct translation id of the plural string
+*/
+package plurals
+
+import (
+	"errors"
+	"fmt"
+	"regexp"
+	"strconv"
+	"strings"
+)
+
+type match struct {
+	openPos  int
+	closePos int
+}
+
+var pat = regexp.MustCompile(`(\?|:|\|\||&&|==|!=|>=|>|<=|<|%|\d+|n)`)
+
+type testToken interface {
+	compile(tokens []string) (test test, err error)
+}
+
+type cmpTestBuilder func(val uint32, flipped bool) test
+type logicTestBuild func(left test, right test) test
+
+var ternaryToken ternaryStruct
+
+type ternaryStruct struct{}
+
+func (ternaryStruct) compile(tokens []string) (expr Expression, err error) {
+	main, err := splitTokens(tokens, "?")
+	if err != nil {
+		return expr, err
+	}
+	test, err := compileTest(strings.Join(main.Left, ""))
+	if err != nil {
+		return expr, err
+	}
+	actions, err := splitTokens(main.Right, ":")
+	if err != nil {
+		return expr, err
+	}
+	trueAction, err := compileExpression(strings.Join(actions.Left, ""))
+	if err != nil {
+		return expr, err
+	}
+	falseAction, err := compileExpression(strings.Join(actions.Right, ""))
+	if err != nil {
+		return expr, nil
+	}
+	return ternary{
+		test:      test,
+		trueExpr:  trueAction,
+		falseExpr: falseAction,
+	}, nil
+}
+
+var constToken constValStruct
+
+type constValStruct struct{}
+
+func (constValStruct) compile(tokens []string) (expr Expression, err error) {
+	if len(tokens) == 0 {
+		return expr, errors.New("got nothing instead of constant")
+	}
+	if len(tokens) != 1 {
+		return expr, fmt.Errorf("invalid constant: %s", strings.Join(tokens, ""))
+	}
+	i, err := strconv.Atoi(tokens[0])
+	if err != nil {
+		return expr, err
+	}
+	return constValue{value: i}, nil
+}
+
+func compileLogicTest(tokens []string, sep string, builder logicTestBuild) (test test, err error) {
+	split, err := splitTokens(tokens, sep)
+	if err != nil {
+		return test, err
+	}
+	left, err := compileTest(strings.Join(split.Left, ""))
+	if err != nil {
+		return test, err
+	}
+	right, err := compileTest(strings.Join(split.Right, ""))
+	if err != nil {
+		return test, err
+	}
+	return builder(left, right), nil
+}
+
+var orToken orStruct
+
+type orStruct struct{}
+
+func (orStruct) compile(tokens []string) (test test, err error) {
+	return compileLogicTest(tokens, "||", buildOr)
+}
+func buildOr(left test, right test) test {
+	return or{left: left, right: right}
+}
+
+var andToken andStruct
+
+type andStruct struct{}
+
+func (andStruct) compile(tokens []string) (test test, err error) {
+	return compileLogicTest(tokens, "&&", buildAnd)
+}
+func buildAnd(left test, right test) test {
+	return and{left: left, right: right}
+}
+
+func compileMod(tokens []string) (math math, err error) {
+	split, err := splitTokens(tokens, "%")
+	if err != nil {
+		return math, err
+	}
+	if len(split.Left) != 1 || split.Left[0] != "n" {
+		return math, errors.New("Modulus operation requires 'n' as left operand")
+	}
+	if len(split.Right) != 1 {
+		return math, errors.New("Modulus operation requires simple integer as right operand")
+	}
+	i, err := parseUint32(split.Right[0])
+	if err != nil {
+		return math, err
+	}
+	return mod{value: uint32(i)}, nil
+}
+
+func subPipe(modTokens []string, actionTokens []string, builder cmpTestBuilder, flipped bool) (test test, err error) {
+	modifier, err := compileMod(modTokens)
+	if err != nil {
+		return test, err
+	}
+	if len(actionTokens) != 1 {
+		return test, errors.New("can only get modulus of integer")
+	}
+	i, err := parseUint32(actionTokens[0])
+	if err != nil {
+		return test, err
+	}
+	action := builder(uint32(i), flipped)
+	return pipe{
+		modifier: modifier,
+		action:   action,
+	}, nil
+}
+
+func compileEquality(tokens []string, sep string, builder cmpTestBuilder) (test test, err error) {
+	split, err := splitTokens(tokens, sep)
+	if err != nil {
+		return test, err
+	}
+	if len(split.Left) == 1 && split.Left[0] == "n" {
+		if len(split.Right) != 1 {
+			return test, errors.New("test can only compare n to integers")
+		}
+		i, err := parseUint32(split.Right[0])
+		if err != nil {
+			return test, err
+		}
+		return builder(i, false), nil
+	} else if len(split.Right) == 1 && split.Right[0] == "n" {
+		if len(split.Left) != 1 {
+			return test, errors.New("test can only compare n to integers")
+		}
+		i, err := parseUint32(split.Left[0])
+		if err != nil {
+			return test, err
+		}
+		return builder(i, true), nil
+	} else if contains(split.Left, "n") && contains(split.Left, "%") {
+		return subPipe(split.Left, split.Right, builder, false)
+	}
+	return test, errors.New("equality test must have 'n' as one of the two tests")
+
+}
+
+var eqToken eqStruct
+
+type eqStruct struct{}
+
+func (eqStruct) compile(tokens []string) (test test, err error) {
+	return compileEquality(tokens, "==", buildEq)
+}
+func buildEq(val uint32, flipped bool) test {
+	return equal{value: val}
+}
+
+var neqToken neqStruct
+
+type neqStruct struct{}
+
+func (neqStruct) compile(tokens []string) (test test, err error) {
+	return compileEquality(tokens, "!=", buildNeq)
+}
+func buildNeq(val uint32, flipped bool) test {
+	return notequal{value: val}
+}
+
+var gtToken gtStruct
+
+type gtStruct struct{}
+
+func (gtStruct) compile(tokens []string) (test test, err error) {
+	return compileEquality(tokens, ">", buildGt)
+}
+func buildGt(val uint32, flipped bool) test {
+	return gt{value: val, flipped: flipped}
+}
+
+var gteToken gteStruct
+
+type gteStruct struct{}
+
+func (gteStruct) compile(tokens []string) (test test, err error) {
+	return compileEquality(tokens, ">=", buildGte)
+}
+func buildGte(val uint32, flipped bool) test {
+	return gte{value: val, flipped: flipped}
+}
+
+var ltToken ltStruct
+
+type ltStruct struct{}
+
+func (ltStruct) compile(tokens []string) (test test, err error) {
+	return compileEquality(tokens, "<", buildLt)
+}
+func buildLt(val uint32, flipped bool) test {
+	return lt{value: val, flipped: flipped}
+}
+
+var lteToken lteStruct
+
+type lteStruct struct{}
+
+func (lteStruct) compile(tokens []string) (test test, err error) {
+	return compileEquality(tokens, "<=", buildLte)
+}
+func buildLte(val uint32, flipped bool) test {
+	return lte{value: val, flipped: flipped}
+}
+
+type testTokenDef struct {
+	op    string
+	token testToken
+}
+
+var precedence = []testTokenDef{
+	{op: "||", token: orToken},
+	{op: "&&", token: andToken},
+	{op: "==", token: eqToken},
+	{op: "!=", token: neqToken},
+	{op: ">=", token: gteToken},
+	{op: ">", token: gtToken},
+	{op: "<=", token: lteToken},
+	{op: "<", token: ltToken},
+}
+
+type splitted struct {
+	Left  []string
+	Right []string
+}
+
+// Find index of token in list of tokens
+func index(tokens []string, sep string) int {
+	for index, token := range tokens {
+		if token == sep {
+			return index
+		}
+	}
+	return -1
+}
+
+// Split a list of tokens by a token into a splitted struct holding the tokens
+// before and after the token to be split by.
+func splitTokens(tokens []string, sep string) (s splitted, err error) {
+	index := index(tokens, sep)
+	if index == -1 {
+		return s, fmt.Errorf("'%s' not found in ['%s']", sep, strings.Join(tokens, "','"))
+	}
+	return splitted{
+		Left:  tokens[:index],
+		Right: tokens[index+1:],
+	}, nil
+}
+
+// Scan a string for parenthesis
+func scan(s string) <-chan match {
+	ch := make(chan match)
+	go func() {
+		depth := 0
+		opener := 0
+		for index, char := range s {
+			switch char {
+			case '(':
+				if depth == 0 {
+					opener = index
+				}
+				depth++
+			case ')':
+				depth--
+				if depth == 0 {
+					ch <- match{
+						openPos:  opener,
+						closePos: index + 1,
+					}
+				}
+			}
+
+		}
+		close(ch)
+	}()
+	return ch
+}
+
+// Split the string into tokens
+func split(s string) <-chan string {
+	ch := make(chan string)
+	go func() {
+		s = strings.Replace(s, " ", "", -1)
+		if !strings.Contains(s, "(") {
+			ch <- s
+		} else {
+			last := 0
+			end := len(s)
+			for info := range scan(s) {
+				if last != info.openPos {
+					ch <- s[last:info.openPos]
+				}
+				ch <- s[info.openPos:info.closePos]
+				last = info.closePos
+			}
+			if last != end {
+				ch <- s[last:]
+			}
+		}
+		close(ch)
+	}()
+	return ch
+}
+
+// Tokenizes a string into a list of strings, tokens grouped by parenthesis are
+// not split! If the string starts with ( and ends in ), those are stripped.
+func tokenize(s string) []string {
+	/*
+		TODO: Properly detect if the string starts with a ( and ends with a )
+		and that those two form a matching pair.
+
+		Eg: (foo) -> true; (foo)(bar) -> false;
+	*/
+	if s[0] == '(' && s[len(s)-1] == ')' {
+		s = s[1 : len(s)-1]
+	}
+	ret := []string{}
+	for chunk := range split(s) {
+		if len(chunk) != 0 {
+			if chunk[0] == '(' && chunk[len(chunk)-1] == ')' {
+				ret = append(ret, chunk)
+			} else {
+				for _, token := range pat.FindAllStringSubmatch(chunk, -1) {
+					ret = append(ret, token[0])
+				}
+			}
+		} else {
+			fmt.Printf("Empty chunk in string '%s'\n", s)
+		}
+	}
+	return ret
+}
+
+// Compile a string containing a plural form expression to a Expression object.
+func Compile(s string) (expr Expression, err error) {
+	if s == "0" {
+		return constValue{value: 0}, nil
+	}
+	if !strings.Contains(s, "?") {
+		s += "?1:0"
+	}
+	return compileExpression(s)
+}
+
+// Check if a token is in a slice of strings
+func contains(haystack []string, needle string) bool {
+	for _, s := range haystack {
+		if s == needle {
+			return true
+		}
+	}
+	return false
+}
+
+// Compiles an expression (ternary or constant)
+func compileExpression(s string) (expr Expression, err error) {
+	tokens := tokenize(s)
+	if contains(tokens, "?") {
+		return ternaryToken.compile(tokens)
+	}
+	return constToken.compile(tokens)
+}
+
+// Compiles a test (comparison)
+func compileTest(s string) (test test, err error) {
+	tokens := tokenize(s)
+	for _, tokenDef := range precedence {
+		if contains(tokens, tokenDef.op) {
+			return tokenDef.token.compile(tokens)
+		}
+	}
+	return test, errors.New("cannot compile")
+}
+
+func parseUint32(s string) (ui uint32, err error) {
+	i, err := strconv.ParseUint(s, 10, 32)
+	if err != nil {
+		return ui, err
+	}
+	return uint32(i), nil
+}

plurals/compiler_test.go

@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2018 DeineAgentur UG https://www.deineagentur.com. All rights reserved.
+ * Licensed under the MIT License. See LICENSE file in the project root for full license information.
+ */
+
+package plurals
+
+import (
+	"encoding/json"
+	"os"
+	"testing"
+)
+
+type fixture struct {
+	PluralForm string
+	Fixture    []int
+}
+
+func TestCompiler(t *testing.T) {
+	f, err := os.Open("testdata/pluralforms.json")
+	if err != nil {
+		t.Fatal(err)
+	}
+	dec := json.NewDecoder(f)
+	var fixtures []fixture
+	err = dec.Decode(&fixtures)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, data := range fixtures {
+		expr, err := Compile(data.PluralForm)
+		if err != nil {
+			t.Errorf("'%s' triggered error: %s", data.PluralForm, err)
+		} else if expr == nil {
+			t.Logf("'%s' compiled to nil", data.PluralForm)
+			t.Fail()
+		} else {
+			for n, e := range data.Fixture {
+				i := expr.Eval(uint32(n))
+				if i != e {
+					t.Logf("'%s' with n = %d, expected %d, got %d, compiled to %s", data.PluralForm, n, e, i, expr)
+					t.Fail()
+				}
+				if i == -1 {
+					break
+				}
+			}
+		}
+	}
+}

plurals/expression.go

@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2018 DeineAgentur UG https://www.deineagentur.com. All rights reserved.
+ * Licensed under the MIT License. See LICENSE file in the project root for full license information.
+ */
+
+package plurals
+
+// Expression is a plurals expression. Eval evaluates the expression for
+// a given n value. Use plurals.Compile to generate Expression instances.
+type Expression interface {
+	Eval(n uint32) int
+}
+
+type constValue struct {
+	value int
+}
+
+func (c constValue) Eval(n uint32) int {
+	return c.value
+}
+
+type test interface {
+	test(n uint32) bool
+}
+
+type ternary struct {
+	test      test
+	trueExpr  Expression
+	falseExpr Expression
+}
+
+func (t ternary) Eval(n uint32) int {
+	if t.test.test(n) {
+		if t.trueExpr == nil {
+			return -1
+		}
+		return t.trueExpr.Eval(n)
+	}
+	if t.falseExpr == nil {
+		return -1
+	}
+	return t.falseExpr.Eval(n)
+}

plurals/math.go

@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2018 DeineAgentur UG https://www.deineagentur.com. All rights reserved.
+ * Licensed under the MIT License. See LICENSE file in the project root for full license information.
+ */
+
+package plurals
+
+type math interface {
+	calc(n uint32) uint32
+}
+
+type mod struct {
+	value uint32
+}
+
+func (m mod) calc(n uint32) uint32 {
+	return n % m.value
+}

plurals/tests.go

@@ -0,0 +1,104 @@
+/*
+ * Copyright (c) 2018 DeineAgentur UG https://www.deineagentur.com. All rights reserved.
+ * Licensed under the MIT License. See LICENSE file in the project root for full license information.
+ */
+
+package plurals
+
+type equal struct {
+	value uint32
+}
+
+func (e equal) test(n uint32) bool {
+	return n == e.value
+}
+
+type notequal struct {
+	value uint32
+}
+
+func (e notequal) test(n uint32) bool {
+	return n != e.value
+}
+
+type gt struct {
+	value   uint32
+	flipped bool
+}
+
+func (e gt) test(n uint32) bool {
+	if e.flipped {
+		return e.value > n
+	} else {
+		return n > e.value
+	}
+}
+
+type lt struct {
+	value   uint32
+	flipped bool
+}
+
+func (e lt) test(n uint32) bool {
+	if e.flipped {
+		return e.value < n
+	}
+	return n < e.value
+}
+
+type gte struct {
+	value   uint32
+	flipped bool
+}
+
+func (e gte) test(n uint32) bool {
+	if e.flipped {
+		return e.value >= n
+	}
+	return n >= e.value
+}
+
+type lte struct {
+	value   uint32
+	flipped bool
+}
+
+func (e lte) test(n uint32) bool {
+	if e.flipped {
+		return e.value <= n
+	}
+	return n <= e.value
+}
+
+type and struct {
+	left  test
+	right test
+}
+
+func (e and) test(n uint32) bool {
+	if !e.left.test(n) {
+		return false
+	}
+	return e.right.test(n)
+}
+
+type or struct {
+	left  test
+	right test
+}
+
+func (e or) test(n uint32) bool {
+	if e.left.test(n) {
+		return true
+	}
+	return e.right.test(n)
+}
+
+type pipe struct {
+	modifier math
+	action   test
+}
+
+func (e pipe) test(n uint32) bool {
+	return e.action.test(e.modifier.calc(n))
+}

po.go

@@ -1,61 +1,26 @@
+/*
+ * Copyright (c) 2018 DeineAgentur UG https://www.deineagentur.com. All rights reserved.
+ * Licensed under the MIT License. See LICENSE file in the project root for full license information.
+ */
+
 package gotext
 
 import (
 	"bufio"
-	"fmt"
+	"bytes"
-	"github.com/mattn/kinako/vm"
+	"encoding/gob"
 	"io/ioutil"
 	"net/textproto"
 	"os"
 	"strconv"
 	"strings"
 	"sync"
+
+	"github.com/leonelquinteros/gotext/plurals"
 )
 
-type translation struct {
-	id       string
-	pluralID string
-	trs      map[int]string
-}
-
-func newTranslation() *translation {
-	tr := new(translation)
-	tr.trs = make(map[int]string)
-
-	return tr
-}
-
-func (t *translation) get() string {
-	// Look for translation index 0
-	if _, ok := t.trs[0]; ok {
-		if t.trs[0] != "" {
-			return t.trs[0]
-		}
-	}
-
-	// Return unstranlated id by default
-	return t.id
-}
-
-func (t *translation) getN(n int) string {
-	// Look for translation index
-	if _, ok := t.trs[n]; ok {
-		if t.trs[n] != "" {
-			return t.trs[n]
-		}
-	}
-
-	// Return unstranlated singular if corresponding
-	if n == 0 {
-		return t.id
-	}
-
-	// Return untranslated plural by default
-	return t.pluralID
-}
-
 /*
-Po parses the content of any PO file and provides all the translation functions needed.
+Po parses the content of any PO file and provides all the Translation functions needed.
 It's the base object used by all package methods.
 And it's safe for concurrent use by multiple goroutines by using the sync package for locking.
 
@@ -68,19 +33,19 @@ Example:
 
 	func main() {
 		// Create po object
-		po := new(gotext.Po)
+		po := gotext.NewPoTranslator()
 
 		// Parse .po file
 		po.ParseFile("/path/to/po/file/translations.po")
 
-		// Get translation
+		// Get Translation
 		fmt.Println(po.Get("Translate this"))
 	}
 
 */
 type Po struct {
-	// Headers
+	// Headers storage
-	RawHeaders string
+	Headers textproto.MIMEHeader
 
 	// Language header
 	Language string
@@ -89,18 +54,19 @@ type Po struct {
 	PluralForms string
 
 	// Parsed Plural-Forms header values
-	nplurals int
+	nplurals    int
-	plural   string
+	plural      string
+	pluralforms plurals.Expression
 
 	// Storage
-	translations map[string]*translation
+	translations map[string]*Translation
-	contexts     map[string]map[string]*translation
+	contexts     map[string]map[string]*Translation
 
 	// Sync Mutex
 	sync.RWMutex
 
 	// Parsing buffers
-	trBuffer  *translation
+	trBuffer  *Translation
 	ctxBuffer string
 }
 
@@ -114,6 +80,11 @@ const (
 	msgStr
 )
 
+// NewPoTranslator creates a new Po object with the Translator interface
+func NewPoTranslator() Translator {
+	return new(Po)
+}
+
 // ParseFile tries to read the file by its provided path (f) and parse its content as a .po file.
 func (po *Po) ParseFile(f string) {
 	// Check if file exists
@@ -133,26 +104,25 @@ func (po *Po) ParseFile(f string) {
 		return
 	}
 
-	po.Parse(string(data))
+	po.Parse(data)
 }
 
 // Parse loads the translations specified in the provided string (str)
-func (po *Po) Parse(str string) {
+func (po *Po) Parse(buf []byte) {
 	// Lock while parsing
 	po.Lock()
-	defer po.Unlock()
 
 	// Init storage
 	if po.translations == nil {
-		po.translations = make(map[string]*translation)
+		po.translations = make(map[string]*Translation)
-		po.contexts = make(map[string]map[string]*translation)
+		po.contexts = make(map[string]map[string]*Translation)
 	}
 
 	// Get lines
-	lines := strings.Split(str, "\n")
+	lines := strings.Split(string(buf), "\n")
 
 	// Init buffer
-	po.trBuffer = newTranslation()
+	po.trBuffer = NewTranslation()
 	po.ctxBuffer = ""
 
 	state := head
@@ -186,7 +156,7 @@ func (po *Po) Parse(str string) {
 			continue
 		}
 
-		// Save translation
+		// Save Translation
 		if strings.HasPrefix(l, "msgstr") {
 			po.parseMessage(l)
 			state = msgStr
@@ -195,44 +165,48 @@ func (po *Po) Parse(str string) {
 
 		// Multi line strings and headers
 		if strings.HasPrefix(l, "\"") && strings.HasSuffix(l, "\"") {
-			state = po.parseString(l, state)
+			po.parseString(l, state)
 			continue
 		}
 	}
 
-	// Save last translation buffer.
+	// Save last Translation buffer.
 	po.saveBuffer()
 
+	// Unlock to parse headers
+	po.Unlock()
+
 	// Parse headers
 	po.parseHeaders()
 }
 
-// saveBuffer takes the context and translation buffers
+// saveBuffer takes the context and Translation buffers
 // and saves it on the translations collection
 func (po *Po) saveBuffer() {
-	// If we have something to save...
+	// With no context...
-	if po.trBuffer.id != "" {
+	if po.ctxBuffer == "" {
-		// With no context...
+		po.translations[po.trBuffer.ID] = po.trBuffer
-		if po.ctxBuffer == "" {
+	} else {
-			po.translations[po.trBuffer.id] = po.trBuffer
+		// With context...
-		} else {
+		if _, ok := po.contexts[po.ctxBuffer]; !ok {
-			// With context...
+			po.contexts[po.ctxBuffer] = make(map[string]*Translation)
-			if _, ok := po.contexts[po.ctxBuffer]; !ok {
-				po.contexts[po.ctxBuffer] = make(map[string]*translation)
-			}
-			po.contexts[po.ctxBuffer][po.trBuffer.id] = po.trBuffer
 		}
+		po.contexts[po.ctxBuffer][po.trBuffer.ID] = po.trBuffer
 
-		// Flush buffer
+		// Cleanup current context buffer if needed
-		po.trBuffer = newTranslation()
+		if po.trBuffer.ID != "" {
-		po.ctxBuffer = ""
+			po.ctxBuffer = ""
+		}
 	}
+
+	// Flush Translation buffer
+	po.trBuffer = NewTranslation()
 }
 
 // parseContext takes a line starting with "msgctxt",
-// saves the current translation buffer and creates a new context.
+// saves the current Translation buffer and creates a new context.
 func (po *Po) parseContext(l string) {
-	// Save current translation buffer.
+	// Save current Translation buffer.
 	po.saveBuffer()
 
 	// Buffer context
@@ -240,25 +214,25 @@ func (po *Po) parseContext(l string) {
 }
 
 // parseID takes a line starting with "msgid",
-// saves the current translation and creates a new msgid buffer.
+// saves the current Translation and creates a new msgid buffer.
 func (po *Po) parseID(l string) {
-	// Save current translation buffer.
+	// Save current Translation buffer.
 	po.saveBuffer()
 
 	// Set id
-	po.trBuffer.id, _ = strconv.Unquote(strings.TrimSpace(strings.TrimPrefix(l, "msgid")))
+	po.trBuffer.ID, _ = strconv.Unquote(strings.TrimSpace(strings.TrimPrefix(l, "msgid")))
 }
 
 // parsePluralID saves the plural id buffer from a line starting with "msgid_plural"
 func (po *Po) parsePluralID(l string) {
-	po.trBuffer.pluralID, _ = strconv.Unquote(strings.TrimSpace(strings.TrimPrefix(l, "msgid_plural")))
+	po.trBuffer.PluralID, _ = strconv.Unquote(strings.TrimSpace(strings.TrimPrefix(l, "msgid_plural")))
 }
 
 // parseMessage takes a line starting with "msgstr" and saves it into the current buffer.
 func (po *Po) parseMessage(l string) {
 	l = strings.TrimSpace(strings.TrimPrefix(l, "msgstr"))
 
-	// Check for indexed translation forms
+	// Check for indexed Translation forms
 	if strings.HasPrefix(l, "[") {
 		idx := strings.Index(l, "]")
 		if idx == -1 {
@@ -273,83 +247,85 @@ func (po *Po) parseMessage(l string) {
 			return
 		}
 
-		// Parse translation string
+		// Parse Translation string
-		po.trBuffer.trs[i], _ = strconv.Unquote(strings.TrimSpace(l[idx+1:]))
+		po.trBuffer.Trs[i], _ = strconv.Unquote(strings.TrimSpace(l[idx+1:]))
 
 		// Loop
 		return
 	}
 
-	// Save single translation form under 0 index
+	// Save single Translation form under 0 index
-	po.trBuffer.trs[0], _ = strconv.Unquote(l)
+	po.trBuffer.Trs[0], _ = strconv.Unquote(l)
 }
 
 // parseString takes a well formatted string without prefix
 // and creates headers or attach multi-line strings when corresponding
-func (po *Po) parseString(l string, state parseState) parseState {
+func (po *Po) parseString(l string, state parseState) {
+	clean, _ := strconv.Unquote(l)
+
 	switch state {
 	case msgStr:
-		// Check for multiline from previously set msgid
+		// Append to last Translation found
-		if po.trBuffer.id != "" {
+		po.trBuffer.Trs[len(po.trBuffer.Trs)-1] += clean
-			// Append to last translation found
-			uq, _ := strconv.Unquote(l)
-			po.trBuffer.trs[len(po.trBuffer.trs)-1] += uq
 
-		}
 	case msgID:
 		// Multiline msgid - Append to current id
-		uq, _ := strconv.Unquote(l)
+		po.trBuffer.ID += clean
-		po.trBuffer.id += uq
+
 	case msgIDPlural:
 		// Multiline msgid - Append to current id
-		uq, _ := strconv.Unquote(l)
+		po.trBuffer.PluralID += clean
-		po.trBuffer.pluralID += uq
+
 	case msgCtxt:
 		// Multiline context - Append to current context
-		ctxt, _ := strconv.Unquote(l)
+		po.ctxBuffer += clean
-		po.ctxBuffer += ctxt
-	default:
-		// Otherwise is a header
-		h, _ := strconv.Unquote(strings.TrimSpace(l))
-		po.RawHeaders += h
-		return head
-	}
 
-	return state
+	}
 }
 
 // isValidLine checks for line prefixes to detect valid syntax.
 func (po *Po) isValidLine(l string) bool {
-	// Skip empty lines
-	if l == "" {
-		return false
-	}
-
 	// Check prefix
-	if !strings.HasPrefix(l, "\"") && !strings.HasPrefix(l, "msgctxt") && !strings.HasPrefix(l, "msgid") && !strings.HasPrefix(l, "msgid_plural") && !strings.HasPrefix(l, "msgstr") {
+	valid := []string{
-		return false
+		"\"",
+		"msgctxt",
+		"msgid",
+		"msgid_plural",
+		"msgstr",
 	}
 
-	return true
+	for _, v := range valid {
+		if strings.HasPrefix(l, v) {
+			return true
+		}
+	}
+
+	return false
 }
 
 // parseHeaders retrieves data from previously parsed headers
 func (po *Po) parseHeaders() {
 	// Make sure we end with 2 carriage returns.
-	po.RawHeaders += "\n\n"
+	raw := po.Get("") + "\n\n"
 
 	// Read
-	reader := bufio.NewReader(strings.NewReader(po.RawHeaders))
+	reader := bufio.NewReader(strings.NewReader(raw))
 	tp := textproto.NewReader(reader)
 
-	mimeHeader, err := tp.ReadMIMEHeader()
+	var err error
+
+	// Sync Headers write.
+	po.Lock()
+	defer po.Unlock()
+
+	po.Headers, err = tp.ReadMIMEHeader()
 	if err != nil {
 		return
 	}
 
 	// Get/save needed headers
-	po.Language = mimeHeader.Get("Language")
+	po.Language = po.Headers.Get("Language")
-	po.PluralForms = mimeHeader.Get("Plural-Forms")
+	po.PluralForms = po.Headers.Get("Plural-Forms")
 
 	// Parse Plural-Forms formula
 	if po.PluralForms == "" {
@@ -372,6 +348,11 @@ func (po *Po) parseHeaders() {
 
 		case "plural":
 			po.plural = vs[1]
+
+			if expr, err := plurals.Compile(po.plural); err == nil {
+				po.pluralforms = expr
+			}
+
 		}
 	}
 }
@@ -382,38 +363,18 @@ func (po *Po) pluralForm(n int) int {
 	po.RLock()
 	defer po.RUnlock()
 
-	// Failsafe
+	// Failure fallback
-	if po.nplurals < 1 {
+	if po.pluralforms == nil {
-		return 0
+		/* Use the Germanic plural rule.  */
-	}
+		if n == 1 {
-	if po.plural == "" {
+			return 0
-		return 0
-	}
-
-	// Init compiler
-	env := vm.NewEnv()
-	env.Define("n", n)
-
-	plural, err := env.Execute(po.plural)
-	if err != nil {
-		return 0
-	}
-	if plural.Type().Name() == "bool" {
-		if plural.Bool() {
-			return 1
 		}
-		// Else
+		return 1
-		return 0
 	}
-
+	return po.pluralforms.Eval(uint32(n))
-	if int(plural.Int()) > po.nplurals {
-		return 0
-	}
-
-	return int(plural.Int())
 }
 
-// Get retrieves the corresponding translation for the given string.
+// Get retrieves the corresponding Translation for the given string.
 // Supports optional parameters (vars... interface{}) to be inserted on the formatted string using the fmt.Printf syntax.
 func (po *Po) Get(str string, vars ...interface{}) string {
 	// Sync read
@@ -422,15 +383,15 @@ func (po *Po) Get(str string, vars ...interface{}) string {
 
 	if po.translations != nil {
 		if _, ok := po.translations[str]; ok {
-			return fmt.Sprintf(po.translations[str].get(), vars...)
+			return Printf(po.translations[str].Get(), vars...)
 		}
 	}
 
 	// Return the same we received by default
-	return fmt.Sprintf(str, vars...)
+	return Printf(str, vars...)
 }
 
-// GetN retrieves the (N)th plural form of translation for the given string.
+// GetN retrieves the (N)th plural form of Translation for the given string.
 // Supports optional parameters (vars... interface{}) to be inserted on the formatted string using the fmt.Printf syntax.
 func (po *Po) GetN(str, plural string, n int, vars ...interface{}) string {
 	// Sync read
@@ -439,18 +400,17 @@ func (po *Po) GetN(str, plural string, n int, vars ...interface{}) string {
 
 	if po.translations != nil {
 		if _, ok := po.translations[str]; ok {
-			return fmt.Sprintf(po.translations[str].getN(po.pluralForm(n)), vars...)
+			return Printf(po.translations[str].GetN(po.pluralForm(n)), vars...)
 		}
 	}
 
 	if n == 1 {
-		return fmt.Sprintf(str, vars...)
+		return Printf(str, vars...)
 	}
-
+	return Printf(plural, vars...)
-	return fmt.Sprintf(plural, vars...)
 }
 
-// GetC retrieves the corresponding translation for a given string in the given context.
+// GetC retrieves the corresponding Translation for a given string in the given context.
 // Supports optional parameters (vars... interface{}) to be inserted on the formatted string using the fmt.Printf syntax.
 func (po *Po) GetC(str, ctx string, vars ...interface{}) string {
 	// Sync read
@@ -461,17 +421,17 @@ func (po *Po) GetC(str, ctx string, vars ...interface{}) string {
 		if _, ok := po.contexts[ctx]; ok {
 			if po.contexts[ctx] != nil {
 				if _, ok := po.contexts[ctx][str]; ok {
-					return fmt.Sprintf(po.contexts[ctx][str].get(), vars...)
+					return Printf(po.contexts[ctx][str].Get(), vars...)
 				}
 			}
 		}
 	}
 
 	// Return the string we received by default
-	return fmt.Sprintf(str, vars...)
+	return Printf(str, vars...)
 }
 
-// GetNC retrieves the (N)th plural form of translation for the given string in the given context.
+// GetNC retrieves the (N)th plural form of Translation for the given string in the given context.
 // Supports optional parameters (vars... interface{}) to be inserted on the formatted string using the fmt.Printf syntax.
 func (po *Po) GetNC(str, plural string, n int, ctx string, vars ...interface{}) string {
 	// Sync read
@@ -482,14 +442,58 @@ func (po *Po) GetNC(str, plural string, n int, ctx string, vars ...interface{})
 		if _, ok := po.contexts[ctx]; ok {
 			if po.contexts[ctx] != nil {
 				if _, ok := po.contexts[ctx][str]; ok {
-					return fmt.Sprintf(po.contexts[ctx][str].getN(po.pluralForm(n)), vars...)
+					return Printf(po.contexts[ctx][str].GetN(po.pluralForm(n)), vars...)
 				}
 			}
 		}
 	}
 
 	if n == 1 {
-		return fmt.Sprintf(str, vars...)
+		return Printf(str, vars...)
 	}
-	return fmt.Sprintf(plural, vars...)
+	return Printf(plural, vars...)
+}
+
+// MarshalBinary implements encoding.BinaryMarshaler interface
+func (po *Po) MarshalBinary() ([]byte, error) {
+	obj := new(TranslatorEncoding)
+	obj.Headers = po.Headers
+	obj.Language = po.Language
+	obj.PluralForms = po.PluralForms
+	obj.Nplurals = po.nplurals
+	obj.Plural = po.plural
+	obj.Translations = po.translations
+	obj.Contexts = po.contexts
+
+	var buff bytes.Buffer
+	encoder := gob.NewEncoder(&buff)
+	err := encoder.Encode(obj)
+
+	return buff.Bytes(), err
+}
+
+// UnmarshalBinary implements encoding.BinaryUnmarshaler interface
+func (po *Po) UnmarshalBinary(data []byte) error {
+	buff := bytes.NewBuffer(data)
+	obj := new(TranslatorEncoding)
+
+	decoder := gob.NewDecoder(buff)
+	err := decoder.Decode(obj)
+	if err != nil {
+		return err
+	}
+
+	po.Headers = obj.Headers
+	po.Language = obj.Language
+	po.PluralForms = obj.PluralForms
+	po.nplurals = obj.Nplurals
+	po.plural = obj.Plural
+	po.translations = obj.Translations
+	po.contexts = obj.Contexts
+
+	if expr, err := plurals.Compile(po.plural); err == nil {
+		po.pluralforms = expr
+	}
+
+	return nil
 }

po_test.go

@@ -1,3 +1,8 @@
+/*
+ * Copyright (c) 2018 DeineAgentur UG https://www.deineagentur.com. All rights reserved.
+ * Licensed under the MIT License. See LICENSE file in the project root for full license information.
+ */
+
 package gotext
 
 import (
@@ -6,9 +11,34 @@ import (
 	"testing"
 )
 
+func TestPo_Get(t *testing.T) {
+	// Create po object
+	po := new(Po)
+
+	// Try to parse a directory
+	po.ParseFile(path.Clean(os.TempDir()))
+
+	// Parse file
+	po.ParseFile("fixtures/en_US/default.po")
+
+	// Test translations
+	tr := po.Get("My text")
+	if tr != "Translated text" {
+		t.Errorf("Expected 'Translated text' but got '%s'", tr)
+	}
+	// Test translations
+	tr = po.Get("language")
+	if tr != "en_US" {
+		t.Errorf("Expected 'en_US' but got '%s'", tr)
+	}
+}
+
 func TestPo(t *testing.T) {
 	// Set PO content
 	str := `
+msgid   ""
+msgstr  ""
+
 # Initial comment
 # Headers below
 "Language: en\n"
@@ -25,13 +55,15 @@ msgid "Another string"
 msgstr ""
 
 # Multi-line msgid
-msgid "multi"
+msgid ""
+"multi"
 "line"
 "id"
 msgstr "id with multiline content"
 
 # Multi-line msgid_plural
-msgid "multi"
+msgid "" 
+"multi"
 "line"
 "plural"
 "id"
@@ -39,7 +71,8 @@ msgstr "plural id with multiline content"
 
 #Multi-line string
 msgid "Multi-line"
-msgstr "Multi "
+msgstr "" 
+"Multi "
 "line"
 
 msgid "One with var: %s"
@@ -48,14 +81,6 @@ msgstr[0] "This one is the singular: %s"
 msgstr[1] "This one is the plural: %s"
 msgstr[2] "And this is the second plural form: %s"
 
-msgid "This one has invalid syntax translations"
-msgid_plural "Plural index"
-msgstr[abc] "Wrong index"
-msgstr[1 "Forgot to close brackets"
-msgstr[0] "Badly formatted string'
-
-msgid "Invalid formatted id[] with no translations
-
 msgctxt "Ctx"
 msgid "One with var: %s"
 msgid_plural "Several with vars: %s"
@@ -63,23 +88,23 @@ msgstr[0] "This one is the singular in a Ctx context: %s"
 msgstr[1] "This one is the plural in a Ctx context: %s"
 
 msgid "Some random"
-msgstr "Some random translation"
+msgstr "Some random Translation"
 
 msgctxt "Ctx"
 msgid "Some random in a context"
-msgstr "Some random translation in a context"
+msgstr "Some random Translation in a context"
 
-msgid "Empty translation"
+msgid "Empty Translation"
 msgstr ""
 
 msgid "Empty plural form singular"
 msgid_plural "Empty plural form"
 msgstr[0] "Singular translated"
-msgstr[1] "
+msgstr[1] ""
 
 msgid "More"
-msgstr "More translation"
+msgstr "More Translation"
-"
+
 	`
 
 	// Write PO content to file
@@ -141,7 +166,7 @@ msgstr "More translation"
 		t.Errorf("Expected 'This one is the plural: Variable' but got '%s'", tr)
 	}
 
-	// Test inexistent translations
+	// Test not existent translations
 	tr = po.Get("This is a test")
 	if tr != "This is a test" {
 		t.Errorf("Expected 'This is a test' but got '%s'", tr)
@@ -152,17 +177,6 @@ msgstr "More translation"
 		t.Errorf("Expected 'This are tests' but got '%s'", tr)
 	}
 
-	// Test syntax error parsed translations
-	tr = po.Get("This one has invalid syntax translations")
-	if tr != "This one has invalid syntax translations" {
-		t.Errorf("Expected 'This one has invalid syntax translations' but got '%s'", tr)
-	}
-
-	tr = po.GetN("This one has invalid syntax translations", "This are tests", 4)
-	if tr != "Plural index" {
-		t.Errorf("Expected 'Plural index' but got '%s'", tr)
-	}
-
 	// Test context translations
 	v = "Test"
 	tr = po.GetC("One with var: %s", "Ctx", v)
@@ -186,10 +200,10 @@ msgstr "More translation"
 		t.Errorf("Expected 'Original' but got '%s'", tr)
 	}
 
-	// Test empty translation strings
+	// Test empty Translation strings
-	tr = po.Get("Empty translation")
+	tr = po.Get("Empty Translation")
-	if tr != "Empty translation" {
+	if tr != "Empty Translation" {
-		t.Errorf("Expected 'Empty translation' but got '%s'", tr)
+		t.Errorf("Expected 'Empty Translation' but got '%s'", tr)
 	}
 
 	tr = po.Get("Empty plural form singular")
@@ -207,16 +221,79 @@ msgstr "More translation"
 		t.Errorf("Expected 'Empty plural form' but got '%s'", tr)
 	}
 
-	// Test last translation
+	// Test last Translation
 	tr = po.Get("More")
-	if tr != "More translation" {
+	if tr != "More Translation" {
-		t.Errorf("Expected 'More translation' but got '%s'", tr)
+		t.Errorf("Expected 'More Translation' but got '%s'", tr)
+	}
+}
+
+func TestPlural(t *testing.T) {
+	// Set PO content
+	str := `
+msgid   ""
+msgstr  ""
+"Plural-Forms: nplurals=2; plural=(n != 1);\n"
+
+msgid "Singular: %s"
+msgid_plural "Plural: %s"
+msgstr[0] "TR Singular: %s"
+msgstr[1] "TR Plural: %s"
+msgstr[2] "TR Plural 2: %s"
+
+	
+`
+	// Create po object
+	po := new(Po)
+	po.Parse([]byte(str))
+
+	v := "Var"
+	tr := po.GetN("Singular: %s", "Plural: %s", 2, v)
+	if tr != "TR Plural: Var" {
+		t.Errorf("Expected 'TR Plural: Var' but got '%s'", tr)
+	}
+
+	tr = po.GetN("Singular: %s", "Plural: %s", 1, v)
+	if tr != "TR Singular: Var" {
+		t.Errorf("Expected 'TR Singular: Var' but got '%s'", tr)
+	}
+}
+
+func TestPluralNoHeaderInformation(t *testing.T) {
+	// Set PO content
+	str := `
+msgid   ""
+msgstr  ""
+
+msgid "Singular: %s"
+msgid_plural "Plural: %s"
+msgstr[0] "TR Singular: %s"
+msgstr[1] "TR Plural: %s"
+msgstr[2] "TR Plural 2: %s"
+
+	
+`
+	// Create po object
+	po := new(Po)
+	po.Parse([]byte(str))
+
+	v := "Var"
+	tr := po.GetN("Singular: %s", "Plural: %s", 2, v)
+	if tr != "TR Plural: Var" {
+		t.Errorf("Expected 'TR Plural: Var' but got '%s'", tr)
+	}
+
+	tr = po.GetN("Singular: %s", "Plural: %s", 1, v)
+	if tr != "TR Singular: Var" {
+		t.Errorf("Expected 'TR Singular: Var' but got '%s'", tr)
 	}
 }
 
 func TestPoHeaders(t *testing.T) {
 	// Set PO content
 	str := `
+msgid   ""
+msgstr  ""
 # Initial comment
 # Headers below
 "Language: en\n"
@@ -233,7 +310,7 @@ msgstr "Translated example"
 	po := new(Po)
 
 	// Parse
-	po.Parse(str)
+	po.Parse([]byte(str))
 
 	// Check headers expected
 	if po.Language != "en" {
@@ -246,9 +323,30 @@ msgstr "Translated example"
 	}
 }
 
+func TestMissingPoHeadersSupport(t *testing.T) {
+	// Set PO content
+	str := `
+msgid "Example"
+msgstr "Translated example"
+	`
+
+	// Create po object
+	po := new(Po)
+
+	// Parse
+	po.Parse([]byte(str))
+
+	// Check Translation expected
+	if po.Get("Example") != "Translated example" {
+		t.Errorf("Expected 'Translated example' but got '%s'", po.Get("Example"))
+	}
+}
+
 func TestPluralFormsSingle(t *testing.T) {
 	// Single form
 	str := `
+msgid   ""
+msgstr  ""
 "Plural-Forms: nplurals=1; plural=0;"
 
 # Some comment
@@ -264,7 +362,7 @@ msgstr[3] "Plural form 3"
 	po := new(Po)
 
 	// Parse
-	po.Parse(str)
+	po.Parse([]byte(str))
 
 	// Check plural form
 	n := po.pluralForm(0)
@@ -292,6 +390,8 @@ msgstr[3] "Plural form 3"
 func TestPluralForms2(t *testing.T) {
 	// 2 forms
 	str := `
+msgid   ""
+msgstr  ""
 "Plural-Forms: nplurals=2; plural=n != 1;"
 
 # Some comment
@@ -307,7 +407,7 @@ msgstr[3] "Plural form 3"
 	po := new(Po)
 
 	// Parse
-	po.Parse(str)
+	po.Parse([]byte(str))
 
 	// Check plural form
 	n := po.pluralForm(0)
@@ -331,6 +431,8 @@ msgstr[3] "Plural form 3"
 func TestPluralForms3(t *testing.T) {
 	// 3 forms
 	str := `
+msgid   ""
+msgstr  ""
 "Plural-Forms: nplurals=3; plural=n%10==1 && n%100!=11 ? 0 : n != 0 ? 1 : 2;"
 
 # Some comment
@@ -346,7 +448,7 @@ msgstr[3] "Plural form 3"
 	po := new(Po)
 
 	// Parse
-	po.Parse(str)
+	po.Parse([]byte(str))
 
 	// Check plural form
 	n := po.pluralForm(0)
@@ -378,6 +480,8 @@ msgstr[3] "Plural form 3"
 func TestPluralFormsSpecial(t *testing.T) {
 	// 3 forms special
 	str := `
+msgid   ""
+msgstr  ""
 "Plural-Forms: nplurals=3;"
 "plural=(n==1) ? 0 : (n>=2 && n<=4) ? 1 : 2;"
 
@@ -394,7 +498,7 @@ msgstr[3] "Plural form 3"
 	po := new(Po)
 
 	// Parse
-	po.Parse(str)
+	po.Parse([]byte(str))
 
 	// Check plural form
 	n := po.pluralForm(1)
@@ -420,19 +524,18 @@ msgstr[3] "Plural form 3"
 }
 
 func TestTranslationObject(t *testing.T) {
-	tr := newTranslation()
+	tr := NewTranslation()
-	str := tr.get()
+	str := tr.Get()
 
 	if str != "" {
 		t.Errorf("Expected '' but got '%s'", str)
 	}
 
 	// Set id
-	tr.id = "Text"
+	tr.ID = "Text"
+	str = tr.Get()
 
 	// Get again
-	str = tr.get()
-
 	if str != "Text" {
 		t.Errorf("Expected 'Text' but got '%s'", str)
 	}
@@ -465,11 +568,11 @@ msgstr[2] "And this is the second plural form: %s"
 
 	// Parse po content in a goroutine
 	go func(po *Po, done chan bool) {
-		po.Parse(str)
+		po.Parse([]byte(str))
 		done <- true
 	}(po, pc)
 
-	// Read some translation on a goroutine
+	// Read some Translation on a goroutine
 	go func(po *Po, done chan bool) {
 		po.Get("My text")
 		done <- true
@@ -482,3 +585,62 @@ msgstr[2] "And this is the second plural form: %s"
 	<-pc
 	<-rc
 }
+
+func TestNewPoTranslatorRace(t *testing.T) {
+	// Create Po object
+	mo := NewPoTranslator()
+
+	// Create sync channels
+	pc := make(chan bool)
+	rc := make(chan bool)
+
+	// Parse po content in a goroutine
+	go func(mo Translator, done chan bool) {
+		// Parse file
+		mo.ParseFile("fixtures/en_US/default.po")
+		done <- true
+	}(mo, pc)
+
+	// Read some Translation on a goroutine
+	go func(mo Translator, done chan bool) {
+		mo.Get("My text")
+		done <- true
+	}(mo, rc)
+
+	// Read something at top level
+	mo.Get("My text")
+
+	// Wait for goroutines to finish
+	<-pc
+	<-rc
+}
+
+func TestPoBinaryEncoding(t *testing.T) {
+	// Create po objects
+	po := new(Po)
+	po2 := new(Po)
+
+	// Parse file
+	po.ParseFile("fixtures/en_US/default.po")
+
+	buff, err := po.MarshalBinary()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = po2.UnmarshalBinary(buff)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// Test translations
+	tr := po2.Get("My text")
+	if tr != "Translated text" {
+		t.Errorf("Expected 'Translated text' but got '%s'", tr)
+	}
+	// Test translations
+	tr = po2.Get("language")
+	if tr != "en_US" {
+		t.Errorf("Expected 'en_US' but got '%s'", tr)
+	}
+}

translation.go

@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2018 DeineAgentur UG https://www.deineagentur.com. All rights reserved.
+ * Licensed under the MIT License. See LICENSE file in the project root for full license information.
+ */
+
+package gotext
+
+// Translation is the struct for the Translations parsed via Po or Mo files and all coming parsers
+type Translation struct {
+	ID       string
+	PluralID string
+	Trs      map[int]string
+}
+
+// NewTranslation returns the Translation object and initialized it.
+func NewTranslation() *Translation {
+	tr := new(Translation)
+	tr.Trs = make(map[int]string)
+
+	return tr
+}
+
+// Get returns the string of the translation
+func (t *Translation) Get() string {
+	// Look for Translation index 0
+	if _, ok := t.Trs[0]; ok {
+		if t.Trs[0] != "" {
+			return t.Trs[0]
+		}
+	}
+
+	// Return untranslated id by default
+	return t.ID
+}
+
+// GetN returns the string of the plural translation
+func (t *Translation) GetN(n int) string {
+	// Look for Translation index
+	if _, ok := t.Trs[n]; ok {
+		if t.Trs[n] != "" {
+			return t.Trs[n]
+		}
+	}
+
+	// Return untranslated singular if corresponding
+	if n == 0 {
+		return t.ID
+	}
+
+	// Return untranslated plural by default
+	return t.PluralID
+}

translator.go

@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2018 DeineAgentur UG https://www.deineagentur.com. All rights reserved.
+ * Licensed under the MIT License. See LICENSE file in the project root for full license information.
+ */
+
+package gotext
+
+import "net/textproto"
+
+// Translator interface is used by Locale and Po objects.Translator
+// It contains all methods needed to parse translation sources and obtain corresponding translations.
+// Also implements gob.GobEncoder/gob.DobDecoder interfaces to allow serialization of Locale objects.
+type Translator interface {
+	ParseFile(f string)
+	Parse(buf []byte)
+	Get(str string, vars ...interface{}) string
+	GetN(str, plural string, n int, vars ...interface{}) string
+	GetC(str, ctx string, vars ...interface{}) string
+	GetNC(str, plural string, n int, ctx string, vars ...interface{}) string
+
+	MarshalBinary() ([]byte, error)
+	UnmarshalBinary([]byte) error
+}
+
+// TranslatorEncoding is used as intermediary storage to encode Translator objects to Gob.
+type TranslatorEncoding struct {
+	// Headers storage
+	Headers textproto.MIMEHeader
+
+	// Language header
+	Language string
+
+	// Plural-Forms header
+	PluralForms string
+
+	// Parsed Plural-Forms header values
+	Nplurals int
+	Plural   string
+
+	// Storage
+	Translations map[string]*Translation
+	Contexts     map[string]map[string]*Translation
+}
+
+// GetTranslator is used to recover a Translator object after unmarshaling the TranslatorEncoding object.
+// Internally uses a Po object as it should be switcheable with Mo objects without problem.
+// External Translator implementations should be able to serialize into a TranslatorEncoding object in order to unserialize into a Po-compatible object.
+func (te *TranslatorEncoding) GetTranslator() Translator {
+	po := new(Po)
+	po.Headers = te.Headers
+	po.Language = te.Language
+	po.PluralForms = te.PluralForms
+	po.nplurals = te.Nplurals
+	po.plural = te.Plural
+	po.translations = te.Translations
+	po.contexts = te.Contexts
+
+	return po
+}

vendor/github.com/mattn/kinako/ast/expr.go

@@ -1,104 +0,0 @@
-package ast
-
-type Token struct {
-	Tok int
-	Lit string
-}
-
-// Position provides interface to store code locations.
-type Position struct {
-	Line   int
-	Column int
-}
-
-// Expr provides all of interfaces for expression.
-type Expr interface {
-	expr()
-}
-
-// ExprImpl provide commonly implementations for Expr.
-type ExprImpl struct {
-}
-
-// expr provide restraint interface.
-func (x *ExprImpl) expr() {}
-
-// NumberExpr provide Number expression.
-type NumberExpr struct {
-	ExprImpl
-	Lit string
-}
-
-// UnaryExpr provide unary minus expression. ex: -1, ^1, ~1.
-type UnaryExpr struct {
-	ExprImpl
-	Operator string
-	Expr     Expr
-}
-
-// IdentExpr provide identity expression.
-type IdentExpr struct {
-	ExprImpl
-	Lit string
-}
-
-// Stmt provides all of interfaces for statement.
-type Stmt interface {
-	stmt()
-}
-
-// StmtImpl provide commonly implementations for Stmt..
-type StmtImpl struct {
-}
-
-// stmt provide restraint interface.
-func (x *StmtImpl) stmt() {}
-
-// LetsStmt provide multiple statement of let.
-type LetsStmt struct {
-	StmtImpl
-	Lhss     []Expr
-	Operator string
-	Rhss     []Expr
-}
-
-// StringExpr provide String expression.
-type StringExpr struct {
-	ExprImpl
-	Lit string
-}
-
-type TernaryOpExpr struct {
-	ExprImpl
-	Expr Expr
-	Lhs  Expr
-	Rhs  Expr
-}
-
-// ParenExpr provide parent block expression.
-type ParenExpr struct {
-	ExprImpl
-	SubExpr Expr
-}
-
-// BinOpExpr provide binary operator expression.
-type BinOpExpr struct {
-	ExprImpl
-	Lhs      Expr
-	Operator string
-	Rhs      Expr
-}
-
-// ExprStmt provide expression statement.
-type ExprStmt struct {
-	StmtImpl
-	Expr Expr
-}
-
-// LetStmt provide statement of let.
-type LetStmt struct {
-	StmtImpl
-	Lhs      Expr
-	Operator string
-	Rhs      Expr
-}

vendor/github.com/mattn/kinako/parser/Makefile

@@ -1,4 +0,0 @@
-all : parser.go
-
-parser.go : parser.go.y
-	goyacc -o $@ parser.go.y

vendor/github.com/mattn/kinako/parser/lexer.go

@@ -1,427 +0,0 @@
-package parser
-
-import (
-	"errors"
-	"fmt"
-	"unicode"
-
-	"github.com/mattn/kinako/ast"
-)
-
-const (
-	EOF = -1   // End of file.
-	EOL = '\n' // End of line.
-)
-
-// Error provides a convenient interface for handling runtime error.
-// It can be Error inteface with type cast which can call Pos().
-type Error struct {
-	Message  string
-	Filename string
-	Fatal    bool
-}
-
-// Error returns the error message.
-func (e *Error) Error() string {
-	return e.Message
-}
-
-// Scanner stores informations for lexer.
-type Scanner struct {
-	src      []rune
-	offset   int
-	lineHead int
-	line     int
-}
-
-// Init resets code to scan.
-func (s *Scanner) Init(src string) {
-	s.src = []rune(src)
-}
-
-// Scan analyses token, and decide identify or literals.
-func (s *Scanner) Scan() (tok int, lit string, pos ast.Position, err error) {
-retry:
-	s.skipBlank()
-	pos = s.pos()
-	switch ch := s.peek(); {
-	case isLetter(ch):
-		tok = IDENT
-		lit, err = s.scanIdentifier()
-		if err != nil {
-			return
-		}
-	case isDigit(ch):
-		tok = NUMBER
-		lit, err = s.scanNumber()
-		if err != nil {
-			return
-		}
-	case ch == '"':
-		tok = STRING
-		lit, err = s.scanString('"')
-		if err != nil {
-			return
-		}
-	case ch == '\'':
-		tok = STRING
-		lit, err = s.scanString('\'')
-		if err != nil {
-			return
-		}
-	case ch == '`':
-		tok = STRING
-		lit, err = s.scanRawString()
-		if err != nil {
-			return
-		}
-	default:
-		switch ch {
-		case EOF:
-			tok = EOF
-		case '#':
-			for !isEOL(s.peek()) {
-				s.next()
-			}
-			goto retry
-		case '!':
-			s.next()
-			switch s.peek() {
-			case '=':
-				tok = NEQ
-				lit = "!="
-			default:
-				s.back()
-				tok = int(ch)
-				lit = string(ch)
-			}
-		case '=':
-			s.next()
-			switch s.peek() {
-			case '=':
-				tok = EQEQ
-				lit = "=="
-			default:
-				s.back()
-				tok = int(ch)
-				lit = string(ch)
-			}
-		case '+':
-			tok = int(ch)
-			lit = string(ch)
-		case '-':
-			tok = int(ch)
-			lit = string(ch)
-		case '*':
-			tok = int(ch)
-			lit = string(ch)
-		case '/':
-			tok = int(ch)
-			lit = string(ch)
-		case '>':
-			s.next()
-			switch s.peek() {
-			case '=':
-				tok = GE
-				lit = ">="
-			case '>':
-				tok = SHIFTRIGHT
-				lit = ">>"
-			default:
-				s.back()
-				tok = int(ch)
-				lit = string(ch)
-			}
-		case '<':
-			s.next()
-			switch s.peek() {
-			case '=':
-				tok = LE
-				lit = "<="
-			case '<':
-				tok = SHIFTLEFT
-				lit = "<<"
-			default:
-				s.back()
-				tok = int(ch)
-				lit = string(ch)
-			}
-		case '|':
-			s.next()
-			switch s.peek() {
-			case '|':
-				tok = OROR
-				lit = "||"
-			default:
-				s.back()
-				tok = int(ch)
-				lit = string(ch)
-			}
-		case '&':
-			s.next()
-			switch s.peek() {
-			case '&':
-				tok = ANDAND
-				lit = "&&"
-			default:
-				s.back()
-				tok = int(ch)
-				lit = string(ch)
-			}
-		case '.':
-			tok = int(ch)
-			lit = string(ch)
-		case '\n':
-			tok = int(ch)
-			lit = string(ch)
-		case '(', ')', ':', ';', '%', '?', '{', '}', ',', '[', ']', '^':
-			tok = int(ch)
-			lit = string(ch)
-		default:
-			err = fmt.Errorf(`syntax error "%s"`, string(ch))
-			tok = int(ch)
-			lit = string(ch)
-			return
-		}
-		s.next()
-	}
-	return
-}
-
-// isLetter returns true if the rune is a letter for identity.
-func isLetter(ch rune) bool {
-	return unicode.IsLetter(ch) || ch == '_'
-}
-
-// isDigit returns true if the rune is a number.
-func isDigit(ch rune) bool {
-	return '0' <= ch && ch <= '9'
-}
-
-// isHex returns true if the rune is a hex digits.
-func isHex(ch rune) bool {
-	return ('0' <= ch && ch <= '9') || ('a' <= ch && ch <= 'f') || ('A' <= ch && ch <= 'F')
-}
-
-// isEOL returns true if the rune is at end-of-line or end-of-file.
-func isEOL(ch rune) bool {
-	return ch == '\n' || ch == -1
-}
-
-// isBlank returns true if the rune is empty character..
-func isBlank(ch rune) bool {
-	return ch == ' ' || ch == '\t' || ch == '\r'
-}
-
-// peek returns current rune in the code.
-func (s *Scanner) peek() rune {
-	if s.reachEOF() {
-		return EOF
-	}
-	return s.src[s.offset]
-}
-
-// next moves offset to next.
-func (s *Scanner) next() {
-	if !s.reachEOF() {
-		if s.peek() == '\n' {
-			s.lineHead = s.offset + 1
-			s.line++
-		}
-		s.offset++
-	}
-}
-
-// current returns the current offset.
-func (s *Scanner) current() int {
-	return s.offset
-}
-
-// offset sets the offset value.
-func (s *Scanner) set(o int) {
-	s.offset = o
-}
-
-// back moves back offset once to top.
-func (s *Scanner) back() {
-	s.offset--
-}
-
-// reachEOF returns true if offset is at end-of-file.
-func (s *Scanner) reachEOF() bool {
-	return len(s.src) <= s.offset
-}
-
-// pos returns the position of current.
-func (s *Scanner) pos() ast.Position {
-	return ast.Position{Line: s.line + 1, Column: s.offset - s.lineHead + 1}
-}
-
-// skipBlank moves position into non-black character.
-func (s *Scanner) skipBlank() {
-	for isBlank(s.peek()) {
-		s.next()
-	}
-}
-
-// scanIdentifier returns identifier begining at current position.
-func (s *Scanner) scanIdentifier() (string, error) {
-	var ret []rune
-	for {
-		if !isLetter(s.peek()) && !isDigit(s.peek()) {
-			break
-		}
-		ret = append(ret, s.peek())
-		s.next()
-	}
-	return string(ret), nil
-}
-
-// scanNumber returns number begining at current position.
-func (s *Scanner) scanNumber() (string, error) {
-	var ret []rune
-	ch := s.peek()
-	ret = append(ret, ch)
-	s.next()
-	if ch == '0' && s.peek() == 'x' {
-		ret = append(ret, s.peek())
-		s.next()
-		for isHex(s.peek()) {
-			ret = append(ret, s.peek())
-			s.next()
-		}
-	} else {
-		for isDigit(s.peek()) || s.peek() == '.' {
-			ret = append(ret, s.peek())
-			s.next()
-		}
-		if s.peek() == 'e' {
-			ret = append(ret, s.peek())
-			s.next()
-			if isDigit(s.peek()) || s.peek() == '+' || s.peek() == '-' {
-				ret = append(ret, s.peek())
-				s.next()
-				for isDigit(s.peek()) || s.peek() == '.' {
-					ret = append(ret, s.peek())
-					s.next()
-				}
-			}
-			for isDigit(s.peek()) || s.peek() == '.' {
-				ret = append(ret, s.peek())
-				s.next()
-			}
-		}
-		if isLetter(s.peek()) {
-			return "", errors.New("identifier starts immediately after numeric literal")
-		}
-	}
-	return string(ret), nil
-}
-
-// scanRawString returns raw-string starting at current position.
-func (s *Scanner) scanRawString() (string, error) {
-	var ret []rune
-	for {
-		s.next()
-		if s.peek() == EOF {
-			return "", errors.New("unexpected EOF")
-			break
-		}
-		if s.peek() == '`' {
-			s.next()
-			break
-		}
-		ret = append(ret, s.peek())
-	}
-	return string(ret), nil
-}
-
-// scanString returns string starting at current position.
-// This handles backslash escaping.
-func (s *Scanner) scanString(l rune) (string, error) {
-	var ret []rune
-eos:
-	for {
-		s.next()
-		switch s.peek() {
-		case EOL:
-			return "", errors.New("unexpected EOL")
-		case EOF:
-			return "", errors.New("unexpected EOF")
-		case l:
-			s.next()
-			break eos
-		case '\\':
-			s.next()
-			switch s.peek() {
-			case 'b':
-				ret = append(ret, '\b')
-				continue
-			case 'f':
-				ret = append(ret, '\f')
-				continue
-			case 'r':
-				ret = append(ret, '\r')
-				continue
-			case 'n':
-				ret = append(ret, '\n')
-				continue
-			case 't':
-				ret = append(ret, '\t')
-				continue
-			}
-			ret = append(ret, s.peek())
-			continue
-		default:
-			ret = append(ret, s.peek())
-		}
-	}
-	return string(ret), nil
-}
-
-// Lexer provides inteface to parse codes.
-type Lexer struct {
-	s     *Scanner
-	lit   string
-	pos   ast.Position
-	e     error
-	stmts []ast.Stmt
-}
-
-// Lex scans the token and literals.
-func (l *Lexer) Lex(lval *yySymType) int {
-	tok, lit, pos, err := l.s.Scan()
-	if err != nil {
-		l.e = &Error{Message: fmt.Sprintf("%s", err.Error()), Fatal: true}
-	}
-	lval.tok = ast.Token{Tok: tok, Lit: lit}
-	l.lit = lit
-	l.pos = pos
-	return tok
-}
-
-// Error sets parse error.
-func (l *Lexer) Error(msg string) {
-	l.e = &Error{Message: msg, Fatal: false}
-}
-
-// Parser provides way to parse the code using Scanner.
-func Parse(s *Scanner) ([]ast.Stmt, error) {
-	l := Lexer{s: s}
-	if yyParse(&l) != 0 {
-		return nil, l.e
-	}
-	return l.stmts, l.e
-}
-
-func EnableErrorVerbose() {
-	yyErrorVerbose = true
-}
-
-// ParserSrc provides way to parse the code from source.
-func ParseSrc(src string) ([]ast.Stmt, error) {
-	scanner := &Scanner{
-		src: []rune(src),
-	}
-	return Parse(scanner)
-}

vendor/github.com/mattn/kinako/parser/parser.go

@@ -1,752 +0,0 @@
-//line parser.go.y:2
-package parser
-
-import __yyfmt__ "fmt"
-
-//line parser.go.y:2
-import (
-	"github.com/mattn/kinako/ast"
-)
-
-//line parser.go.y:15
-type yySymType struct {
-	yys       int
-	compstmt  []ast.Stmt
-	stmts     []ast.Stmt
-	stmt      ast.Stmt
-	expr      ast.Expr
-	tok       ast.Token
-	term      ast.Token
-	terms     ast.Token
-	opt_terms ast.Token
-}
-
-const IDENT = 57346
-const NUMBER = 57347
-const STRING = 57348
-const EQEQ = 57349
-const NEQ = 57350
-const GE = 57351
-const LE = 57352
-const OROR = 57353
-const ANDAND = 57354
-const POW = 57355
-const SHIFTLEFT = 57356
-const SHIFTRIGHT = 57357
-const PLUSPLUS = 57358
-const MINUSMINUS = 57359
-const UNARY = 57360
-
-var yyToknames = [...]string{
-	"$end",
-	"error",
-	"$unk",
-	"IDENT",
-	"NUMBER",
-	"STRING",
-	"EQEQ",
-	"NEQ",
-	"GE",
-	"LE",
-	"OROR",
-	"ANDAND",
-	"POW",
-	"'='",
-	"'?'",
-	"':'",
-	"','",
-	"'>'",
-	"'<'",
-	"SHIFTLEFT",
-	"SHIFTRIGHT",
-	"'+'",
-	"'-'",
-	"PLUSPLUS",
-	"MINUSMINUS",
-	"'*'",
-	"'/'",
-	"'%'",
-	"UNARY",
-	"'!'",
-	"'^'",
-	"'('",
-	"')'",
-	"'|'",
-	"'&'",
-	"';'",
-	"'\\n'",
-}
-var yyStatenames = [...]string{}
-
-const yyEofCode = 1
-const yyErrCode = 2
-const yyInitialStackSize = 16
-
-//line parser.go.y:194
-
-//line yacctab:1
-var yyExca = [...]int{
-	-1, 1,
-	1, -1,
-	-2, 0,
-	-1, 49,
-	7, 0,
-	8, 0,
-	-2, 20,
-	-1, 50,
-	7, 0,
-	8, 0,
-	-2, 21,
-}
-
-const yyNprod = 36
-const yyPrivate = 57344
-
-var yyTokenNames []string
-var yyStates []string
-
-const yyLast = 249
-
-var yyAct = [...]int{
-
-	9, 6, 7, 33, 35, 4, 22, 23, 3, 18,
-	24, 25, 26, 37, 38, 39, 2, 40, 33, 35,
-	17, 42, 43, 44, 45, 46, 47, 48, 49, 50,
-	51, 52, 53, 54, 55, 56, 57, 58, 27, 28,
-	30, 32, 34, 36, 8, 1, 21, 60, 0, 29,
-	31, 0, 0, 22, 23, 5, 0, 24, 25, 26,
-	19, 61, 0, 41, 0, 33, 35, 27, 28, 30,
-	32, 34, 36, 0, 19, 21, 0, 0, 29, 31,
-	0, 0, 22, 23, 0, 0, 24, 25, 26, 0,
-	0, 0, 0, 59, 33, 35, 27, 28, 30, 32,
-	34, 36, 0, 20, 21, 0, 0, 29, 31, 0,
-	0, 22, 23, 0, 0, 24, 25, 26, 0, 0,
-	0, 0, 0, 33, 35, 27, 28, 30, 32, 34,
-	36, 0, 0, 21, 0, 0, 29, 31, 0, 0,
-	22, 23, 0, 0, 24, 25, 26, 0, 0, 0,
-	0, 0, 33, 35, 27, 28, 30, 32, 0, 36,
-	0, 0, 0, 0, 0, 29, 31, 0, 0, 22,
-	23, 0, 0, 24, 25, 26, 27, 28, 30, 32,
-	0, 33, 35, 0, 0, 0, 0, 29, 31, 0,
-	0, 22, 23, 0, 0, 24, 25, 26, 30, 32,
-	10, 11, 15, 33, 35, 0, 0, 29, 31, 0,
-	0, 22, 23, 0, 0, 24, 25, 26, 0, 12,
-	10, 11, 15, 33, 35, 0, 13, 14, 16, 24,
-	25, 26, 6, 7, 0, 0, 0, 33, 35, 12,
-	0, 0, 0, 0, 0, 0, 13, 14, 16,
-}
-var yyPact = [...]int{
-
-	-35, -1000, 216, -35, -35, -1000, -1000, -1000, -1000, 89,
-	-1000, -1000, 216, 216, 216, -1000, 216, -1000, 196, -1000,
-	216, 216, 216, 216, 216, 216, 216, 216, 216, 216,
-	216, 216, 216, 216, 216, 216, 216, -31, -31, -31,
-	60, -1000, 118, 31, 203, 203, -31, -31, -31, 189,
-	189, -16, -16, -16, -16, 118, 147, 118, 169, -1000,
-	216, 118,
-}
-var yyPgo = [...]int{
-
-	0, 45, 8, 44, 0, 16, 5, 55,
-}
-var yyR1 = [...]int{
-
-	0, 1, 1, 2, 2, 3, 3, 4, 4, 4,
-	4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
-	4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
-	5, 5, 6, 6, 7, 7,
-}
-var yyR2 = [...]int{
-
-	0, 1, 2, 2, 3, 3, 1, 1, 1, 2,
-	2, 2, 1, 5, 3, 3, 3, 3, 3, 3,
-	3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
-	0, 1, 1, 2, 1, 1,
-}
-var yyChk = [...]int{
-
-	-1000, -1, -5, -2, -6, -7, 36, 37, -3, -4,
-	4, 5, 23, 30, 31, 6, 32, -5, -6, -7,
-	14, 15, 22, 23, 26, 27, 28, 7, 8, 18,
-	9, 19, 10, 34, 11, 35, 12, -4, -4, -4,
-	-4, -3, -4, -4, -4, -4, -4, -4, -4, -4,
-	-4, -4, -4, -4, -4, -4, -4, -4, -4, 33,
-	16, -4,
-}
-var yyDef = [...]int{
-
-	30, -2, 1, 30, 31, 32, 34, 35, 3, 6,
-	7, 8, 0, 0, 0, 12, 0, 2, 31, 33,
-	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 0, 9, 10, 11,
-	0, 4, 5, 0, 15, 16, 17, 18, 19, -2,
-	-2, 22, 23, 24, 25, 26, 27, 28, 29, 14,
-	0, 13,
-}
-var yyTok1 = [...]int{
-
-	1, 3, 3, 3, 3, 3, 3, 3, 3, 3,
-	37, 3, 3, 3, 3, 3, 3, 3, 3, 3,
-	3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
-	3, 3, 3, 30, 3, 3, 3, 28, 35, 3,
-	32, 33, 26, 22, 17, 23, 3, 27, 3, 3,
-	3, 3, 3, 3, 3, 3, 3, 3, 16, 36,
-	19, 14, 18, 15, 3, 3, 3, 3, 3, 3,
-	3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
-	3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
-	3, 3, 3, 3, 31, 3, 3, 3, 3, 3,
-	3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
-	3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
-	3, 3, 3, 3, 34,
-}
-var yyTok2 = [...]int{
-
-	2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
-	12, 13, 20, 21, 24, 25, 29,
-}
-var yyTok3 = [...]int{
-	0,
-}
-
-var yyErrorMessages = [...]struct {
-	state int
-	token int
-	msg   string
-}{}
-
-//line yaccpar:1
-
-/*	parser for yacc output	*/
-
-var (
-	yyDebug        = 0
-	yyErrorVerbose = false
-)
-
-type yyLexer interface {
-	Lex(lval *yySymType) int
-	Error(s string)
-}
-
-type yyParser interface {
-	Parse(yyLexer) int
-	Lookahead() int
-}
-
-type yyParserImpl struct {
-	lval  yySymType
-	stack [yyInitialStackSize]yySymType
-	char  int
-}
-
-func (p *yyParserImpl) Lookahead() int {
-	return p.char
-}
-
-func yyNewParser() yyParser {
-	return &yyParserImpl{}
-}
-
-const yyFlag = -1000
-
-func yyTokname(c int) string {
-	if c >= 1 && c-1 < len(yyToknames) {
-		if yyToknames[c-1] != "" {
-			return yyToknames[c-1]
-		}
-	}
-	return __yyfmt__.Sprintf("tok-%v", c)
-}
-
-func yyStatname(s int) string {
-	if s >= 0 && s < len(yyStatenames) {
-		if yyStatenames[s] != "" {
-			return yyStatenames[s]
-		}
-	}
-	return __yyfmt__.Sprintf("state-%v", s)
-}
-
-func yyErrorMessage(state, lookAhead int) string {
-	const TOKSTART = 4
-
-	if !yyErrorVerbose {
-		return "syntax error"
-	}
-
-	for _, e := range yyErrorMessages {
-		if e.state == state && e.token == lookAhead {
-			return "syntax error: " + e.msg
-		}
-	}
-
-	res := "syntax error: unexpected " + yyTokname(lookAhead)
-
-	// To match Bison, suggest at most four expected tokens.
-	expected := make([]int, 0, 4)
-
-	// Look for shiftable tokens.
-	base := yyPact[state]
-	for tok := TOKSTART; tok-1 < len(yyToknames); tok++ {
-		if n := base + tok; n >= 0 && n < yyLast && yyChk[yyAct[n]] == tok {
-			if len(expected) == cap(expected) {
-				return res
-			}
-			expected = append(expected, tok)
-		}
-	}
-
-	if yyDef[state] == -2 {
-		i := 0
-		for yyExca[i] != -1 || yyExca[i+1] != state {
-			i += 2
-		}
-
-		// Look for tokens that we accept or reduce.
-		for i += 2; yyExca[i] >= 0; i += 2 {
-			tok := yyExca[i]
-			if tok < TOKSTART || yyExca[i+1] == 0 {
-				continue
-			}
-			if len(expected) == cap(expected) {
-				return res
-			}
-			expected = append(expected, tok)
-		}
-
-		// If the default action is to accept or reduce, give up.
-		if yyExca[i+1] != 0 {
-			return res
-		}
-	}
-
-	for i, tok := range expected {
-		if i == 0 {
-			res += ", expecting "
-		} else {
-			res += " or "
-		}
-		res += yyTokname(tok)
-	}
-	return res
-}
-
-func yylex1(lex yyLexer, lval *yySymType) (char, token int) {
-	token = 0
-	char = lex.Lex(lval)
-	if char <= 0 {
-		token = yyTok1[0]
-		goto out
-	}
-	if char < len(yyTok1) {
-		token = yyTok1[char]
-		goto out
-	}
-	if char >= yyPrivate {
-		if char < yyPrivate+len(yyTok2) {
-			token = yyTok2[char-yyPrivate]
-			goto out
-		}
-	}
-	for i := 0; i < len(yyTok3); i += 2 {
-		token = yyTok3[i+0]
-		if token == char {
-			token = yyTok3[i+1]
-			goto out
-		}
-	}
-
-out:
-	if token == 0 {
-		token = yyTok2[1] /* unknown char */
-	}
-	if yyDebug >= 3 {
-		__yyfmt__.Printf("lex %s(%d)\n", yyTokname(token), uint(char))
-	}
-	return char, token
-}
-
-func yyParse(yylex yyLexer) int {
-	return yyNewParser().Parse(yylex)
-}
-
-func (yyrcvr *yyParserImpl) Parse(yylex yyLexer) int {
-	var yyn int
-	var yyVAL yySymType
-	var yyDollar []yySymType
-	_ = yyDollar // silence set and not used
-	yyS := yyrcvr.stack[:]
-
-	Nerrs := 0   /* number of errors */
-	Errflag := 0 /* error recovery flag */
-	yystate := 0
-	yyrcvr.char = -1
-	yytoken := -1 // yyrcvr.char translated into internal numbering
-	defer func() {
-		// Make sure we report no lookahead when not parsing.
-		yystate = -1
-		yyrcvr.char = -1
-		yytoken = -1
-	}()
-	yyp := -1
-	goto yystack
-
-ret0:
-	return 0
-
-ret1:
-	return 1
-
-yystack:
-	/* put a state and value onto the stack */
-	if yyDebug >= 4 {
-		__yyfmt__.Printf("char %v in %v\n", yyTokname(yytoken), yyStatname(yystate))
-	}
-
-	yyp++
-	if yyp >= len(yyS) {
-		nyys := make([]yySymType, len(yyS)*2)
-		copy(nyys, yyS)
-		yyS = nyys
-	}
-	yyS[yyp] = yyVAL
-	yyS[yyp].yys = yystate
-
-yynewstate:
-	yyn = yyPact[yystate]
-	if yyn <= yyFlag {
-		goto yydefault /* simple state */
-	}
-	if yyrcvr.char < 0 {
-		yyrcvr.char, yytoken = yylex1(yylex, &yyrcvr.lval)
-	}
-	yyn += yytoken
-	if yyn < 0 || yyn >= yyLast {
-		goto yydefault
-	}
-	yyn = yyAct[yyn]
-	if yyChk[yyn] == yytoken { /* valid shift */
-		yyrcvr.char = -1
-		yytoken = -1
-		yyVAL = yyrcvr.lval
-		yystate = yyn
-		if Errflag > 0 {
-			Errflag--
-		}
-		goto yystack
-	}
-
-yydefault:
-	/* default state action */
-	yyn = yyDef[yystate]
-	if yyn == -2 {
-		if yyrcvr.char < 0 {
-			yyrcvr.char, yytoken = yylex1(yylex, &yyrcvr.lval)
-		}
-
-		/* look through exception table */
-		xi := 0
-		for {
-			if yyExca[xi+0] == -1 && yyExca[xi+1] == yystate {
-				break
-			}
-			xi += 2
-		}
-		for xi += 2; ; xi += 2 {
-			yyn = yyExca[xi+0]
-			if yyn < 0 || yyn == yytoken {
-				break
-			}
-		}
-		yyn = yyExca[xi+1]
-		if yyn < 0 {
-			goto ret0
-		}
-	}
-	if yyn == 0 {
-		/* error ... attempt to resume parsing */
-		switch Errflag {
-		case 0: /* brand new error */
-			yylex.Error(yyErrorMessage(yystate, yytoken))
-			Nerrs++
-			if yyDebug >= 1 {
-				__yyfmt__.Printf("%s", yyStatname(yystate))
-				__yyfmt__.Printf(" saw %s\n", yyTokname(yytoken))
-			}
-			fallthrough
-
-		case 1, 2: /* incompletely recovered error ... try again */
-			Errflag = 3
-
-			/* find a state where "error" is a legal shift action */
-			for yyp >= 0 {
-				yyn = yyPact[yyS[yyp].yys] + yyErrCode
-				if yyn >= 0 && yyn < yyLast {
-					yystate = yyAct[yyn] /* simulate a shift of "error" */
-					if yyChk[yystate] == yyErrCode {
-						goto yystack
-					}
-				}
-
-				/* the current p has no shift on "error", pop stack */
-				if yyDebug >= 2 {
-					__yyfmt__.Printf("error recovery pops state %d\n", yyS[yyp].yys)
-				}
-				yyp--
-			}
-			/* there is no state on the stack with an error shift ... abort */
-			goto ret1
-
-		case 3: /* no shift yet; clobber input char */
-			if yyDebug >= 2 {
-				__yyfmt__.Printf("error recovery discards %s\n", yyTokname(yytoken))
-			}
-			if yytoken == yyEofCode {
-				goto ret1
-			}
-			yyrcvr.char = -1
-			yytoken = -1
-			goto yynewstate /* try again in the same state */
-		}
-	}
-
-	/* reduction by production yyn */
-	if yyDebug >= 2 {
-		__yyfmt__.Printf("reduce %v in:\n\t%v\n", yyn, yyStatname(yystate))
-	}
-
-	yynt := yyn
-	yypt := yyp
-	_ = yypt // guard against "declared and not used"
-
-	yyp -= yyR2[yyn]
-	// yyp is now the index of $0. Perform the default action. Iff the
-	// reduced production is ε, $1 is possibly out of range.
-	if yyp+1 >= len(yyS) {
-		nyys := make([]yySymType, len(yyS)*2)
-		copy(nyys, yyS)
-		yyS = nyys
-	}
-	yyVAL = yyS[yyp+1]
-
-	/* consult goto table to find next state */
-	yyn = yyR1[yyn]
-	yyg := yyPgo[yyn]
-	yyj := yyg + yyS[yyp].yys + 1
-
-	if yyj >= yyLast {
-		yystate = yyAct[yyg]
-	} else {
-		yystate = yyAct[yyj]
-		if yyChk[yystate] != -yyn {
-			yystate = yyAct[yyg]
-		}
-	}
-	// dummy call; replaced with literal code
-	switch yynt {
-
-	case 1:
-		yyDollar = yyS[yypt-1 : yypt+1]
-		//line parser.go.y:43
-		{
-			yyVAL.compstmt = nil
-		}
-	case 2:
-		yyDollar = yyS[yypt-2 : yypt+1]
-		//line parser.go.y:47
-		{
-			yyVAL.compstmt = yyDollar[1].stmts
-		}
-	case 3:
-		yyDollar = yyS[yypt-2 : yypt+1]
-		//line parser.go.y:53
-		{
-			yyVAL.stmts = []ast.Stmt{yyDollar[2].stmt}
-			if l, ok := yylex.(*Lexer); ok {
-				l.stmts = yyVAL.stmts
-			}
-		}
-	case 4:
-		yyDollar = yyS[yypt-3 : yypt+1]
-		//line parser.go.y:60
-		{
-			if yyDollar[3].stmt != nil {
-				yyVAL.stmts = append(yyDollar[1].stmts, yyDollar[3].stmt)
-				if l, ok := yylex.(*Lexer); ok {
-					l.stmts = yyVAL.stmts
-				}
-			}
-		}
-	case 5:
-		yyDollar = yyS[yypt-3 : yypt+1]
-		//line parser.go.y:71
-		{
-			yyVAL.stmt = &ast.LetStmt{Lhs: yyDollar[1].expr, Operator: "=", Rhs: yyDollar[3].expr}
-		}
-	case 6:
-		yyDollar = yyS[yypt-1 : yypt+1]
-		//line parser.go.y:75
-		{
-			yyVAL.stmt = &ast.ExprStmt{Expr: yyDollar[1].expr}
-		}
-	case 7:
-		yyDollar = yyS[yypt-1 : yypt+1]
-		//line parser.go.y:81
-		{
-			yyVAL.expr = &ast.IdentExpr{Lit: yyDollar[1].tok.Lit}
-		}
-	case 8:
-		yyDollar = yyS[yypt-1 : yypt+1]
-		//line parser.go.y:85
-		{
-			yyVAL.expr = &ast.NumberExpr{Lit: yyDollar[1].tok.Lit}
-		}
-	case 9:
-		yyDollar = yyS[yypt-2 : yypt+1]
-		//line parser.go.y:89
-		{
-			yyVAL.expr = &ast.UnaryExpr{Operator: "-", Expr: yyDollar[2].expr}
-		}
-	case 10:
-		yyDollar = yyS[yypt-2 : yypt+1]
-		//line parser.go.y:93
-		{
-			yyVAL.expr = &ast.UnaryExpr{Operator: "!", Expr: yyDollar[2].expr}
-		}
-	case 11:
-		yyDollar = yyS[yypt-2 : yypt+1]
-		//line parser.go.y:97
-		{
-			yyVAL.expr = &ast.UnaryExpr{Operator: "^", Expr: yyDollar[2].expr}
-		}
-	case 12:
-		yyDollar = yyS[yypt-1 : yypt+1]
-		//line parser.go.y:101
-		{
-			yyVAL.expr = &ast.StringExpr{Lit: yyDollar[1].tok.Lit}
-		}
-	case 13:
-		yyDollar = yyS[yypt-5 : yypt+1]
-		//line parser.go.y:105
-		{
-			yyVAL.expr = &ast.TernaryOpExpr{Expr: yyDollar[1].expr, Lhs: yyDollar[3].expr, Rhs: yyDollar[5].expr}
-		}
-	case 14:
-		yyDollar = yyS[yypt-3 : yypt+1]
-		//line parser.go.y:109
-		{
-			yyVAL.expr = &ast.ParenExpr{SubExpr: yyDollar[2].expr}
-		}
-	case 15:
-		yyDollar = yyS[yypt-3 : yypt+1]
-		//line parser.go.y:113
-		{
-			yyVAL.expr = &ast.BinOpExpr{Lhs: yyDollar[1].expr, Operator: "+", Rhs: yyDollar[3].expr}
-		}
-	case 16:
-		yyDollar = yyS[yypt-3 : yypt+1]
-		//line parser.go.y:117
-		{
-			yyVAL.expr = &ast.BinOpExpr{Lhs: yyDollar[1].expr, Operator: "-", Rhs: yyDollar[3].expr}
-		}
-	case 17:
-		yyDollar = yyS[yypt-3 : yypt+1]
-		//line parser.go.y:121
-		{
-			yyVAL.expr = &ast.BinOpExpr{Lhs: yyDollar[1].expr, Operator: "*", Rhs: yyDollar[3].expr}
-		}
-	case 18:
-		yyDollar = yyS[yypt-3 : yypt+1]
-		//line parser.go.y:125
-		{
-			yyVAL.expr = &ast.BinOpExpr{Lhs: yyDollar[1].expr, Operator: "/", Rhs: yyDollar[3].expr}
-		}
-	case 19:
-		yyDollar = yyS[yypt-3 : yypt+1]
-		//line parser.go.y:129
-		{
-			yyVAL.expr = &ast.BinOpExpr{Lhs: yyDollar[1].expr, Operator: "%", Rhs: yyDollar[3].expr}
-		}
-	case 20:
-		yyDollar = yyS[yypt-3 : yypt+1]
-		//line parser.go.y:133
-		{
-			yyVAL.expr = &ast.BinOpExpr{Lhs: yyDollar[1].expr, Operator: "==", Rhs: yyDollar[3].expr}
-		}
-	case 21:
-		yyDollar = yyS[yypt-3 : yypt+1]
-		//line parser.go.y:137
-		{
-			yyVAL.expr = &ast.BinOpExpr{Lhs: yyDollar[1].expr, Operator: "!=", Rhs: yyDollar[3].expr}
-		}
-	case 22:
-		yyDollar = yyS[yypt-3 : yypt+1]
-		//line parser.go.y:141
-		{
-			yyVAL.expr = &ast.BinOpExpr{Lhs: yyDollar[1].expr, Operator: ">", Rhs: yyDollar[3].expr}
-		}
-	case 23:
-		yyDollar = yyS[yypt-3 : yypt+1]
-		//line parser.go.y:145
-		{
-			yyVAL.expr = &ast.BinOpExpr{Lhs: yyDollar[1].expr, Operator: ">=", Rhs: yyDollar[3].expr}
-		}
-	case 24:
-		yyDollar = yyS[yypt-3 : yypt+1]
-		//line parser.go.y:149
-		{
-			yyVAL.expr = &ast.BinOpExpr{Lhs: yyDollar[1].expr, Operator: "<", Rhs: yyDollar[3].expr}
-		}
-	case 25:
-		yyDollar = yyS[yypt-3 : yypt+1]
-		//line parser.go.y:153
-		{
-			yyVAL.expr = &ast.BinOpExpr{Lhs: yyDollar[1].expr, Operator: "<=", Rhs: yyDollar[3].expr}
-		}
-	case 26:
-		yyDollar = yyS[yypt-3 : yypt+1]
-		//line parser.go.y:157
-		{
-			yyVAL.expr = &ast.BinOpExpr{Lhs: yyDollar[1].expr, Operator: "|", Rhs: yyDollar[3].expr}
-		}
-	case 27:
-		yyDollar = yyS[yypt-3 : yypt+1]
-		//line parser.go.y:161
-		{
-			yyVAL.expr = &ast.BinOpExpr{Lhs: yyDollar[1].expr, Operator: "||", Rhs: yyDollar[3].expr}
-		}
-	case 28:
-		yyDollar = yyS[yypt-3 : yypt+1]
-		//line parser.go.y:165
-		{
-			yyVAL.expr = &ast.BinOpExpr{Lhs: yyDollar[1].expr, Operator: "&", Rhs: yyDollar[3].expr}
-		}
-	case 29:
-		yyDollar = yyS[yypt-3 : yypt+1]
-		//line parser.go.y:169
-		{
-			yyVAL.expr = &ast.BinOpExpr{Lhs: yyDollar[1].expr, Operator: "&&", Rhs: yyDollar[3].expr}
-		}
-	case 32:
-		yyDollar = yyS[yypt-1 : yypt+1]
-		//line parser.go.y:179
-		{
-		}
-	case 33:
-		yyDollar = yyS[yypt-2 : yypt+1]
-		//line parser.go.y:182
-		{
-		}
-	case 34:
-		yyDollar = yyS[yypt-1 : yypt+1]
-		//line parser.go.y:187
-		{
-		}
-	case 35:
-		yyDollar = yyS[yypt-1 : yypt+1]
-		//line parser.go.y:190
-		{
-		}
-	}
-	goto yystack /* stack new state and value */
-}

vendor/github.com/mattn/kinako/parser/parser.go.y

@@ -1,195 +0,0 @@
-%{
-package parser
-
-import (
-	"github.com/mattn/kinako/ast"
-)
-
-%}
-
-%type<compstmt> compstmt
-%type<stmts> stmts
-%type<stmt> stmt
-%type<expr> expr
-
-%union{
-	compstmt               []ast.Stmt
-	stmts                  []ast.Stmt
-	stmt                   ast.Stmt
-	expr                   ast.Expr
-	tok                    ast.Token
-	term                   ast.Token
-	terms                  ast.Token
-	opt_terms              ast.Token
-}
-
-%token<tok> IDENT NUMBER STRING EQEQ NEQ GE LE OROR ANDAND POW
-
-%right '='
-%right '?' ':'
-%left OROR
-%left ANDAND
-%left IDENT
-%nonassoc EQEQ NEQ ','
-%left '>' GE '<' LE SHIFTLEFT SHIFTRIGHT
-
-%left '+' '-' PLUSPLUS MINUSMINUS
-%left '*' '/' '%'
-%right UNARY
-
-%%
-
-compstmt : opt_terms
-	{
-		$$ = nil
-	}
-	| stmts opt_terms
-	{
-		$$ = $1
-	}
-
-stmts :
-	opt_terms stmt
-	{
-		$$ = []ast.Stmt{$2}
-		if l, ok := yylex.(*Lexer); ok {
-			l.stmts = $$
-		}
-	}
-	| stmts terms stmt
-	{
-		if $3 != nil {
-			$$ = append($1, $3)
-			if l, ok := yylex.(*Lexer); ok {
-				l.stmts = $$
-			}
-		}
-	}
-
-stmt :
-	expr '=' expr
-	{
-		$$ = &ast.LetStmt{Lhs: $1, Operator: "=", Rhs: $3}
-	}
-	| expr
-	{
-		$$ = &ast.ExprStmt{Expr: $1}
-	}
-
-expr :
-	IDENT
-	{
-		$$ = &ast.IdentExpr{Lit: $1.Lit}
-	}
-	| NUMBER
-	{
-		$$ = &ast.NumberExpr{Lit: $1.Lit}
-	}
-	| '-' expr %prec UNARY
-	{
-		$$ = &ast.UnaryExpr{Operator: "-", Expr: $2}
-	}
-	| '!' expr %prec UNARY
-	{
-		$$ = &ast.UnaryExpr{Operator: "!", Expr: $2}
-	}
-	| '^' expr %prec UNARY
-	{
-		$$ = &ast.UnaryExpr{Operator: "^", Expr: $2}
-	}
-	| STRING
-	{
-		$$ = &ast.StringExpr{Lit: $1.Lit}
-	}
-	| expr '?' expr ':' expr
-	{
-		$$ = &ast.TernaryOpExpr{Expr: $1, Lhs: $3, Rhs: $5}
-	}
-	| '(' expr ')'
-	{
-		$$ = &ast.ParenExpr{SubExpr: $2}
-	}
-	| expr '+' expr
-	{
-		$$ = &ast.BinOpExpr{Lhs: $1, Operator: "+", Rhs: $3}
-	}
-	| expr '-' expr
-	{
-		$$ = &ast.BinOpExpr{Lhs: $1, Operator: "-", Rhs: $3}
-	}
-	| expr '*' expr
-	{
-		$$ = &ast.BinOpExpr{Lhs: $1, Operator: "*", Rhs: $3}
-	}
-	| expr '/' expr
-	{
-		$$ = &ast.BinOpExpr{Lhs: $1, Operator: "/", Rhs: $3}
-	}
-	| expr '%' expr
-	{
-		$$ = &ast.BinOpExpr{Lhs: $1, Operator: "%", Rhs: $3}
-	}
-	| expr EQEQ expr
-	{
-		$$ = &ast.BinOpExpr{Lhs: $1, Operator: "==", Rhs: $3}
-	}
-	| expr NEQ expr
-	{
-		$$ = &ast.BinOpExpr{Lhs: $1, Operator: "!=", Rhs: $3}
-	}
-	| expr '>' expr
-	{
-		$$ = &ast.BinOpExpr{Lhs: $1, Operator: ">", Rhs: $3}
-	}
-	| expr GE expr
-	{
-		$$ = &ast.BinOpExpr{Lhs: $1, Operator: ">=", Rhs: $3}
-	}
-	| expr '<' expr
-	{
-		$$ = &ast.BinOpExpr{Lhs: $1, Operator: "<", Rhs: $3}
-	}
-	| expr LE expr
-	{
-		$$ = &ast.BinOpExpr{Lhs: $1, Operator: "<=", Rhs: $3}
-	}
-	| expr '|' expr
-	{
-		$$ = &ast.BinOpExpr{Lhs: $1, Operator: "|", Rhs: $3}
-	}
-	| expr OROR expr
-	{
-		$$ = &ast.BinOpExpr{Lhs: $1, Operator: "||", Rhs: $3}
-	}
-	| expr '&' expr
-	{
-		$$ = &ast.BinOpExpr{Lhs: $1, Operator: "&", Rhs: $3}
-	}
-	| expr ANDAND expr
-	{
-		$$ = &ast.BinOpExpr{Lhs: $1, Operator: "&&", Rhs: $3}
-	}
-
-opt_terms : /* none */
-	| terms
-	;
-
-
-terms : term
-	{
-	}
-	| terms term
-	{
-	}
-	;
-
-term : ';'
-	{
-	}
-	| '\n'
-	{
-	}
-	;
-
-%%
-

vendor/github.com/mattn/kinako/vm/env.go

@@ -1,258 +0,0 @@
-package vm
-
-import (
-	"fmt"
-	"reflect"
-	"strings"
-	"sync"
-
-	"github.com/mattn/kinako/parser"
-)
-
-// Env provides interface to run VM. This mean function scope and blocked-scope.
-// If stack goes to blocked-scope, it will make new Env.
-type Env struct {
-	name      string
-	env       map[string]reflect.Value
-	typ       map[string]reflect.Type
-	parent    *Env
-	interrupt *bool
-	sync.RWMutex
-}
-
-// NewEnv creates new global scope.
-func NewEnv() *Env {
-	b := false
-
-	return &Env{
-		env:       make(map[string]reflect.Value),
-		typ:       make(map[string]reflect.Type),
-		parent:    nil,
-		interrupt: &b,
-	}
-}
-
-// NewEnv creates new child scope.
-func (e *Env) NewEnv() *Env {
-	return &Env{
-		env:       make(map[string]reflect.Value),
-		typ:       make(map[string]reflect.Type),
-		parent:    e,
-		name:      e.name,
-		interrupt: e.interrupt,
-	}
-}
-
-func NewPackage(n string) *Env {
-	b := false
-
-	return &Env{
-		env:       make(map[string]reflect.Value),
-		typ:       make(map[string]reflect.Type),
-		parent:    nil,
-		name:      n,
-		interrupt: &b,
-	}
-}
-
-func (e *Env) NewPackage(n string) *Env {
-	return &Env{
-		env:       make(map[string]reflect.Value),
-		typ:       make(map[string]reflect.Type),
-		parent:    e,
-		name:      n,
-		interrupt: e.interrupt,
-	}
-}
-
-// Destroy deletes current scope.
-func (e *Env) Destroy() {
-	e.Lock()
-	defer e.Unlock()
-
-	if e.parent == nil {
-		return
-	}
-	for k, v := range e.parent.env {
-		if v.IsValid() && v.Interface() == e {
-			delete(e.parent.env, k)
-		}
-	}
-	e.parent = nil
-	e.env = nil
-}
-
-// NewModule creates new module scope as global.
-func (e *Env) NewModule(n string) *Env {
-	m := &Env{
-		env:    make(map[string]reflect.Value),
-		parent: e,
-		name:   n,
-	}
-	e.Define(n, m)
-	return m
-}
-
-// SetName sets a name of the scope. This means that the scope is module.
-func (e *Env) SetName(n string) {
-	e.Lock()
-	e.name = n
-	e.Unlock()
-}
-
-// GetName returns module name.
-func (e *Env) GetName() string {
-	e.RLock()
-	defer e.RUnlock()
-
-	return e.name
-}
-
-// Addr returns pointer value which specified symbol. It goes to upper scope until
-// found or returns error.
-func (e *Env) Addr(k string) (reflect.Value, error) {
-	e.RLock()
-	defer e.RUnlock()
-
-	if v, ok := e.env[k]; ok {
-		return v.Addr(), nil
-	}
-	if e.parent == nil {
-		return NilValue, fmt.Errorf("Undefined symbol '%s'", k)
-	}
-	return e.parent.Addr(k)
-}
-
-// Type returns type which specified symbol. It goes to upper scope until
-// found or returns error.
-func (e *Env) Type(k string) (reflect.Type, error) {
-	e.RLock()
-	defer e.RUnlock()
-
-	if v, ok := e.typ[k]; ok {
-		return v, nil
-	}
-	if e.parent == nil {
-		return NilType, fmt.Errorf("Undefined type '%s'", k)
-	}
-	return e.parent.Type(k)
-}
-
-// Get returns value which specified symbol. It goes to upper scope until
-// found or returns error.
-func (e *Env) Get(k string) (reflect.Value, error) {
-	e.RLock()
-	defer e.RUnlock()
-
-	if v, ok := e.env[k]; ok {
-		return v, nil
-	}
-	if e.parent == nil {
-		return NilValue, fmt.Errorf("Undefined symbol '%s'", k)
-	}
-	return e.parent.Get(k)
-}
-
-// Set modifies value which specified as symbol. It goes to upper scope until
-// found or returns error.
-func (e *Env) Set(k string, v interface{}) error {
-	e.Lock()
-	defer e.Unlock()
-
-	if _, ok := e.env[k]; ok {
-		val, ok := v.(reflect.Value)
-		if !ok {
-			val = reflect.ValueOf(v)
-		}
-		e.env[k] = val
-		return nil
-	}
-	if e.parent == nil {
-		return fmt.Errorf("Unknown symbol '%s'", k)
-	}
-	return e.parent.Set(k, v)
-}
-
-// DefineGlobal defines symbol in global scope.
-func (e *Env) DefineGlobal(k string, v interface{}) error {
-	if e.parent == nil {
-		return e.Define(k, v)
-	}
-	return e.parent.DefineGlobal(k, v)
-}
-
-// DefineType defines type which specifis symbol in global scope.
-func (e *Env) DefineType(k string, t interface{}) error {
-	if strings.Contains(k, ".") {
-		return fmt.Errorf("Unknown symbol '%s'", k)
-	}
-	global := e
-	keys := []string{k}
-
-	e.RLock()
-	for global.parent != nil {
-		if global.name != "" {
-			keys = append(keys, global.name)
-		}
-		global = global.parent
-	}
-	e.RUnlock()
-
-	for i, j := 0, len(keys)-1; i < j; i, j = i+1, j-1 {
-		keys[i], keys[j] = keys[j], keys[i]
-	}
-
-	typ, ok := t.(reflect.Type)
-	if !ok {
-		typ = reflect.TypeOf(t)
-	}
-
-	global.Lock()
-	global.typ[strings.Join(keys, ".")] = typ
-	global.Unlock()
-
-	return nil
-}
-
-// Define defines symbol in current scope.
-func (e *Env) Define(k string, v interface{}) error {
-	if strings.Contains(k, ".") {
-		return fmt.Errorf("Unknown symbol '%s'", k)
-	}
-	val, ok := v.(reflect.Value)
-	if !ok {
-		val = reflect.ValueOf(v)
-	}
-
-	e.Lock()
-	e.env[k] = val
-	e.Unlock()
-
-	return nil
-}
-
-// String return the name of current scope.
-func (e *Env) String() string {
-	e.RLock()
-	defer e.RUnlock()
-
-	return e.name
-}
-
-// Dump show symbol values in the scope.
-func (e *Env) Dump() {
-	e.RLock()
-	for k, v := range e.env {
-		fmt.Printf("%v = %#v\n", k, v)
-	}
-	e.RUnlock()
-}
-
-// Execute parses and runs source in current scope.
-func (e *Env) Execute(src string) (reflect.Value, error) {
-	stmts, err := parser.ParseSrc(src)
-	if err != nil {
-		return NilValue, err
-	}
-	return Run(stmts, e)
-}

vendor/github.com/mattn/kinako/vm/vm.go

@@ -1,409 +0,0 @@
-package vm
-
-import (
-	"errors"
-	"fmt"
-	"math"
-	"reflect"
-	"strconv"
-	"strings"
-
-	"github.com/mattn/kinako/ast"
-)
-
-var (
-	NilValue   = reflect.ValueOf((*interface{})(nil))
-	NilType    = reflect.TypeOf((*interface{})(nil))
-	TrueValue  = reflect.ValueOf(true)
-	FalseValue = reflect.ValueOf(false)
-)
-
-// Error provides a convenient interface for handling runtime error.
-// It can be Error interface with type cast which can call Pos().
-type Error struct {
-	Message string
-}
-
-var (
-	BreakError     = errors.New("Unexpected break statement")
-	ContinueError  = errors.New("Unexpected continue statement")
-	ReturnError    = errors.New("Unexpected return statement")
-	InterruptError = errors.New("Execution interrupted")
-)
-
-// Error returns the error message.
-func (e *Error) Error() string {
-	return e.Message
-}
-
-// Func is function interface to reflect functions internaly.
-type Func func(args ...reflect.Value) (reflect.Value, error)
-
-func (f Func) String() string {
-	return fmt.Sprintf("[Func: %p]", f)
-}
-
-func ToFunc(f Func) reflect.Value {
-	return reflect.ValueOf(f)
-}
-
-// Run executes statements in the specified environment.
-func Run(stmts []ast.Stmt, env *Env) (reflect.Value, error) {
-	rv := NilValue
-	var err error
-	for _, stmt := range stmts {
-		rv, err = RunSingleStmt(stmt, env)
-		if err != nil {
-			return rv, err
-		}
-	}
-	return rv, nil
-}
-
-// Interrupts the execution of any running statements in the specified environment.
-//
-// Note that the execution is not instantly aborted: after a call to Interrupt,
-// the current running statement will finish, but the next statement will not run,
-// and instead will return a NilValue and an InterruptError.
-func Interrupt(env *Env) {
-	env.Lock()
-	*(env.interrupt) = true
-	env.Unlock()
-}
-
-// RunSingleStmt executes one statement in the specified environment.
-func RunSingleStmt(stmt ast.Stmt, env *Env) (reflect.Value, error) {
-	env.Lock()
-	if *(env.interrupt) {
-		*(env.interrupt) = false
-		env.Unlock()
-
-		return NilValue, InterruptError
-	}
-	env.Unlock()
-
-	switch stmt := stmt.(type) {
-	case *ast.ExprStmt:
-		rv, err := invokeExpr(stmt.Expr, env)
-		if err != nil {
-			return rv, err
-		}
-		return rv, nil
-	case *ast.LetStmt:
-		rv := NilValue
-		var err error
-		rv, err = invokeExpr(stmt.Rhs, env)
-		if err != nil {
-			return rv, err
-		}
-		_, err = invokeLetExpr(stmt.Lhs, rv, env)
-		if err != nil {
-			return rv, err
-		}
-		return rv, nil
-	default:
-		return NilValue, errors.New("unknown statement")
-	}
-}
-
-// toString converts all reflect.Value-s into string.
-func toString(v reflect.Value) string {
-	if v.Kind() == reflect.Interface {
-		v = v.Elem()
-	}
-	if v.Kind() == reflect.String {
-		return v.String()
-	}
-	if !v.IsValid() {
-		return "nil"
-	}
-	return fmt.Sprint(v.Interface())
-}
-
-// toBool converts all reflect.Value-s into bool.
-func toBool(v reflect.Value) bool {
-	if v.Kind() == reflect.Interface {
-		v = v.Elem()
-	}
-
-	switch v.Kind() {
-	case reflect.Float32, reflect.Float64:
-		return v.Float() != 0.0
-	case reflect.Int, reflect.Int32, reflect.Int64:
-		return v.Int() != 0
-	case reflect.Bool:
-		return v.Bool()
-	case reflect.String:
-		if v.String() == "true" {
-			return true
-		}
-		if toInt64(v) != 0 {
-			return true
-		}
-	}
-	return false
-}
-
-// toFloat64 converts all reflect.Value-s into float64.
-func toFloat64(v reflect.Value) float64 {
-	if v.Kind() == reflect.Interface {
-		v = v.Elem()
-	}
-	switch v.Kind() {
-	case reflect.Float32, reflect.Float64:
-		return v.Float()
-	case reflect.Int, reflect.Int32, reflect.Int64:
-		return float64(v.Int())
-	}
-	return 0.0
-}
-
-func isNil(v reflect.Value) bool {
-	if !v.IsValid() || v.Kind().String() == "unsafe.Pointer" {
-		return true
-	}
-	if (v.Kind() == reflect.Interface || v.Kind() == reflect.Ptr) && v.IsNil() {
-		return true
-	}
-	return false
-}
-
-func isNum(v reflect.Value) bool {
-	switch v.Kind() {
-	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr, reflect.Float32, reflect.Float64:
-		return true
-	}
-	return false
-}
-
-// equal returns true when lhsV and rhsV is same value.
-func equal(lhsV, rhsV reflect.Value) bool {
-	lhsIsNil, rhsIsNil := isNil(lhsV), isNil(rhsV)
-	if lhsIsNil && rhsIsNil {
-		return true
-	}
-	if (!lhsIsNil && rhsIsNil) || (lhsIsNil && !rhsIsNil) {
-		return false
-	}
-	if lhsV.Kind() == reflect.Interface || lhsV.Kind() == reflect.Ptr {
-		lhsV = lhsV.Elem()
-	}
-	if rhsV.Kind() == reflect.Interface || rhsV.Kind() == reflect.Ptr {
-		rhsV = rhsV.Elem()
-	}
-	if !lhsV.IsValid() || !rhsV.IsValid() {
-		return true
-	}
-	if isNum(lhsV) && isNum(rhsV) {
-		if rhsV.Type().ConvertibleTo(lhsV.Type()) {
-			rhsV = rhsV.Convert(lhsV.Type())
-		}
-	}
-	if lhsV.CanInterface() && rhsV.CanInterface() {
-		return reflect.DeepEqual(lhsV.Interface(), rhsV.Interface())
-	}
-	return reflect.DeepEqual(lhsV, rhsV)
-}
-
-// toInt64 converts all reflect.Value-s into int64.
-func toInt64(v reflect.Value) int64 {
-	if v.Kind() == reflect.Interface {
-		v = v.Elem()
-	}
-	switch v.Kind() {
-	case reflect.Float32, reflect.Float64:
-		return int64(v.Float())
-	case reflect.Int, reflect.Int32, reflect.Int64:
-		return v.Int()
-	case reflect.String:
-		s := v.String()
-		var i int64
-		var err error
-		if strings.HasPrefix(s, "0x") {
-			i, err = strconv.ParseInt(s, 16, 64)
-		} else {
-			i, err = strconv.ParseInt(s, 10, 64)
-		}
-		if err == nil {
-			return int64(i)
-		}
-	}
-	return 0
-}
-
-func invokeLetExpr(expr ast.Expr, rv reflect.Value, env *Env) (reflect.Value, error) {
-	switch lhs := expr.(type) {
-	case *ast.IdentExpr:
-		if env.Set(lhs.Lit, rv) != nil {
-			if strings.Contains(lhs.Lit, ".") {
-				return NilValue, fmt.Errorf("Undefined symbol '%s'", lhs.Lit)
-			}
-			env.Define(lhs.Lit, rv)
-		}
-		return rv, nil
-	}
-	return NilValue, errors.New("Invalid operation")
-}
-
-// invokeExpr evaluates one expression.
-func invokeExpr(expr ast.Expr, env *Env) (reflect.Value, error) {
-	switch e := expr.(type) {
-	case *ast.NumberExpr:
-		if strings.Contains(e.Lit, ".") || strings.Contains(e.Lit, "e") {
-			v, err := strconv.ParseFloat(e.Lit, 64)
-			if err != nil {
-				return NilValue, err
-			}
-			return reflect.ValueOf(float64(v)), nil
-		}
-		var i int64
-		var err error
-		if strings.HasPrefix(e.Lit, "0x") {
-			i, err = strconv.ParseInt(e.Lit[2:], 16, 64)
-		} else {
-			i, err = strconv.ParseInt(e.Lit, 10, 64)
-		}
-		if err != nil {
-			return NilValue, err
-		}
-		return reflect.ValueOf(i), nil
-	case *ast.IdentExpr:
-		return env.Get(e.Lit)
-	case *ast.StringExpr:
-		return reflect.ValueOf(e.Lit), nil
-	case *ast.UnaryExpr:
-		v, err := invokeExpr(e.Expr, env)
-		if err != nil {
-			return v, err
-		}
-		switch e.Operator {
-		case "-":
-			if v.Kind() == reflect.Float64 {
-				return reflect.ValueOf(-v.Float()), nil
-			}
-			return reflect.ValueOf(-v.Int()), nil
-		case "^":
-			return reflect.ValueOf(^toInt64(v)), nil
-		case "!":
-			return reflect.ValueOf(!toBool(v)), nil
-		default:
-			return NilValue, errors.New("Unknown operator ''")
-		}
-	case *ast.ParenExpr:
-		v, err := invokeExpr(e.SubExpr, env)
-		if err != nil {
-			return v, err
-		}
-		return v, nil
-	case *ast.BinOpExpr:
-		lhsV := NilValue
-		rhsV := NilValue
-		var err error
-
-		lhsV, err = invokeExpr(e.Lhs, env)
-		if err != nil {
-			return lhsV, err
-		}
-		if lhsV.Kind() == reflect.Interface {
-			lhsV = lhsV.Elem()
-		}
-		if e.Rhs != nil {
-			rhsV, err = invokeExpr(e.Rhs, env)
-			if err != nil {
-				return rhsV, err
-			}
-			if rhsV.Kind() == reflect.Interface {
-				rhsV = rhsV.Elem()
-			}
-		}
-		switch e.Operator {
-		case "+":
-			if lhsV.Kind() == reflect.String || rhsV.Kind() == reflect.String {
-				return reflect.ValueOf(toString(lhsV) + toString(rhsV)), nil
-			}
-			if (lhsV.Kind() == reflect.Array || lhsV.Kind() == reflect.Slice) && (rhsV.Kind() != reflect.Array && rhsV.Kind() != reflect.Slice) {
-				return reflect.Append(lhsV, rhsV), nil
-			}
-			if (lhsV.Kind() == reflect.Array || lhsV.Kind() == reflect.Slice) && (rhsV.Kind() == reflect.Array || rhsV.Kind() == reflect.Slice) {
-				return reflect.AppendSlice(lhsV, rhsV), nil
-			}
-			if lhsV.Kind() == reflect.Float64 || rhsV.Kind() == reflect.Float64 {
-				return reflect.ValueOf(toFloat64(lhsV) + toFloat64(rhsV)), nil
-			}
-			return reflect.ValueOf(toInt64(lhsV) + toInt64(rhsV)), nil
-		case "-":
-			if lhsV.Kind() == reflect.Float64 || rhsV.Kind() == reflect.Float64 {
-				return reflect.ValueOf(toFloat64(lhsV) - toFloat64(rhsV)), nil
-			}
-			return reflect.ValueOf(toInt64(lhsV) - toInt64(rhsV)), nil
-		case "*":
-			if lhsV.Kind() == reflect.String && (rhsV.Kind() == reflect.Int || rhsV.Kind() == reflect.Int32 || rhsV.Kind() == reflect.Int64) {
-				return reflect.ValueOf(strings.Repeat(toString(lhsV), int(toInt64(rhsV)))), nil
-			}
-			if lhsV.Kind() == reflect.Float64 || rhsV.Kind() == reflect.Float64 {
-				return reflect.ValueOf(toFloat64(lhsV) * toFloat64(rhsV)), nil
-			}
-			return reflect.ValueOf(toInt64(lhsV) * toInt64(rhsV)), nil
-		case "/":
-			return reflect.ValueOf(toFloat64(lhsV) / toFloat64(rhsV)), nil
-		case "%":
-			return reflect.ValueOf(toInt64(lhsV) % toInt64(rhsV)), nil
-		case "==":
-			return reflect.ValueOf(equal(lhsV, rhsV)), nil
-		case "!=":
-			return reflect.ValueOf(equal(lhsV, rhsV) == false), nil
-		case ">":
-			return reflect.ValueOf(toFloat64(lhsV) > toFloat64(rhsV)), nil
-		case ">=":
-			return reflect.ValueOf(toFloat64(lhsV) >= toFloat64(rhsV)), nil
-		case "<":
-			return reflect.ValueOf(toFloat64(lhsV) < toFloat64(rhsV)), nil
-		case "<=":
-			return reflect.ValueOf(toFloat64(lhsV) <= toFloat64(rhsV)), nil
-		case "|":
-			return reflect.ValueOf(toInt64(lhsV) | toInt64(rhsV)), nil
-		case "||":
-			if toBool(lhsV) {
-				return lhsV, nil
-			}
-			return rhsV, nil
-		case "&":
-			return reflect.ValueOf(toInt64(lhsV) & toInt64(rhsV)), nil
-		case "&&":
-			if toBool(lhsV) {
-				return rhsV, nil
-			}
-			return lhsV, nil
-		case "**":
-			if lhsV.Kind() == reflect.Float64 {
-				return reflect.ValueOf(math.Pow(toFloat64(lhsV), toFloat64(rhsV))), nil
-			}
-			return reflect.ValueOf(int64(math.Pow(toFloat64(lhsV), toFloat64(rhsV)))), nil
-		case ">>":
-			return reflect.ValueOf(toInt64(lhsV) >> uint64(toInt64(rhsV))), nil
-		case "<<":
-			return reflect.ValueOf(toInt64(lhsV) << uint64(toInt64(rhsV))), nil
-		default:
-			return NilValue, errors.New("Unknown operator")
-		}
-	case *ast.TernaryOpExpr:
-		rv, err := invokeExpr(e.Expr, env)
-		if err != nil {
-			return rv, err
-		}
-		if toBool(rv) {
-			lhsV, err := invokeExpr(e.Lhs, env)
-			if err != nil {
-				return lhsV, err
-			}
-			return lhsV, nil
-		}
-		rhsV, err := invokeExpr(e.Rhs, env)
-		if err != nil {
-			return rhsV, err
-		}
-		return rhsV, nil
-	default:
-		return NilValue, errors.New("Unknown expression")
-	}
-}