params: release Geth 1.8.2 stable

* github: config for probot-stale bot

* github: use stale label, instead of wontfix

.dockerignore

@@ -0,0 +1,9 @@
+**/.git
+.git
+!.git/HEAD
+!.git/refs/heads
+**/*_test.go
+
+build/_workspace
+build/_bin
+tests/testdata

.github/CODEOWNERS

@@ -0,0 +1,11 @@
+# Lines starting with '#' are comments.
+# Each line is a file pattern followed by one or more owners.
+
+accounts/usbwallet @karalabe
+consensus          @karalabe
+core/              @karalabe @holiman
+eth/               @karalabe
+les/               @zsfelfoldi
+light/             @zsfelfoldi
+mobile/            @karalabe
+p2p/               @fjl @zsfelfoldi

.github/CONTRIBUTING.md

@@ -2,16 +2,14 @@
 
 Before you do a feature request please check and make sure that it isn't possible
 through some other means. The JavaScript enabled console is a powerful feature
-in the right hands. Please check our [Bitchin' tricks](https://github.com/ethereum/go-ethereum/wiki/bitchin-tricks) wiki page for more info
+in the right hands. Please check our [Wiki page](https://github.com/ethereum/go-ethereum/wiki) for more info
 and help.
 
 ## Contributing
 
 If you'd like to contribute to go-ethereum please fork, fix, commit and
 send a pull request. Commits which do not comply with the coding standards
-are ignored (use gofmt!). If you send pull requests make absolute sure that you
-commit on the `develop` branch and that you do not merge to master.
-Commits that are directly based on master are simply ignored.
+are ignored (use gofmt!).
 
 See [Developers' Guide](https://github.com/ethereum/go-ethereum/wiki/Developers'-Guide)
 for more details on configuring your environment, testing, and

.github/ISSUE_TEMPLATE.md

@@ -1,3 +1,9 @@
+Hi there,
+
+please note that this is an issue tracker reserved for bug reports and feature requests.
+
+For general questions please use the gitter channel or the Ethereum stack exchange at https://ethereum.stackexchange.com.
+
 #### System information
 
 Geth version: `geth version`

.github/stale.yml

@@ -0,0 +1,17 @@
+# Number of days of inactivity before an issue becomes stale
+daysUntilStale: 366
+# Number of days of inactivity before a stale issue is closed
+daysUntilClose: 42
+# Issues with these labels will never be considered stale
+exemptLabels:
+  - pinned
+  - security
+# Label to use when marking an issue as stale
+staleLabel: stale
+# Comment to post when marking an issue as stale. Set to `false` to disable
+markComment: >
+  This issue has been automatically marked as stale because it has not had
+  recent activity. It will be closed if no further activity occurs. Thank you
+  for your contributions.
+# Comment to post when closing a stale issue. Set to `false` to disable
+closeComment: false

.gitignore

@@ -13,8 +13,7 @@
 .ethtest
 */**/*tx_database*
 */**/*dapps*
-Godeps/_workspace/pkg
-Godeps/_workspace/bin
+build/_vendor/pkg
 
 #*
 .#*
@@ -31,3 +30,15 @@ Godeps/_workspace/bin
 # travis
 profile.tmp
 profile.cov
+
+# IdeaIDE
+.idea
+
+# VS Code
+.vscode
+
+# dashboard
+/dashboard/assets/flow-typed
+/dashboard/assets/node_modules
+/dashboard/assets/stats.json
+/dashboard/assets/bundle.js

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "tests"]
+	path = tests/testdata
+	url = https://github.com/ethereum/tests

.mailmap

@@ -17,6 +17,7 @@ Taylor Gerring <taylor.gerring@gmail.com> <taylor.gerring@ethereum.org>
 Bas van Kervel <bas@ethdev.com>
 Bas van Kervel <bas@ethdev.com> <basvankervel@ziggo.nl>
 Bas van Kervel <bas@ethdev.com> <basvankervel@gmail.com>
+Bas van Kervel <bas@ethdev.com> <bas-vk@users.noreply.github.com>
 
 Sven Ehlert <sven@ethdev.com>
 
@@ -62,4 +63,61 @@ Joseph Chow <ethereum@outlook.com> ethers <TODO>
 
 Enrique Fynn <enriquefynn@gmail.com>
 
-Vincent G <caktux@gmail.com>
+Vincent G <caktux@gmail.com>
+
+RJ Catalano <catalanor0220@gmail.com>
+RJ Catalano <catalanor0220@gmail.com> <rj@erisindustries.com>
+
+Nchinda Nchinda <nchinda2@gmail.com>
+
+Aron Fischer <github@aron.guru> <homotopycolimit@users.noreply.github.com>
+
+Vlad Gluhovsky <gluk256@users.noreply.github.com>
+
+Ville Sundell <github@solarius.fi>
+
+Elliot Shepherd <elliot@identitii.com>
+
+Yohann Léon <sybiload@gmail.com>
+
+Gregg Dourgarian <greggd@tempworks.com>
+
+Casey Detrio <cdetrio@gmail.com>
+
+Jens Agerberg <github@agerberg.me>
+
+Nick Johnson <arachnid@notdot.net>
+
+Henning Diedrich <hd@eonblast.com>
+Henning Diedrich <hd@eonblast.com> Drake Burroughs <wildfyre@hotmail.com>
+
+Felix Lange <fjl@twurst.com>
+Felix Lange <fjl@twurst.com> <fjl@users.noreply.github.com>
+
+Максим Чусовлянов <mchusovlianov@gmail.com>
+
+Louis Holbrook <dev@holbrook.no>
+Louis Holbrook <dev@holbrook.no> <nolash@users.noreply.github.com>
+
+Thomas Bocek <tom@tomp2p.net>
+
+Victor Tran <vu.tran54@gmail.com>
+
+Justin Drake <drakefjustin@gmail.com>
+
+Frank Wang <eternnoir@gmail.com>
+
+Gary Rong <garyrong0905@gmail.com>
+
+Guillaume Nicolas <guin56@gmail.com>
+
+Sorin Neacsu <sorin.neacsu@gmail.com>
+Sorin Neacsu <sorin.neacsu@gmail.com> <sorin@users.noreply.github.com>
+
+Valentin Wüstholz <wuestholz@gmail.com>
+Valentin Wüstholz <wuestholz@gmail.com> <wuestholz@users.noreply.github.com>
+
+Armin Braun <me@obrown.io>
+
+Ernesto del Toro <ernesto.deltoro@gmail.com>
+Ernesto del Toro <ernesto.deltoro@gmail.com> <ernestodeltoro@users.noreply.github.com>

.travis.yml

@@ -5,37 +5,190 @@ matrix:
   include:
     - os: linux
       dist: trusty
-      go: 1.4.2
-    - os: linux
-      dist: trusty
-      go: 1.5.4
-    - os: linux
-      dist: trusty
-      go: 1.6.2
-    - os: osx
-      go: 1.6.2
+      sudo: required
+      go: 1.8.x
+      script:
+        - sudo modprobe fuse
+        - sudo chmod 666 /dev/fuse
+        - sudo chown root:$USER /etc/fuse.conf
+        - go run build/ci.go install
+        - go run build/ci.go test -coverage
 
-    # This builder does the PPA upload (and nothing else).
+    # These are the latest Go versions.
     - os: linux
       dist: trusty
-      go: 1.6.2
-      env: PPA
+      sudo: required
+      go: 1.9.x
+      script:
+        - sudo modprobe fuse
+        - sudo chmod 666 /dev/fuse
+        - sudo chown root:$USER /etc/fuse.conf
+        - go run build/ci.go install
+        - go run build/ci.go test -coverage
+
+    - os: osx
+      go: 1.9.x
+      script:
+        - unset -f cd # workaround for https://github.com/travis-ci/travis-ci/issues/8703
+        - brew update
+        - brew install caskroom/cask/brew-cask
+        - brew cask install osxfuse
+        - go run build/ci.go install
+        - go run build/ci.go test -coverage
+
+    # This builder only tests code linters on latest version of Go
+    - os: linux
+      dist: trusty
+      go: 1.9.x
+      env:
+        - lint
+      git:
+        submodules: false # avoid cloning ethereum/tests
+      script:
+        - go run build/ci.go lint
+
+    # This builder does the Ubuntu PPA and Linux Azure uploads
+    - os: linux
+      dist: trusty
+      sudo: required
+      go: 1.9.x
+      env:
+        - ubuntu-ppa
+        - azure-linux
+      git:
+        submodules: false # avoid cloning ethereum/tests
       addons:
         apt:
           packages:
             - devscripts
             - debhelper
             - dput
+            - gcc-multilib
+            - fakeroot
       script:
-        - go run build/ci.go debsrc -signer "Felix Lange (Geth CI Testing Key) <fjl@twurst.com>" -upload ppa:lp-fjl/geth-ci-testing
+        # Build for the primary platforms that Trusty can manage
+        - go run build/ci.go debsrc -signer "Go Ethereum Linux Builder <geth-ci@ethereum.org>" -upload ppa:ethereum/ethereum
+        - go run build/ci.go install
+        - go run build/ci.go archive -type tar -signer LINUX_SIGNING_KEY -upload gethstore/builds
+        - go run build/ci.go install -arch 386
+        - go run build/ci.go archive -arch 386 -type tar -signer LINUX_SIGNING_KEY -upload gethstore/builds
 
-install:
-  - go get golang.org/x/tools/cmd/cover
-script:
-  - go run build/ci.go install
-  - go run build/ci.go test -coverage -vet
-after_success:
-  # - go run build/ci.go archive -type tar
+        # Switch over GCC to cross compilation (breaks 386, hence why do it here only)
+        - sudo -E apt-get -yq --no-install-suggests --no-install-recommends --force-yes install gcc-arm-linux-gnueabi libc6-dev-armel-cross gcc-arm-linux-gnueabihf libc6-dev-armhf-cross gcc-aarch64-linux-gnu libc6-dev-arm64-cross
+        - sudo ln -s /usr/include/asm-generic /usr/include/asm
+
+        - GOARM=5 go run build/ci.go install -arch arm -cc arm-linux-gnueabi-gcc
+        - GOARM=5 go run build/ci.go archive -arch arm -type tar -signer LINUX_SIGNING_KEY -upload gethstore/builds
+        - GOARM=6 go run build/ci.go install -arch arm -cc arm-linux-gnueabi-gcc
+        - GOARM=6 go run build/ci.go archive -arch arm -type tar -signer LINUX_SIGNING_KEY -upload gethstore/builds
+        - GOARM=7 go run build/ci.go install -arch arm -cc arm-linux-gnueabihf-gcc
+        - GOARM=7 go run build/ci.go archive -arch arm -type tar -signer LINUX_SIGNING_KEY -upload gethstore/builds
+        - go run build/ci.go install -arch arm64 -cc aarch64-linux-gnu-gcc
+        - go run build/ci.go archive -arch arm64 -type tar -signer LINUX_SIGNING_KEY -upload gethstore/builds
+
+    # This builder does the Linux Azure MIPS xgo uploads
+    - os: linux
+      dist: trusty
+      services:
+        - docker
+      go: 1.9.x
+      env:
+        - azure-linux-mips
+      git:
+        submodules: false # avoid cloning ethereum/tests
+      script:
+        - go run build/ci.go xgo --alltools -- --targets=linux/mips --ldflags '-extldflags "-static"' -v
+        - for bin in build/bin/*-linux-mips; do mv -f "${bin}" "${bin/-linux-mips/}"; done
+        - go run build/ci.go archive -arch mips -type tar -signer LINUX_SIGNING_KEY -upload gethstore/builds
+
+        - go run build/ci.go xgo --alltools -- --targets=linux/mipsle --ldflags '-extldflags "-static"' -v
+        - for bin in build/bin/*-linux-mipsle; do mv -f "${bin}" "${bin/-linux-mipsle/}"; done
+        - go run build/ci.go archive -arch mipsle -type tar -signer LINUX_SIGNING_KEY -upload gethstore/builds
+
+        - go run build/ci.go xgo --alltools -- --targets=linux/mips64 --ldflags '-extldflags "-static"' -v
+        - for bin in build/bin/*-linux-mips64; do mv -f "${bin}" "${bin/-linux-mips64/}"; done
+        - go run build/ci.go archive -arch mips64 -type tar -signer LINUX_SIGNING_KEY -upload gethstore/builds
+
+        - go run build/ci.go xgo --alltools -- --targets=linux/mips64le --ldflags '-extldflags "-static"' -v
+        - for bin in build/bin/*-linux-mips64le; do mv -f "${bin}" "${bin/-linux-mips64le/}"; done
+        - go run build/ci.go archive -arch mips64le -type tar -signer LINUX_SIGNING_KEY -upload gethstore/builds
+
+    # This builder does the Android Maven and Azure uploads
+    - os: linux
+      dist: precise # Needed for the android tools
+      addons:
+        apt:
+          packages:
+            - oracle-java8-installer
+            - oracle-java8-set-default
+      language: android
+      android:
+        components:
+          - platform-tools
+          - tools
+          - android-15
+          - android-19
+          - android-24
+      env:
+        - azure-android
+        - maven-android
+      git:
+        submodules: false # avoid cloning ethereum/tests
+      before_install:
+        - curl https://storage.googleapis.com/golang/go1.9.2.linux-amd64.tar.gz | tar -xz
+        - export PATH=`pwd`/go/bin:$PATH
+        - export GOROOT=`pwd`/go
+        - export GOPATH=$HOME/go
+      script:
+        # Build the Android archive and upload it to Maven Central and Azure
+        - curl https://dl.google.com/android/repository/android-ndk-r15c-linux-x86_64.zip -o android-ndk-r15c.zip
+        - unzip -q android-ndk-r15c.zip && rm android-ndk-r15c.zip
+        - mv android-ndk-r15c $HOME
+        - export ANDROID_NDK=$HOME/android-ndk-r15c
+
+        - mkdir -p $GOPATH/src/github.com/ethereum
+        - ln -s `pwd` $GOPATH/src/github.com/ethereum
+        - go run build/ci.go aar -signer ANDROID_SIGNING_KEY -deploy https://oss.sonatype.org -upload gethstore/builds
+
+    # This builder does the OSX Azure, iOS CocoaPods and iOS Azure uploads
+    - os: osx
+      go: 1.9.x
+      env:
+        - azure-osx
+        - azure-ios
+        - cocoapods-ios
+      git:
+        submodules: false # avoid cloning ethereum/tests
+      script:
+        - go run build/ci.go install
+        - go run build/ci.go archive -type tar -signer OSX_SIGNING_KEY -upload gethstore/builds
+
+        # Build the iOS framework and upload it to CocoaPods and Azure
+        - gem uninstall cocoapods -a -x
+        - gem install cocoapods
+
+        - mv ~/.cocoapods/repos/master ~/.cocoapods/repos/master.bak
+        - sed -i '.bak' 's/repo.join/!repo.join/g' $(dirname `gem which cocoapods`)/cocoapods/sources_manager.rb
+        - if [ "$TRAVIS_PULL_REQUEST" = "false" ]; then git clone --depth=1 https://github.com/CocoaPods/Specs.git ~/.cocoapods/repos/master && pod setup --verbose; fi
+
+        - xctool -version
+        - xcrun simctl list
+
+        # Workaround for https://github.com/golang/go/issues/23749
+        - export CGO_CFLAGS_ALLOW='-fmodules|-fblocks|-fobjc-arc'
+        - go run build/ci.go xcode -signer IOS_SIGNING_KEY -deploy trunk -upload gethstore/builds
+
+    # This builder does the Azure archive purges to avoid accumulating junk
+    - os: linux
+      dist: trusty
+      sudo: required
+      go: 1.9.x
+      env:
+        - azure-purge
+      git:
+        submodules: false # avoid cloning ethereum/tests
+      script:
+        - go run build/ci.go purge -store gethstore/builds -days 14
 
 notifications:
   webhooks:

AUTHORS

@@ -1,36 +1,173 @@
 # This is the official list of go-ethereum authors for copyright purposes.
 
+Afri Schoedon <5chdn@users.noreply.github.com>
+Agustin Armellini Fischer <armellini13@gmail.com>
+Airead <fgh1987168@gmail.com>
+Alan Chen <alanchchen@users.noreply.github.com>
+Alejandro Isaza <alejandro.isaza@gmail.com>
+Ales Katona <ales@coinbase.com>
 Alex Leverington <alex@ethdev.com>
+Alex Wu <wuyiding@gmail.com>
 Alexandre Van de Sande <alex.vandesande@ethdev.com>
+Ali Hajimirza <Ali92hm@users.noreply.github.com>
+Anton Evangelatov <anton.evangelatov@gmail.com>
+Arba Sasmoyo <arba.sasmoyo@gmail.com>
+Armani Ferrante <armaniferrante@berkeley.edu>
+Armin Braun <me@obrown.io>
+Aron Fischer <github@aron.guru>
 Bas van Kervel <bas@ethdev.com>
+Benjamin Brent <benjamin@benjaminbrent.com>
+Benoit Verkindt <benoit.verkindt@gmail.com>
+Bo <bohende@gmail.com>
+Bo Ye <boy.e.computer.1982@outlook.com>
+Bob Glickstein <bobg@users.noreply.github.com>
+Brian Schroeder <bts@gmail.com>
+Casey Detrio <cdetrio@gmail.com>
+Chase Wright <mysticryuujin@gmail.com>
 Christoph Jentzsch <jentzsch.software@gmail.com>
 Daniel A. Nagy <nagy.da@gmail.com>
-Drake Burroughs <wildfyre@hotmail.com>
+Daniel Sloof <goapsychadelic@gmail.com>
+Darrel Herbst <dherbst@gmail.com>
+Dave Appleton <calistralabs@gmail.com>
+Diego Siqueira <DiSiqueira@users.noreply.github.com>
+Dmitry Shulyak <yashulyak@gmail.com>
+Egon Elbre <egonelbre@gmail.com>
+Elias Naur <elias.naur@gmail.com>
+Elliot Shepherd <elliot@identitii.com>
 Enrique Fynn <enriquefynn@gmail.com>
+Ernesto del Toro <ernesto.deltoro@gmail.com>
 Ethan Buchman <ethan@coinculture.info>
+Eugene Valeyev <evgen.povt@gmail.com>
+Evangelos Pappas <epappas@evalonlabs.com>
+Evgeny Danilenko <6655321@bk.ru>
 Fabian Vogelsteller <fabian@frozeman.de>
+Fabio Barone <fabio.barone.co@gmail.com>
+Fabio Berger <fabioberger1991@gmail.com>
+FaceHo <facehoshi@gmail.com>
 Felix Lange <fjl@twurst.com>
+Fiisio <liangcszzu@163.com>
+Frank Wang <eternnoir@gmail.com>
+Furkan KAMACI <furkankamaci@gmail.com>
+Gary Rong <garyrong0905@gmail.com>
+George Ornbo <george@shapeshed.com>
+Gregg Dourgarian <greggd@tempworks.com>
+Guillaume Ballet <gballet@gmail.com>
+Guillaume Nicolas <guin56@gmail.com>
 Gustav Simonsson <gustav.simonsson@gmail.com>
+Hao Bryan Cheng <haobcheng@gmail.com>
+Henning Diedrich <hd@eonblast.com>
 Isidoro Ghezzi <isidoro.ghezzi@icloud.com>
+Ivan Daniluk <ivan.daniluk@gmail.com>
 Jae Kwon <jkwon.work@gmail.com>
+Jamie Pitts <james.pitts@gmail.com>
+Janoš Guljaš <janos@users.noreply.github.com>
 Jason Carver <jacarver@linkedin.com>
+Jay Guo <guojiannan1101@gmail.com>
 Jeff R. Allen <jra@nella.org>
 Jeffrey Wilcke <jeffrey@ethereum.org>
+Jens Agerberg <github@agerberg.me>
+Jia Chenhui <jiachenhui1989@gmail.com>
+Jim McDonald <Jim@mcdee.net>
+Joel Burget <joelburget@gmail.com>
+Jonathan Brown <jbrown@bluedroplet.com>
 Joseph Chow <ethereum@outlook.com>
+Justin Clark-Casey <justincc@justincc.org>
+Justin Drake <drakefjustin@gmail.com>
+Kenji Siu <kenji@isuntv.com>
 Kobi Gurkan <kobigurk@gmail.com>
+Konrad Feldmeier <konrad@brainbot.com>
+Kurkó Mihály <kurkomisi@users.noreply.github.com>
+Kyuntae Ethan Kim <ethan.kyuntae.kim@gmail.com>
 Lefteris Karapetsas <lefteris@refu.co>
 Leif Jurvetson <leijurv@gmail.com>
+Leo Shklovskii <leo@thermopylae.net>
+Lewis Marshall <lewis@lmars.net>
+Lio李欧 <lionello@users.noreply.github.com>
+Louis Holbrook <dev@holbrook.no>
+Luca Zeug <luclu@users.noreply.github.com>
+Magicking <s@6120.eu>
 Maran Hidskes <maran.hidskes@gmail.com>
 Marek Kotewicz <marek.kotewicz@gmail.com>
+Mark <markya0616@gmail.com>
+Martin Holst Swende <martin@swende.se>
+Matthew Di Ferrante <mattdf@users.noreply.github.com>
 Matthew Wampler-Doty <matthew.wampler.doty@gmail.com>
+Maximilian Meister <mmeister@suse.de>
+Micah Zoltu <micah@zoltu.net>
+Michael Ruminer <michael.ruminer+github@gmail.com>
+Miguel Mota <miguelmota2@gmail.com>
+Miya Chen <miyatlchen@gmail.com>
+Nchinda Nchinda <nchinda2@gmail.com>
 Nick Dodson <silentcicero@outlook.com>
+Nick Johnson <arachnid@notdot.net>
+Nicolas Guillaume <gunicolas@sqli.com>
+Noman <noman@noman.land>
+Oli Bye <olibye@users.noreply.github.com>
+Paul Litvak <litvakpol@012.net.il>
+Paulo L F Casaretto <pcasaretto@gmail.com>
+Paweł Bylica <chfast@gmail.com>
 Peter Pratscher <pratscher@gmail.com>
+Petr Mikusek <petr@mikusek.info>
 Péter Szilágyi <peterke@gmail.com>
+RJ Catalano <catalanor0220@gmail.com>
 Ramesh Nair <ram@hiddentao.com>
 Ricardo Catalinas Jiménez <r@untroubled.be>
+Ricardo Domingos <ricardohsd@gmail.com>
+Richard Hart <richardhart92@gmail.com>
+Rob <robert@rojotek.com>
+Robert Zaremba <robert.zaremba@scale-it.pl>
+Russ Cox <rsc@golang.org>
 Rémy Roy <remyroy@remyroy.com>
+S. Matthew English <s-matthew-english@users.noreply.github.com>
+Shintaro Kaneko <kaneshin0120@gmail.com>
+Sorin Neacsu <sorin.neacsu@gmail.com>
+Stein Dekker <dekker.stein@gmail.com>
+Steve Waldman <swaldman@mchange.com>
+Steven Roose <stevenroose@gmail.com>
 Taylor Gerring <taylor.gerring@gmail.com>
+Thomas Bocek <tom@tomp2p.net>
+Ti Zhou <tizhou1986@gmail.com>
+Tosh Camille <tochecamille@gmail.com>
+Valentin Wüstholz <wuestholz@gmail.com>
+Victor Farazdagi <simple.square@gmail.com>
+Victor Tran <vu.tran54@gmail.com>
 Viktor Trón <viktor.tron@gmail.com>
+Ville Sundell <github@solarius.fi>
 Vincent G <caktux@gmail.com>
 Vitalik Buterin <v@buterin.com>
+Vitaly V <vvelikodny@gmail.com>
+Vivek Anand <vivekanand1101@users.noreply.github.com>
+Vlad Gluhovsky <gluk256@users.noreply.github.com>
+Yohann Léon <sybiload@gmail.com>
+Yoichi Hirai <i@yoichihirai.com>
+Yondon Fu <yondon.fu@gmail.com>
+Zach <zach.ramsay@gmail.com>
+Zahoor Mohamed <zahoor@zahoor.in>
+Zoe Nolan <github@zoenolan.org>
 Zsolt Felföldi <zsfelfoldi@gmail.com>
+am2rican5 <am2rican5@gmail.com>
+ayeowch <ayeowch@gmail.com>
+b00ris <b00ris@mail.ru>
+bailantaotao <Edwin@maicoin.com>
+baizhenxuan <nkbai@163.com>
+bloonfield <bloonfield@163.com>
+changhong <changhong.yu@shanbay.com>
+evgk <evgeniy.kamyshev@gmail.com>
+ferhat elmas <elmas.ferhat@gmail.com>
+holisticode <holistic.computing@gmail.com>
+jtakalai <juuso.takalainen@streamr.com>
+ken10100147 <sunhongping@kanjian.com>
+ligi <ligi@ligi.de>
+mark.lin <mark@maicoin.com>
+necaremus <necaremus@gmail.com>
+njupt-moon <1015041018@njupt.edu.cn>
+nkbai <nkbai@163.com>
+rhaps107 <dod-source@yandex.ru>
+slumber1122 <slumber1122@gmail.com>
+sunxiaojun2014 <sunxiaojun-xy@360.cn>
+terasum <terasum@163.com>
+tsarpaul <Litvakpol@012.net.il>
+xiekeyang <xiekeyang@users.noreply.github.com>
+yoza <yoza.is12s@gmail.com>
+ΞTHΞЯSPHΞЯΞ <{viktor.tron,nagydani,zsfelfoldi}@gmail.com>
+Максим Чусовлянов <mchusovlianov@gmail.com>

Dockerfile

@@ -0,0 +1,16 @@
+# Build Geth in a stock Go builder container
+FROM golang:1.9-alpine as builder
+
+RUN apk add --no-cache make gcc musl-dev linux-headers
+
+ADD . /go-ethereum
+RUN cd /go-ethereum && make geth
+
+# Pull Geth into a second stage deploy alpine container
+FROM alpine:latest
+
+RUN apk add --no-cache ca-certificates
+COPY --from=builder /go-ethereum/build/bin/geth /usr/local/bin/
+
+EXPOSE 8545 8546 30303 30303/udp 30304/udp
+ENTRYPOINT ["geth"]

Dockerfile.alltools

@@ -0,0 +1,15 @@
+# Build Geth in a stock Go builder container
+FROM golang:1.9-alpine as builder
+
+RUN apk add --no-cache make gcc musl-dev linux-headers
+
+ADD . /go-ethereum
+RUN cd /go-ethereum && make all
+
+# Pull all binaries into a second stage deploy alpine container
+FROM alpine:latest
+
+RUN apk add --no-cache ca-certificates
+COPY --from=builder /go-ethereum/build/bin/* /usr/local/bin/
+
+EXPOSE 8545 8546 30303 30303/udp 30304/udp

Godeps/Godeps.json

@@ -1,329 +0,0 @@
-{
-	"ImportPath": "github.com/ethereum/go-ethereum",
-	"GoVersion": "go1.5.2",
-	"GodepVersion": "v74",
-	"Packages": [
-		"./..."
-	],
-	"Deps": [
-		{
-			"ImportPath": "github.com/Gustav-Simonsson/go-opencl/cl",
-			"Rev": "593e01cfc4f3353585015321e01951d4a907d3ef"
-		},
-		{
-			"ImportPath": "github.com/cespare/cp",
-			"Rev": "165db2f241fd235aec29ba6d9b1ccd5f1c14637c"
-		},
-		{
-			"ImportPath": "github.com/davecgh/go-spew/spew",
-			"Rev": "5215b55f46b2b919f50a1df0eaa5886afe4e3b3d"
-		},
-		{
-			"ImportPath": "github.com/ethereum/ethash",
-			"Comment": "v23.1-247-g2e80de5",
-			"Rev": "2e80de5022370cfe632195b1720db52d07ff8a77"
-		},
-		{
-			"ImportPath": "github.com/fatih/color",
-			"Comment": "v0.1-12-g9aae6aa",
-			"Rev": "9aae6aaa22315390f03959adca2c4d395b02fcef"
-		},
-		{
-			"ImportPath": "github.com/gizak/termui",
-			"Rev": "08a5d3f67b7d9ec87830ea39c48e570a1f18531f"
-		},
-		{
-			"ImportPath": "github.com/golang/snappy",
-			"Rev": "799c780093d646c1b79d30894e22512c319fa137"
-		},
-		{
-			"ImportPath": "github.com/hashicorp/golang-lru",
-			"Rev": "a0d98a5f288019575c6d1f4bb1573fef2d1fcdc4"
-		},
-		{
-			"ImportPath": "github.com/hashicorp/golang-lru/simplelru",
-			"Rev": "a0d98a5f288019575c6d1f4bb1573fef2d1fcdc4"
-		},
-		{
-			"ImportPath": "github.com/huin/goupnp",
-			"Rev": "46bde78b11f3f021f2a511df138be9e2fc7506e8"
-		},
-		{
-			"ImportPath": "github.com/huin/goupnp/dcps/internetgateway1",
-			"Rev": "46bde78b11f3f021f2a511df138be9e2fc7506e8"
-		},
-		{
-			"ImportPath": "github.com/huin/goupnp/dcps/internetgateway2",
-			"Rev": "46bde78b11f3f021f2a511df138be9e2fc7506e8"
-		},
-		{
-			"ImportPath": "github.com/huin/goupnp/httpu",
-			"Rev": "46bde78b11f3f021f2a511df138be9e2fc7506e8"
-		},
-		{
-			"ImportPath": "github.com/huin/goupnp/scpd",
-			"Rev": "46bde78b11f3f021f2a511df138be9e2fc7506e8"
-		},
-		{
-			"ImportPath": "github.com/huin/goupnp/soap",
-			"Rev": "46bde78b11f3f021f2a511df138be9e2fc7506e8"
-		},
-		{
-			"ImportPath": "github.com/huin/goupnp/ssdp",
-			"Rev": "46bde78b11f3f021f2a511df138be9e2fc7506e8"
-		},
-		{
-			"ImportPath": "github.com/jackpal/gateway",
-			"Rev": "192609c58b8985e645cbe82ddcb28a4362ca0fdc"
-		},
-		{
-			"ImportPath": "github.com/jackpal/go-nat-pmp",
-			"Rev": "46523a463303c6ede3ddfe45bde1c7ed52ebaacd"
-		},
-		{
-			"ImportPath": "github.com/mattn/go-colorable",
-			"Rev": "9fdad7c47650b7d2e1da50644c1f4ba7f172f252"
-		},
-		{
-			"ImportPath": "github.com/mattn/go-isatty",
-			"Rev": "56b76bdf51f7708750eac80fa38b952bb9f32639"
-		},
-		{
-			"ImportPath": "github.com/mattn/go-runewidth",
-			"Comment": "travisish-44-ge882a96",
-			"Rev": "e882a96ec18dd43fa283187b66af74497c9101c0"
-		},
-		{
-			"ImportPath": "github.com/microsoft/go-winio",
-			"Comment": "v0.2.0",
-			"Rev": "9e2895e5f6c3f16473b91d37fae6e89990a4520c"
-		},
-		{
-			"ImportPath": "github.com/nsf/termbox-go",
-			"Rev": "362329b0aa6447eadd52edd8d660ec1dff470295"
-		},
-		{
-			"ImportPath": "github.com/pborman/uuid",
-			"Comment": "v1.0-6-g0f1a469",
-			"Rev": "0f1a46960a86dcdf5dd30d3e6568a497a997909f"
-		},
-		{
-			"ImportPath": "github.com/peterh/liner",
-			"Rev": "ad1edfd30321d8f006ccf05f1e0524adeb943060"
-		},
-		{
-			"ImportPath": "github.com/rcrowley/go-metrics",
-			"Rev": "51425a2415d21afadfd55cd93432c0bc69e9598d"
-		},
-		{
-			"ImportPath": "github.com/rjeczalik/notify",
-			"Rev": "f627deca7a510d96f0ef9388f2d0e8b16d21f87f"
-		},
-		{
-			"ImportPath": "github.com/robertkrimen/otto",
-			"Rev": "53221230c215611a90762720c9042ac782ef74ee"
-		},
-		{
-			"ImportPath": "github.com/robertkrimen/otto/ast",
-			"Rev": "53221230c215611a90762720c9042ac782ef74ee"
-		},
-		{
-			"ImportPath": "github.com/robertkrimen/otto/dbg",
-			"Rev": "53221230c215611a90762720c9042ac782ef74ee"
-		},
-		{
-			"ImportPath": "github.com/robertkrimen/otto/file",
-			"Rev": "53221230c215611a90762720c9042ac782ef74ee"
-		},
-		{
-			"ImportPath": "github.com/robertkrimen/otto/parser",
-			"Rev": "53221230c215611a90762720c9042ac782ef74ee"
-		},
-		{
-			"ImportPath": "github.com/robertkrimen/otto/registry",
-			"Rev": "53221230c215611a90762720c9042ac782ef74ee"
-		},
-		{
-			"ImportPath": "github.com/robertkrimen/otto/token",
-			"Rev": "53221230c215611a90762720c9042ac782ef74ee"
-		},
-		{
-			"ImportPath": "github.com/rs/cors",
-			"Rev": "5950cf11d77f8a61b432a25dd4d444b4ced01379"
-		},
-		{
-			"ImportPath": "github.com/rs/xhandler",
-			"Rev": "d9d9599b6aaf6a058cb7b1f48291ded2cbd13390"
-		},
-		{
-			"ImportPath": "github.com/syndtr/goleveldb/leveldb",
-			"Rev": "917f41c560270110ceb73c5b38be2a9127387071"
-		},
-		{
-			"ImportPath": "github.com/syndtr/goleveldb/leveldb/cache",
-			"Rev": "917f41c560270110ceb73c5b38be2a9127387071"
-		},
-		{
-			"ImportPath": "github.com/syndtr/goleveldb/leveldb/comparer",
-			"Rev": "917f41c560270110ceb73c5b38be2a9127387071"
-		},
-		{
-			"ImportPath": "github.com/syndtr/goleveldb/leveldb/errors",
-			"Rev": "917f41c560270110ceb73c5b38be2a9127387071"
-		},
-		{
-			"ImportPath": "github.com/syndtr/goleveldb/leveldb/filter",
-			"Rev": "917f41c560270110ceb73c5b38be2a9127387071"
-		},
-		{
-			"ImportPath": "github.com/syndtr/goleveldb/leveldb/iterator",
-			"Rev": "917f41c560270110ceb73c5b38be2a9127387071"
-		},
-		{
-			"ImportPath": "github.com/syndtr/goleveldb/leveldb/journal",
-			"Rev": "917f41c560270110ceb73c5b38be2a9127387071"
-		},
-		{
-			"ImportPath": "github.com/syndtr/goleveldb/leveldb/memdb",
-			"Rev": "917f41c560270110ceb73c5b38be2a9127387071"
-		},
-		{
-			"ImportPath": "github.com/syndtr/goleveldb/leveldb/opt",
-			"Rev": "917f41c560270110ceb73c5b38be2a9127387071"
-		},
-		{
-			"ImportPath": "github.com/syndtr/goleveldb/leveldb/storage",
-			"Rev": "917f41c560270110ceb73c5b38be2a9127387071"
-		},
-		{
-			"ImportPath": "github.com/syndtr/goleveldb/leveldb/table",
-			"Rev": "917f41c560270110ceb73c5b38be2a9127387071"
-		},
-		{
-			"ImportPath": "github.com/syndtr/goleveldb/leveldb/util",
-			"Rev": "917f41c560270110ceb73c5b38be2a9127387071"
-		},
-		{
-			"ImportPath": "golang.org/x/crypto/pbkdf2",
-			"Rev": "1f22c0103821b9390939b6776727195525381532"
-		},
-		{
-			"ImportPath": "golang.org/x/crypto/ripemd160",
-			"Rev": "1f22c0103821b9390939b6776727195525381532"
-		},
-		{
-			"ImportPath": "golang.org/x/crypto/scrypt",
-			"Rev": "1f22c0103821b9390939b6776727195525381532"
-		},
-		{
-			"ImportPath": "golang.org/x/net/context",
-			"Rev": "8968c61983e8f51a91b8c0ef25bf739278c89634"
-		},
-		{
-			"ImportPath": "golang.org/x/net/html",
-			"Rev": "8968c61983e8f51a91b8c0ef25bf739278c89634"
-		},
-		{
-			"ImportPath": "golang.org/x/net/html/atom",
-			"Rev": "8968c61983e8f51a91b8c0ef25bf739278c89634"
-		},
-		{
-			"ImportPath": "golang.org/x/net/html/charset",
-			"Rev": "8968c61983e8f51a91b8c0ef25bf739278c89634"
-		},
-		{
-			"ImportPath": "golang.org/x/net/websocket",
-			"Rev": "8968c61983e8f51a91b8c0ef25bf739278c89634"
-		},
-		{
-			"ImportPath": "golang.org/x/sys/unix",
-			"Rev": "50c6bc5e4292a1d4e65c6e9be5f53be28bcbe28e"
-		},
-		{
-			"ImportPath": "golang.org/x/text/encoding",
-			"Rev": "09761194ac5034a97b2bfad4f5b896b0ac350b3e"
-		},
-		{
-			"ImportPath": "golang.org/x/text/encoding/charmap",
-			"Rev": "09761194ac5034a97b2bfad4f5b896b0ac350b3e"
-		},
-		{
-			"ImportPath": "golang.org/x/text/encoding/htmlindex",
-			"Rev": "09761194ac5034a97b2bfad4f5b896b0ac350b3e"
-		},
-		{
-			"ImportPath": "golang.org/x/text/encoding/internal",
-			"Rev": "09761194ac5034a97b2bfad4f5b896b0ac350b3e"
-		},
-		{
-			"ImportPath": "golang.org/x/text/encoding/internal/identifier",
-			"Rev": "09761194ac5034a97b2bfad4f5b896b0ac350b3e"
-		},
-		{
-			"ImportPath": "golang.org/x/text/encoding/japanese",
-			"Rev": "09761194ac5034a97b2bfad4f5b896b0ac350b3e"
-		},
-		{
-			"ImportPath": "golang.org/x/text/encoding/korean",
-			"Rev": "09761194ac5034a97b2bfad4f5b896b0ac350b3e"
-		},
-		{
-			"ImportPath": "golang.org/x/text/encoding/simplifiedchinese",
-			"Rev": "09761194ac5034a97b2bfad4f5b896b0ac350b3e"
-		},
-		{
-			"ImportPath": "golang.org/x/text/encoding/traditionalchinese",
-			"Rev": "09761194ac5034a97b2bfad4f5b896b0ac350b3e"
-		},
-		{
-			"ImportPath": "golang.org/x/text/encoding/unicode",
-			"Rev": "09761194ac5034a97b2bfad4f5b896b0ac350b3e"
-		},
-		{
-			"ImportPath": "golang.org/x/text/internal/tag",
-			"Rev": "09761194ac5034a97b2bfad4f5b896b0ac350b3e"
-		},
-		{
-			"ImportPath": "golang.org/x/text/internal/utf8internal",
-			"Rev": "09761194ac5034a97b2bfad4f5b896b0ac350b3e"
-		},
-		{
-			"ImportPath": "golang.org/x/text/language",
-			"Rev": "09761194ac5034a97b2bfad4f5b896b0ac350b3e"
-		},
-		{
-			"ImportPath": "golang.org/x/text/runes",
-			"Rev": "09761194ac5034a97b2bfad4f5b896b0ac350b3e"
-		},
-		{
-			"ImportPath": "golang.org/x/text/transform",
-			"Rev": "09761194ac5034a97b2bfad4f5b896b0ac350b3e"
-		},
-		{
-			"ImportPath": "golang.org/x/tools/go/ast/astutil",
-			"Rev": "758728c4b28cfbac299730969ef8f655c4761283"
-		},
-		{
-			"ImportPath": "golang.org/x/tools/imports",
-			"Rev": "758728c4b28cfbac299730969ef8f655c4761283"
-		},
-		{
-			"ImportPath": "gopkg.in/check.v1",
-			"Rev": "4f90aeace3a26ad7021961c297b22c42160c7b25"
-		},
-		{
-			"ImportPath": "gopkg.in/fatih/set.v0",
-			"Comment": "v0.1.0-3-g27c4092",
-			"Rev": "27c40922c40b43fe04554d8223a402af3ea333f3"
-		},
-		{
-			"ImportPath": "gopkg.in/karalabe/cookiejar.v2/collections/prque",
-			"Rev": "8dcd6a7f4951f6ff3ee9cbb919a06d8925822e57"
-		},
-		{
-			"ImportPath": "gopkg.in/urfave/cli.v1",
-			"Comment": "v1.17.0",
-			"Rev": "01857ac33766ce0c93856370626f9799281c14f4"
-		}
-	]
-}

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.

Godeps/_workspace/.gitignore

@@ -1,2 +0,0 @@
-/pkg
-/bin

Godeps/_workspace/src/github.com/Gustav-Simonsson/go-opencl/cl/cl.go

@@ -1,26 +0,0 @@
-/*
-Package cl provides a binding to the OpenCL api. It's mostly a low-level
-wrapper that avoids adding functionality while still making the interface
-a little more friendly and easy to use.
-
-Resource life-cycle management:
-
-For any CL object that gets created (buffer, queue, kernel, etc..) you should
-call object.Release() when finished with it to free the CL resources. This
-explicitely calls the related clXXXRelease method for the type. However,
-as a fallback there is a finalizer set for every resource item that takes
-care of it (eventually) if Release isn't called. In this way you can have
-better control over the life cycle of resources while having a fall back
-to avoid leaks. This is similar to how file handles and such are handled
-in the Go standard packages.
-*/
-package cl
-
-// #include "headers/1.2/opencl.h"
-// #cgo CFLAGS: -Iheaders/1.2
-// #cgo darwin LDFLAGS: -framework OpenCL
-// #cgo linux LDFLAGS: -lOpenCL
-import "C"
-import "errors"
-
-var ErrUnsupported = errors.New("cl: unsupported")

Godeps/_workspace/src/github.com/Gustav-Simonsson/go-opencl/cl/context.go

@@ -1,161 +0,0 @@
-package cl
-
-// #include <stdlib.h>
-// #ifdef __APPLE__
-// #include "OpenCL/opencl.h"
-// #else
-// #include "cl.h"
-// #endif
-import "C"
-
-import (
-	"runtime"
-	"unsafe"
-)
-
-const maxImageFormats = 256
-
-type Context struct {
-	clContext C.cl_context
-	devices   []*Device
-}
-
-type MemObject struct {
-	clMem C.cl_mem
-	size  int
-}
-
-func releaseContext(c *Context) {
-	if c.clContext != nil {
-		C.clReleaseContext(c.clContext)
-		c.clContext = nil
-	}
-}
-
-func releaseMemObject(b *MemObject) {
-	if b.clMem != nil {
-		C.clReleaseMemObject(b.clMem)
-		b.clMem = nil
-	}
-}
-
-func newMemObject(mo C.cl_mem, size int) *MemObject {
-	memObject := &MemObject{clMem: mo, size: size}
-	runtime.SetFinalizer(memObject, releaseMemObject)
-	return memObject
-}
-
-func (b *MemObject) Release() {
-	releaseMemObject(b)
-}
-
-// TODO: properties
-func CreateContext(devices []*Device) (*Context, error) {
-	deviceIds := buildDeviceIdList(devices)
-	var err C.cl_int
-	clContext := C.clCreateContext(nil, C.cl_uint(len(devices)), &deviceIds[0], nil, nil, &err)
-	if err != C.CL_SUCCESS {
-		return nil, toError(err)
-	}
-	if clContext == nil {
-		return nil, ErrUnknown
-	}
-	context := &Context{clContext: clContext, devices: devices}
-	runtime.SetFinalizer(context, releaseContext)
-	return context, nil
-}
-
-func (ctx *Context) GetSupportedImageFormats(flags MemFlag, imageType MemObjectType) ([]ImageFormat, error) {
-	var formats [maxImageFormats]C.cl_image_format
-	var nFormats C.cl_uint
-	if err := C.clGetSupportedImageFormats(ctx.clContext, C.cl_mem_flags(flags), C.cl_mem_object_type(imageType), maxImageFormats, &formats[0], &nFormats); err != C.CL_SUCCESS {
-		return nil, toError(err)
-	}
-	fmts := make([]ImageFormat, nFormats)
-	for i, f := range formats[:nFormats] {
-		fmts[i] = ImageFormat{
-			ChannelOrder:    ChannelOrder(f.image_channel_order),
-			ChannelDataType: ChannelDataType(f.image_channel_data_type),
-		}
-	}
-	return fmts, nil
-}
-
-func (ctx *Context) CreateCommandQueue(device *Device, properties CommandQueueProperty) (*CommandQueue, error) {
-	var err C.cl_int
-	clQueue := C.clCreateCommandQueue(ctx.clContext, device.id, C.cl_command_queue_properties(properties), &err)
-	if err != C.CL_SUCCESS {
-		return nil, toError(err)
-	}
-	if clQueue == nil {
-		return nil, ErrUnknown
-	}
-	commandQueue := &CommandQueue{clQueue: clQueue, device: device}
-	runtime.SetFinalizer(commandQueue, releaseCommandQueue)
-	return commandQueue, nil
-}
-
-func (ctx *Context) CreateProgramWithSource(sources []string) (*Program, error) {
-	cSources := make([]*C.char, len(sources))
-	for i, s := range sources {
-		cs := C.CString(s)
-		cSources[i] = cs
-		defer C.free(unsafe.Pointer(cs))
-	}
-	var err C.cl_int
-	clProgram := C.clCreateProgramWithSource(ctx.clContext, C.cl_uint(len(sources)), &cSources[0], nil, &err)
-	if err != C.CL_SUCCESS {
-		return nil, toError(err)
-	}
-	if clProgram == nil {
-		return nil, ErrUnknown
-	}
-	program := &Program{clProgram: clProgram, devices: ctx.devices}
-	runtime.SetFinalizer(program, releaseProgram)
-	return program, nil
-}
-
-func (ctx *Context) CreateBufferUnsafe(flags MemFlag, size int, dataPtr unsafe.Pointer) (*MemObject, error) {
-	var err C.cl_int
-	clBuffer := C.clCreateBuffer(ctx.clContext, C.cl_mem_flags(flags), C.size_t(size), dataPtr, &err)
-	if err != C.CL_SUCCESS {
-		return nil, toError(err)
-	}
-	if clBuffer == nil {
-		return nil, ErrUnknown
-	}
-	return newMemObject(clBuffer, size), nil
-}
-
-func (ctx *Context) CreateEmptyBuffer(flags MemFlag, size int) (*MemObject, error) {
-	return ctx.CreateBufferUnsafe(flags, size, nil)
-}
-
-func (ctx *Context) CreateEmptyBufferFloat32(flags MemFlag, size int) (*MemObject, error) {
-	return ctx.CreateBufferUnsafe(flags, 4*size, nil)
-}
-
-func (ctx *Context) CreateBuffer(flags MemFlag, data []byte) (*MemObject, error) {
-	return ctx.CreateBufferUnsafe(flags, len(data), unsafe.Pointer(&data[0]))
-}
-
-//float64
-func (ctx *Context) CreateBufferFloat32(flags MemFlag, data []float32) (*MemObject, error) {
-	return ctx.CreateBufferUnsafe(flags, 4*len(data), unsafe.Pointer(&data[0]))
-}
-
-func (ctx *Context) CreateUserEvent() (*Event, error) {
-	var err C.cl_int
-	clEvent := C.clCreateUserEvent(ctx.clContext, &err)
-	if err != C.CL_SUCCESS {
-		return nil, toError(err)
-	}
-	return newEvent(clEvent), nil
-}
-
-func (ctx *Context) Release() {
-	releaseContext(ctx)
-}
-
-// http://www.khronos.org/registry/cl/sdk/1.2/docs/man/xhtml/clCreateSubBuffer.html
-// func (memObject *MemObject) CreateSubBuffer(flags MemFlag, bufferCreateType BufferCreateType, )

Godeps/_workspace/src/github.com/Gustav-Simonsson/go-opencl/cl/device.go

@@ -1,510 +0,0 @@
-package cl
-
-// #ifdef __APPLE__
-// #include "OpenCL/opencl.h"
-// #else
-// #include "cl.h"
-// #include "cl_ext.h"
-// #endif
-import "C"
-
-import (
-	"strings"
-	"unsafe"
-)
-
-const maxDeviceCount = 64
-
-type DeviceType uint
-
-const (
-	DeviceTypeCPU         DeviceType = C.CL_DEVICE_TYPE_CPU
-	DeviceTypeGPU         DeviceType = C.CL_DEVICE_TYPE_GPU
-	DeviceTypeAccelerator DeviceType = C.CL_DEVICE_TYPE_ACCELERATOR
-	DeviceTypeDefault     DeviceType = C.CL_DEVICE_TYPE_DEFAULT
-	DeviceTypeAll         DeviceType = C.CL_DEVICE_TYPE_ALL
-)
-
-type FPConfig int
-
-const (
-	FPConfigDenorm         FPConfig = C.CL_FP_DENORM           // denorms are supported
-	FPConfigInfNaN         FPConfig = C.CL_FP_INF_NAN          // INF and NaNs are supported
-	FPConfigRoundToNearest FPConfig = C.CL_FP_ROUND_TO_NEAREST // round to nearest even rounding mode supported
-	FPConfigRoundToZero    FPConfig = C.CL_FP_ROUND_TO_ZERO    // round to zero rounding mode supported
-	FPConfigRoundToInf     FPConfig = C.CL_FP_ROUND_TO_INF     // round to positive and negative infinity rounding modes supported
-	FPConfigFMA            FPConfig = C.CL_FP_FMA              // IEEE754-2008 fused multiply-add is supported
-	FPConfigSoftFloat      FPConfig = C.CL_FP_SOFT_FLOAT       // Basic floating-point operations (such as addition, subtraction, multiplication) are implemented in software
-)
-
-var fpConfigNameMap = map[FPConfig]string{
-	FPConfigDenorm:         "Denorm",
-	FPConfigInfNaN:         "InfNaN",
-	FPConfigRoundToNearest: "RoundToNearest",
-	FPConfigRoundToZero:    "RoundToZero",
-	FPConfigRoundToInf:     "RoundToInf",
-	FPConfigFMA:            "FMA",
-	FPConfigSoftFloat:      "SoftFloat",
-}
-
-func (c FPConfig) String() string {
-	var parts []string
-	for bit, name := range fpConfigNameMap {
-		if c&bit != 0 {
-			parts = append(parts, name)
-		}
-	}
-	if parts == nil {
-		return ""
-	}
-	return strings.Join(parts, "|")
-}
-
-func (dt DeviceType) String() string {
-	var parts []string
-	if dt&DeviceTypeCPU != 0 {
-		parts = append(parts, "CPU")
-	}
-	if dt&DeviceTypeGPU != 0 {
-		parts = append(parts, "GPU")
-	}
-	if dt&DeviceTypeAccelerator != 0 {
-		parts = append(parts, "Accelerator")
-	}
-	if dt&DeviceTypeDefault != 0 {
-		parts = append(parts, "Default")
-	}
-	if parts == nil {
-		parts = append(parts, "None")
-	}
-	return strings.Join(parts, "|")
-}
-
-type Device struct {
-	id C.cl_device_id
-}
-
-func buildDeviceIdList(devices []*Device) []C.cl_device_id {
-	deviceIds := make([]C.cl_device_id, len(devices))
-	for i, d := range devices {
-		deviceIds[i] = d.id
-	}
-	return deviceIds
-}
-
-// Obtain the list of devices available on a platform. 'platform' refers
-// to the platform returned by GetPlatforms or can be nil. If platform
-// is nil, the behavior is implementation-defined.
-func GetDevices(platform *Platform, deviceType DeviceType) ([]*Device, error) {
-	var deviceIds [maxDeviceCount]C.cl_device_id
-	var numDevices C.cl_uint
-	var platformId C.cl_platform_id
-	if platform != nil {
-		platformId = platform.id
-	}
-	if err := C.clGetDeviceIDs(platformId, C.cl_device_type(deviceType), C.cl_uint(maxDeviceCount), &deviceIds[0], &numDevices); err != C.CL_SUCCESS {
-		return nil, toError(err)
-	}
-	if numDevices > maxDeviceCount {
-		numDevices = maxDeviceCount
-	}
-	devices := make([]*Device, numDevices)
-	for i := 0; i < int(numDevices); i++ {
-		devices[i] = &Device{id: deviceIds[i]}
-	}
-	return devices, nil
-}
-
-func (d *Device) nullableId() C.cl_device_id {
-	if d == nil {
-		return nil
-	}
-	return d.id
-}
-
-func (d *Device) GetInfoString(param C.cl_device_info, panicOnError bool) (string, error) {
-	var strC [1024]C.char
-	var strN C.size_t
-	if err := C.clGetDeviceInfo(d.id, param, 1024, unsafe.Pointer(&strC), &strN); err != C.CL_SUCCESS {
-		if panicOnError {
-			panic("Should never fail")
-		}
-		return "", toError(err)
-	}
-
-	// OpenCL strings are NUL-terminated, and the terminator is included in strN
-	// Go strings aren't NUL-terminated, so subtract 1 from the length
-	return C.GoStringN((*C.char)(unsafe.Pointer(&strC)), C.int(strN-1)), nil
-}
-
-func (d *Device) getInfoUint(param C.cl_device_info, panicOnError bool) (uint, error) {
-	var val C.cl_uint
-	if err := C.clGetDeviceInfo(d.id, param, C.size_t(unsafe.Sizeof(val)), unsafe.Pointer(&val), nil); err != C.CL_SUCCESS {
-		if panicOnError {
-			panic("Should never fail")
-		}
-		return 0, toError(err)
-	}
-	return uint(val), nil
-}
-
-func (d *Device) getInfoSize(param C.cl_device_info, panicOnError bool) (int, error) {
-	var val C.size_t
-	if err := C.clGetDeviceInfo(d.id, param, C.size_t(unsafe.Sizeof(val)), unsafe.Pointer(&val), nil); err != C.CL_SUCCESS {
-		if panicOnError {
-			panic("Should never fail")
-		}
-		return 0, toError(err)
-	}
-	return int(val), nil
-}
-
-func (d *Device) getInfoUlong(param C.cl_device_info, panicOnError bool) (int64, error) {
-	var val C.cl_ulong
-	if err := C.clGetDeviceInfo(d.id, param, C.size_t(unsafe.Sizeof(val)), unsafe.Pointer(&val), nil); err != C.CL_SUCCESS {
-		if panicOnError {
-			panic("Should never fail")
-		}
-		return 0, toError(err)
-	}
-	return int64(val), nil
-}
-
-func (d *Device) getInfoBool(param C.cl_device_info, panicOnError bool) (bool, error) {
-	var val C.cl_bool
-	if err := C.clGetDeviceInfo(d.id, param, C.size_t(unsafe.Sizeof(val)), unsafe.Pointer(&val), nil); err != C.CL_SUCCESS {
-		if panicOnError {
-			panic("Should never fail")
-		}
-		return false, toError(err)
-	}
-	return val == C.CL_TRUE, nil
-}
-
-func (d *Device) Name() string {
-	str, _ := d.GetInfoString(C.CL_DEVICE_NAME, true)
-	return str
-}
-
-func (d *Device) Vendor() string {
-	str, _ := d.GetInfoString(C.CL_DEVICE_VENDOR, true)
-	return str
-}
-
-func (d *Device) Extensions() string {
-	str, _ := d.GetInfoString(C.CL_DEVICE_EXTENSIONS, true)
-	return str
-}
-
-func (d *Device) OpenCLCVersion() string {
-	str, _ := d.GetInfoString(C.CL_DEVICE_OPENCL_C_VERSION, true)
-	return str
-}
-
-func (d *Device) Profile() string {
-	str, _ := d.GetInfoString(C.CL_DEVICE_PROFILE, true)
-	return str
-}
-
-func (d *Device) Version() string {
-	str, _ := d.GetInfoString(C.CL_DEVICE_VERSION, true)
-	return str
-}
-
-func (d *Device) DriverVersion() string {
-	str, _ := d.GetInfoString(C.CL_DRIVER_VERSION, true)
-	return str
-}
-
-// The default compute device address space size specified as an
-// unsigned integer value in bits. Currently supported values are 32 or 64 bits.
-func (d *Device) AddressBits() int {
-	val, _ := d.getInfoUint(C.CL_DEVICE_ADDRESS_BITS, true)
-	return int(val)
-}
-
-// Size of global memory cache line in bytes.
-func (d *Device) GlobalMemCachelineSize() int {
-	val, _ := d.getInfoUint(C.CL_DEVICE_GLOBAL_MEM_CACHELINE_SIZE, true)
-	return int(val)
-}
-
-// Maximum configured clock frequency of the device in MHz.
-func (d *Device) MaxClockFrequency() int {
-	val, _ := d.getInfoUint(C.CL_DEVICE_MAX_CLOCK_FREQUENCY, true)
-	return int(val)
-}
-
-// The number of parallel compute units on the OpenCL device.
-// A work-group executes on a single compute unit. The minimum value is 1.
-func (d *Device) MaxComputeUnits() int {
-	val, _ := d.getInfoUint(C.CL_DEVICE_MAX_COMPUTE_UNITS, true)
-	return int(val)
-}
-
-// Max number of arguments declared with the __constant qualifier in a kernel.
-// The minimum value is 8 for devices that are not of type CL_DEVICE_TYPE_CUSTOM.
-func (d *Device) MaxConstantArgs() int {
-	val, _ := d.getInfoUint(C.CL_DEVICE_MAX_CONSTANT_ARGS, true)
-	return int(val)
-}
-
-// Max number of simultaneous image objects that can be read by a kernel.
-// The minimum value is 128 if CL_DEVICE_IMAGE_SUPPORT is CL_TRUE.
-func (d *Device) MaxReadImageArgs() int {
-	val, _ := d.getInfoUint(C.CL_DEVICE_MAX_READ_IMAGE_ARGS, true)
-	return int(val)
-}
-
-// Maximum number of samplers that can be used in a kernel. The minimum
-// value is 16 if CL_DEVICE_IMAGE_SUPPORT is CL_TRUE. (Also see sampler_t.)
-func (d *Device) MaxSamplers() int {
-	val, _ := d.getInfoUint(C.CL_DEVICE_MAX_SAMPLERS, true)
-	return int(val)
-}
-
-// Maximum dimensions that specify the global and local work-item IDs used
-// by the data parallel execution model. (Refer to clEnqueueNDRangeKernel).
-// The minimum value is 3 for devices that are not of type CL_DEVICE_TYPE_CUSTOM.
-func (d *Device) MaxWorkItemDimensions() int {
-	val, _ := d.getInfoUint(C.CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS, true)
-	return int(val)
-}
-
-// Max number of simultaneous image objects that can be written to by a
-// kernel. The minimum value is 8 if CL_DEVICE_IMAGE_SUPPORT is CL_TRUE.
-func (d *Device) MaxWriteImageArgs() int {
-	val, _ := d.getInfoUint(C.CL_DEVICE_MAX_WRITE_IMAGE_ARGS, true)
-	return int(val)
-}
-
-// The minimum value is the size (in bits) of the largest OpenCL built-in
-// data type supported by the device (long16 in FULL profile, long16 or
-// int16 in EMBEDDED profile) for devices that are not of type CL_DEVICE_TYPE_CUSTOM.
-func (d *Device) MemBaseAddrAlign() int {
-	val, _ := d.getInfoUint(C.CL_DEVICE_MEM_BASE_ADDR_ALIGN, true)
-	return int(val)
-}
-
-func (d *Device) NativeVectorWidthChar() int {
-	val, _ := d.getInfoUint(C.CL_DEVICE_NATIVE_VECTOR_WIDTH_CHAR, true)
-	return int(val)
-}
-
-func (d *Device) NativeVectorWidthShort() int {
-	val, _ := d.getInfoUint(C.CL_DEVICE_NATIVE_VECTOR_WIDTH_SHORT, true)
-	return int(val)
-}
-
-func (d *Device) NativeVectorWidthInt() int {
-	val, _ := d.getInfoUint(C.CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, true)
-	return int(val)
-}
-
-func (d *Device) NativeVectorWidthLong() int {
-	val, _ := d.getInfoUint(C.CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, true)
-	return int(val)
-}
-
-func (d *Device) NativeVectorWidthFloat() int {
-	val, _ := d.getInfoUint(C.CL_DEVICE_NATIVE_VECTOR_WIDTH_FLOAT, true)
-	return int(val)
-}
-
-func (d *Device) NativeVectorWidthDouble() int {
-	val, _ := d.getInfoUint(C.CL_DEVICE_NATIVE_VECTOR_WIDTH_DOUBLE, true)
-	return int(val)
-}
-
-func (d *Device) NativeVectorWidthHalf() int {
-	val, _ := d.getInfoUint(C.CL_DEVICE_NATIVE_VECTOR_WIDTH_HALF, true)
-	return int(val)
-}
-
-// Max height of 2D image in pixels. The minimum value is 8192
-// if CL_DEVICE_IMAGE_SUPPORT is CL_TRUE.
-func (d *Device) Image2DMaxHeight() int {
-	val, _ := d.getInfoSize(C.CL_DEVICE_IMAGE2D_MAX_HEIGHT, true)
-	return int(val)
-}
-
-// Max width of 2D image or 1D image not created from a buffer object in
-// pixels. The minimum value is 8192 if CL_DEVICE_IMAGE_SUPPORT is CL_TRUE.
-func (d *Device) Image2DMaxWidth() int {
-	val, _ := d.getInfoSize(C.CL_DEVICE_IMAGE2D_MAX_WIDTH, true)
-	return int(val)
-}
-
-// Max depth of 3D image in pixels. The minimum value is 2048 if CL_DEVICE_IMAGE_SUPPORT is CL_TRUE.
-func (d *Device) Image3DMaxDepth() int {
-	val, _ := d.getInfoSize(C.CL_DEVICE_IMAGE3D_MAX_DEPTH, true)
-	return int(val)
-}
-
-// Max height of 3D image in pixels. The minimum value is 2048 if CL_DEVICE_IMAGE_SUPPORT is CL_TRUE.
-func (d *Device) Image3DMaxHeight() int {
-	val, _ := d.getInfoSize(C.CL_DEVICE_IMAGE3D_MAX_HEIGHT, true)
-	return int(val)
-}
-
-// Max width of 3D image in pixels. The minimum value is 2048 if CL_DEVICE_IMAGE_SUPPORT is CL_TRUE.
-func (d *Device) Image3DMaxWidth() int {
-	val, _ := d.getInfoSize(C.CL_DEVICE_IMAGE3D_MAX_WIDTH, true)
-	return int(val)
-}
-
-// Max size in bytes of the arguments that can be passed to a kernel. The
-// minimum value is 1024 for devices that are not of type CL_DEVICE_TYPE_CUSTOM.
-// For this minimum value, only a maximum of 128 arguments can be passed to a kernel.
-func (d *Device) MaxParameterSize() int {
-	val, _ := d.getInfoSize(C.CL_DEVICE_MAX_PARAMETER_SIZE, true)
-	return int(val)
-}
-
-// Maximum number of work-items in a work-group executing a kernel on a
-// single compute unit, using the data parallel execution model. (Refer
-// to clEnqueueNDRangeKernel). The minimum value is 1.
-func (d *Device) MaxWorkGroupSize() int {
-	val, _ := d.getInfoSize(C.CL_DEVICE_MAX_WORK_GROUP_SIZE, true)
-	return int(val)
-}
-
-// Describes the resolution of device timer. This is measured in nanoseconds.
-func (d *Device) ProfilingTimerResolution() int {
-	val, _ := d.getInfoSize(C.CL_DEVICE_PROFILING_TIMER_RESOLUTION, true)
-	return int(val)
-}
-
-// Size of local memory arena in bytes. The minimum value is 32 KB for
-// devices that are not of type CL_DEVICE_TYPE_CUSTOM.
-func (d *Device) LocalMemSize() int64 {
-	val, _ := d.getInfoUlong(C.CL_DEVICE_LOCAL_MEM_SIZE, true)
-	return val
-}
-
-// Max size in bytes of a constant buffer allocation. The minimum value is
-// 64 KB for devices that are not of type CL_DEVICE_TYPE_CUSTOM.
-func (d *Device) MaxConstantBufferSize() int64 {
-	val, _ := d.getInfoUlong(C.CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE, true)
-	return val
-}
-
-// Max size of memory object allocation in bytes. The minimum value is max
-// (1/4th of CL_DEVICE_GLOBAL_MEM_SIZE, 128*1024*1024) for devices that are
-// not of type CL_DEVICE_TYPE_CUSTOM.
-func (d *Device) MaxMemAllocSize() int64 {
-	val, _ := d.getInfoUlong(C.CL_DEVICE_MAX_MEM_ALLOC_SIZE, true)
-	return val
-}
-
-// Size of global device memory in bytes.
-func (d *Device) GlobalMemSize() int64 {
-	val, _ := d.getInfoUlong(C.CL_DEVICE_GLOBAL_MEM_SIZE, true)
-	return val
-}
-
-func (d *Device) Available() bool {
-	val, _ := d.getInfoBool(C.CL_DEVICE_AVAILABLE, true)
-	return val
-}
-
-func (d *Device) CompilerAvailable() bool {
-	val, _ := d.getInfoBool(C.CL_DEVICE_COMPILER_AVAILABLE, true)
-	return val
-}
-
-func (d *Device) EndianLittle() bool {
-	val, _ := d.getInfoBool(C.CL_DEVICE_ENDIAN_LITTLE, true)
-	return val
-}
-
-// Is CL_TRUE if the device implements error correction for all
-// accesses to compute device memory (global and constant). Is
-// CL_FALSE if the device does not implement such error correction.
-func (d *Device) ErrorCorrectionSupport() bool {
-	val, _ := d.getInfoBool(C.CL_DEVICE_ERROR_CORRECTION_SUPPORT, true)
-	return val
-}
-
-func (d *Device) HostUnifiedMemory() bool {
-	val, _ := d.getInfoBool(C.CL_DEVICE_HOST_UNIFIED_MEMORY, true)
-	return val
-}
-
-func (d *Device) ImageSupport() bool {
-	val, _ := d.getInfoBool(C.CL_DEVICE_IMAGE_SUPPORT, true)
-	return val
-}
-
-func (d *Device) Type() DeviceType {
-	var deviceType C.cl_device_type
-	if err := C.clGetDeviceInfo(d.id, C.CL_DEVICE_TYPE, C.size_t(unsafe.Sizeof(deviceType)), unsafe.Pointer(&deviceType), nil); err != C.CL_SUCCESS {
-		panic("Failed to get device type")
-	}
-	return DeviceType(deviceType)
-}
-
-// Describes double precision floating-point capability of the OpenCL device
-func (d *Device) DoubleFPConfig() FPConfig {
-	var fpConfig C.cl_device_fp_config
-	if err := C.clGetDeviceInfo(d.id, C.CL_DEVICE_DOUBLE_FP_CONFIG, C.size_t(unsafe.Sizeof(fpConfig)), unsafe.Pointer(&fpConfig), nil); err != C.CL_SUCCESS {
-		panic("Failed to get double FP config")
-	}
-	return FPConfig(fpConfig)
-}
-
-// Describes the OPTIONAL half precision floating-point capability of the OpenCL device
-func (d *Device) HalfFPConfig() FPConfig {
-	var fpConfig C.cl_device_fp_config
-	err := C.clGetDeviceInfo(d.id, C.CL_DEVICE_HALF_FP_CONFIG, C.size_t(unsafe.Sizeof(fpConfig)), unsafe.Pointer(&fpConfig), nil)
-	if err != C.CL_SUCCESS {
-		return FPConfig(0)
-	}
-	return FPConfig(fpConfig)
-}
-
-// Type of local memory supported. This can be set to CL_LOCAL implying dedicated
-// local memory storage such as SRAM, or CL_GLOBAL. For custom devices, CL_NONE
-// can also be returned indicating no local memory support.
-func (d *Device) LocalMemType() LocalMemType {
-	var memType C.cl_device_local_mem_type
-	if err := C.clGetDeviceInfo(d.id, C.CL_DEVICE_LOCAL_MEM_TYPE, C.size_t(unsafe.Sizeof(memType)), unsafe.Pointer(&memType), nil); err != C.CL_SUCCESS {
-		return LocalMemType(C.CL_NONE)
-	}
-	return LocalMemType(memType)
-}
-
-// Describes the execution capabilities of the device. The mandated minimum capability is CL_EXEC_KERNEL.
-func (d *Device) ExecutionCapabilities() ExecCapability {
-	var execCap C.cl_device_exec_capabilities
-	if err := C.clGetDeviceInfo(d.id, C.CL_DEVICE_EXECUTION_CAPABILITIES, C.size_t(unsafe.Sizeof(execCap)), unsafe.Pointer(&execCap), nil); err != C.CL_SUCCESS {
-		panic("Failed to get execution capabilities")
-	}
-	return ExecCapability(execCap)
-}
-
-func (d *Device) GlobalMemCacheType() MemCacheType {
-	var memType C.cl_device_mem_cache_type
-	if err := C.clGetDeviceInfo(d.id, C.CL_DEVICE_GLOBAL_MEM_CACHE_TYPE, C.size_t(unsafe.Sizeof(memType)), unsafe.Pointer(&memType), nil); err != C.CL_SUCCESS {
-		return MemCacheType(C.CL_NONE)
-	}
-	return MemCacheType(memType)
-}
-
-// Maximum number of work-items that can be specified in each dimension of the work-group to clEnqueueNDRangeKernel.
-//
-// Returns n size_t entries, where n is the value returned by the query for CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS.
-//
-// The minimum value is (1, 1, 1) for devices that are not of type CL_DEVICE_TYPE_CUSTOM.
-func (d *Device) MaxWorkItemSizes() []int {
-	dims := d.MaxWorkItemDimensions()
-	sizes := make([]C.size_t, dims)
-	if err := C.clGetDeviceInfo(d.id, C.CL_DEVICE_MAX_WORK_ITEM_SIZES, C.size_t(int(unsafe.Sizeof(sizes[0]))*dims), unsafe.Pointer(&sizes[0]), nil); err != C.CL_SUCCESS {
-		panic("Failed to get max work item sizes")
-	}
-	intSizes := make([]int, dims)
-	for i, s := range sizes {
-		intSizes[i] = int(s)
-	}
-	return intSizes
-}

Godeps/_workspace/src/github.com/Gustav-Simonsson/go-opencl/cl/device12.go

@@ -1,51 +0,0 @@
-// +build cl12
-
-package cl
-
-// #ifdef __APPLE__
-// #include "OpenCL/opencl.h"
-// #else
-// #include "cl.h"
-// #endif
-import "C"
-import "unsafe"
-
-const FPConfigCorrectlyRoundedDivideSqrt FPConfig = C.CL_FP_CORRECTLY_ROUNDED_DIVIDE_SQRT
-
-func init() {
-	fpConfigNameMap[FPConfigCorrectlyRoundedDivideSqrt] = "CorrectlyRoundedDivideSqrt"
-}
-
-func (d *Device) BuiltInKernels() string {
-	str, _ := d.getInfoString(C.CL_DEVICE_BUILT_IN_KERNELS, true)
-	return str
-}
-
-// Is CL_FALSE if the implementation does not have a linker available. Is CL_TRUE if the linker is available. This can be CL_FALSE for the embedded platform profile only. This must be CL_TRUE if CL_DEVICE_COMPILER_AVAILABLE is CL_TRUE
-func (d *Device) LinkerAvailable() bool {
-	val, _ := d.getInfoBool(C.CL_DEVICE_LINKER_AVAILABLE, true)
-	return val
-}
-
-func (d *Device) ParentDevice() *Device {
-	var deviceId C.cl_device_id
-	if err := C.clGetDeviceInfo(d.id, C.CL_DEVICE_PARENT_DEVICE, C.size_t(unsafe.Sizeof(deviceId)), unsafe.Pointer(&deviceId), nil); err != C.CL_SUCCESS {
-		panic("ParentDevice failed")
-	}
-	if deviceId == nil {
-		return nil
-	}
-	return &Device{id: deviceId}
-}
-
-// Max number of pixels for a 1D image created from a buffer object. The minimum value is 65536 if CL_DEVICE_IMAGE_SUPPORT is CL_TRUE.
-func (d *Device) ImageMaxBufferSize() int {
-	val, _ := d.getInfoSize(C.CL_DEVICE_IMAGE_MAX_BUFFER_SIZE, true)
-	return int(val)
-}
-
-// Max number of images in a 1D or 2D image array. The minimum value is 2048 if CL_DEVICE_IMAGE_SUPPORT is CL_TRUE
-func (d *Device) ImageMaxArraySize() int {
-	val, _ := d.getInfoSize(C.CL_DEVICE_IMAGE_MAX_ARRAY_SIZE, true)
-	return int(val)
-}

Godeps/_workspace/src/github.com/Gustav-Simonsson/go-opencl/cl/headers/1.2/cl_ext.h

@@ -1,315 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2008-2013 The Khronos Group Inc.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and/or associated documentation files (the
- * "Materials"), to deal in the Materials without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sublicense, and/or sell copies of the Materials, and to
- * permit persons to whom the Materials are furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Materials.
- *
- * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
- * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
- * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
- ******************************************************************************/
-
-/* $Revision: 11928 $ on $Date: 2010-07-13 09:04:56 -0700 (Tue, 13 Jul 2010) $ */
-
-/* cl_ext.h contains OpenCL extensions which don't have external */
-/* (OpenGL, D3D) dependencies.                                   */
-
-#ifndef __CL_EXT_H
-#define __CL_EXT_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#ifdef __APPLE__
-#include <AvailabilityMacros.h>
-#endif
-
-#include <cl.h>
-
-/* cl_khr_fp16 extension - no extension #define since it has no functions  */
-#define CL_DEVICE_HALF_FP_CONFIG                    0x1033
-
-/* Memory object destruction
- *
- * Apple extension for use to manage externally allocated buffers used with cl_mem objects with CL_MEM_USE_HOST_PTR
- *
- * Registers a user callback function that will be called when the memory object is deleted and its resources 
- * freed. Each call to clSetMemObjectCallbackFn registers the specified user callback function on a callback 
- * stack associated with memobj. The registered user callback functions are called in the reverse order in 
- * which they were registered. The user callback functions are called and then the memory object is deleted 
- * and its resources freed. This provides a mechanism for the application (and libraries) using memobj to be 
- * notified when the memory referenced by host_ptr, specified when the memory object is created and used as 
- * the storage bits for the memory object, can be reused or freed.
- *
- * The application may not call CL api's with the cl_mem object passed to the pfn_notify.
- *
- * Please check for the "cl_APPLE_SetMemObjectDestructor" extension using clGetDeviceInfo(CL_DEVICE_EXTENSIONS)
- * before using.
- */
-#define cl_APPLE_SetMemObjectDestructor 1
-cl_int  CL_API_ENTRY clSetMemObjectDestructorAPPLE(  cl_mem /* memobj */, 
-                                        void (* /*pfn_notify*/)( cl_mem /* memobj */, void* /*user_data*/), 
-                                        void * /*user_data */ )             CL_EXT_SUFFIX__VERSION_1_0;  
-
-
-/* Context Logging Functions
- *
- * The next three convenience functions are intended to be used as the pfn_notify parameter to clCreateContext().
- * Please check for the "cl_APPLE_ContextLoggingFunctions" extension using clGetDeviceInfo(CL_DEVICE_EXTENSIONS)
- * before using.
- *
- * clLogMessagesToSystemLog fowards on all log messages to the Apple System Logger 
- */
-#define cl_APPLE_ContextLoggingFunctions 1
-extern void CL_API_ENTRY clLogMessagesToSystemLogAPPLE(  const char * /* errstr */, 
-                                            const void * /* private_info */, 
-                                            size_t       /* cb */, 
-                                            void *       /* user_data */ )  CL_EXT_SUFFIX__VERSION_1_0;
-
-/* clLogMessagesToStdout sends all log messages to the file descriptor stdout */
-extern void CL_API_ENTRY clLogMessagesToStdoutAPPLE(   const char * /* errstr */, 
-                                          const void * /* private_info */, 
-                                          size_t       /* cb */, 
-                                          void *       /* user_data */ )    CL_EXT_SUFFIX__VERSION_1_0;
-
-/* clLogMessagesToStderr sends all log messages to the file descriptor stderr */
-extern void CL_API_ENTRY clLogMessagesToStderrAPPLE(   const char * /* errstr */, 
-                                          const void * /* private_info */, 
-                                          size_t       /* cb */, 
-                                          void *       /* user_data */ )    CL_EXT_SUFFIX__VERSION_1_0;
-
-
-/************************ 
-* cl_khr_icd extension *                                                  
-************************/
-#define cl_khr_icd 1
-
-/* cl_platform_info                                                        */
-#define CL_PLATFORM_ICD_SUFFIX_KHR                  0x0920
-
-/* Additional Error Codes                                                  */
-#define CL_PLATFORM_NOT_FOUND_KHR                   -1001
-
-extern CL_API_ENTRY cl_int CL_API_CALL
-clIcdGetPlatformIDsKHR(cl_uint          /* num_entries */,
-                       cl_platform_id * /* platforms */,
-                       cl_uint *        /* num_platforms */);
-
-typedef CL_API_ENTRY cl_int (CL_API_CALL *clIcdGetPlatformIDsKHR_fn)(
-    cl_uint          /* num_entries */,
-    cl_platform_id * /* platforms */,
-    cl_uint *        /* num_platforms */);
-
-
-/* Extension: cl_khr_image2D_buffer
- *
- * This extension allows a 2D image to be created from a cl_mem buffer without a copy.
- * The type associated with a 2D image created from a buffer in an OpenCL program is image2d_t.
- * Both the sampler and sampler-less read_image built-in functions are supported for 2D images
- * and 2D images created from a buffer.  Similarly, the write_image built-ins are also supported
- * for 2D images created from a buffer.
- *
- * When the 2D image from buffer is created, the client must specify the width,
- * height, image format (i.e. channel order and channel data type) and optionally the row pitch
- *
- * The pitch specified must be a multiple of CL_DEVICE_IMAGE_PITCH_ALIGNMENT pixels.
- * The base address of the buffer must be aligned to CL_DEVICE_IMAGE_BASE_ADDRESS_ALIGNMENT pixels.
- */
-    
-/*************************************
- * cl_khr_initalize_memory extension *
- *************************************/
-    
-#define CL_CONTEXT_MEMORY_INITIALIZE_KHR            0x200E
-    
-    
-/**************************************
- * cl_khr_terminate_context extension *
- **************************************/
-    
-#define CL_DEVICE_TERMINATE_CAPABILITY_KHR          0x200F
-#define CL_CONTEXT_TERMINATE_KHR                    0x2010
-
-#define cl_khr_terminate_context 1
-extern CL_API_ENTRY cl_int CL_API_CALL clTerminateContextKHR(cl_context /* context */) CL_EXT_SUFFIX__VERSION_1_2;
-
-typedef CL_API_ENTRY cl_int (CL_API_CALL *clTerminateContextKHR_fn)(cl_context /* context */) CL_EXT_SUFFIX__VERSION_1_2;
-    
-    
-/*
- * Extension: cl_khr_spir
- *
- * This extension adds support to create an OpenCL program object from a 
- * Standard Portable Intermediate Representation (SPIR) instance
- */
-
-#define CL_DEVICE_SPIR_VERSIONS                     0x40E0
-#define CL_PROGRAM_BINARY_TYPE_INTERMEDIATE         0x40E1
-
-
-/******************************************
-* cl_nv_device_attribute_query extension *
-******************************************/
-/* cl_nv_device_attribute_query extension - no extension #define since it has no functions */
-#define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV       0x4000
-#define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV       0x4001
-#define CL_DEVICE_REGISTERS_PER_BLOCK_NV            0x4002
-#define CL_DEVICE_WARP_SIZE_NV                      0x4003
-#define CL_DEVICE_GPU_OVERLAP_NV                    0x4004
-#define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV            0x4005
-#define CL_DEVICE_INTEGRATED_MEMORY_NV              0x4006
-
-/*********************************
-* cl_amd_device_attribute_query *
-*********************************/
-#define CL_DEVICE_PROFILING_TIMER_OFFSET_AMD        0x4036
-
-/*********************************
-* cl_arm_printf extension
-*********************************/
-#define CL_PRINTF_CALLBACK_ARM                      0x40B0
-#define CL_PRINTF_BUFFERSIZE_ARM                    0x40B1
-
-#ifdef CL_VERSION_1_1
-   /***********************************
-    * cl_ext_device_fission extension *
-    ***********************************/
-    #define cl_ext_device_fission   1
-    
-    extern CL_API_ENTRY cl_int CL_API_CALL
-    clReleaseDeviceEXT( cl_device_id /*device*/ ) CL_EXT_SUFFIX__VERSION_1_1; 
-    
-    typedef CL_API_ENTRY cl_int 
-    (CL_API_CALL *clReleaseDeviceEXT_fn)( cl_device_id /*device*/ ) CL_EXT_SUFFIX__VERSION_1_1;
-
-    extern CL_API_ENTRY cl_int CL_API_CALL
-    clRetainDeviceEXT( cl_device_id /*device*/ ) CL_EXT_SUFFIX__VERSION_1_1; 
-    
-    typedef CL_API_ENTRY cl_int 
-    (CL_API_CALL *clRetainDeviceEXT_fn)( cl_device_id /*device*/ ) CL_EXT_SUFFIX__VERSION_1_1;
-
-    typedef cl_ulong  cl_device_partition_property_ext;
-    extern CL_API_ENTRY cl_int CL_API_CALL
-    clCreateSubDevicesEXT(  cl_device_id /*in_device*/,
-                            const cl_device_partition_property_ext * /* properties */,
-                            cl_uint /*num_entries*/,
-                            cl_device_id * /*out_devices*/,
-                            cl_uint * /*num_devices*/ ) CL_EXT_SUFFIX__VERSION_1_1;
-
-    typedef CL_API_ENTRY cl_int 
-    ( CL_API_CALL * clCreateSubDevicesEXT_fn)(  cl_device_id /*in_device*/,
-                                                const cl_device_partition_property_ext * /* properties */,
-                                                cl_uint /*num_entries*/,
-                                                cl_device_id * /*out_devices*/,
-                                                cl_uint * /*num_devices*/ ) CL_EXT_SUFFIX__VERSION_1_1;
-
-    /* cl_device_partition_property_ext */
-    #define CL_DEVICE_PARTITION_EQUALLY_EXT             0x4050
-    #define CL_DEVICE_PARTITION_BY_COUNTS_EXT           0x4051
-    #define CL_DEVICE_PARTITION_BY_NAMES_EXT            0x4052
-    #define CL_DEVICE_PARTITION_BY_AFFINITY_DOMAIN_EXT  0x4053
-    
-    /* clDeviceGetInfo selectors */
-    #define CL_DEVICE_PARENT_DEVICE_EXT                 0x4054
-    #define CL_DEVICE_PARTITION_TYPES_EXT               0x4055
-    #define CL_DEVICE_AFFINITY_DOMAINS_EXT              0x4056
-    #define CL_DEVICE_REFERENCE_COUNT_EXT               0x4057
-    #define CL_DEVICE_PARTITION_STYLE_EXT               0x4058
-    
-    /* error codes */
-    #define CL_DEVICE_PARTITION_FAILED_EXT              -1057
-    #define CL_INVALID_PARTITION_COUNT_EXT              -1058
-    #define CL_INVALID_PARTITION_NAME_EXT               -1059
-    
-    /* CL_AFFINITY_DOMAINs */
-    #define CL_AFFINITY_DOMAIN_L1_CACHE_EXT             0x1
-    #define CL_AFFINITY_DOMAIN_L2_CACHE_EXT             0x2
-    #define CL_AFFINITY_DOMAIN_L3_CACHE_EXT             0x3
-    #define CL_AFFINITY_DOMAIN_L4_CACHE_EXT             0x4
-    #define CL_AFFINITY_DOMAIN_NUMA_EXT                 0x10
-    #define CL_AFFINITY_DOMAIN_NEXT_FISSIONABLE_EXT     0x100
-    
-    /* cl_device_partition_property_ext list terminators */
-    #define CL_PROPERTIES_LIST_END_EXT                  ((cl_device_partition_property_ext) 0)
-    #define CL_PARTITION_BY_COUNTS_LIST_END_EXT         ((cl_device_partition_property_ext) 0)
-    #define CL_PARTITION_BY_NAMES_LIST_END_EXT          ((cl_device_partition_property_ext) 0 - 1)
-
-/*********************************
-* cl_qcom_ext_host_ptr extension
-*********************************/
-
-#define CL_MEM_EXT_HOST_PTR_QCOM                  (1 << 29)
-
-#define CL_DEVICE_EXT_MEM_PADDING_IN_BYTES_QCOM   0x40A0      
-#define CL_DEVICE_PAGE_SIZE_QCOM                  0x40A1
-#define CL_IMAGE_ROW_ALIGNMENT_QCOM               0x40A2
-#define CL_IMAGE_SLICE_ALIGNMENT_QCOM             0x40A3
-#define CL_MEM_HOST_UNCACHED_QCOM                 0x40A4
-#define CL_MEM_HOST_WRITEBACK_QCOM                0x40A5
-#define CL_MEM_HOST_WRITETHROUGH_QCOM             0x40A6
-#define CL_MEM_HOST_WRITE_COMBINING_QCOM          0x40A7
-
-typedef cl_uint                                   cl_image_pitch_info_qcom;
-
-extern CL_API_ENTRY cl_int CL_API_CALL
-clGetDeviceImageInfoQCOM(cl_device_id             device,
-                         size_t                   image_width,
-                         size_t                   image_height,
-                         const cl_image_format   *image_format,
-                         cl_image_pitch_info_qcom param_name,
-                         size_t                   param_value_size,
-                         void                    *param_value,
-                         size_t                  *param_value_size_ret);
-
-typedef struct _cl_mem_ext_host_ptr
-{
-    /* Type of external memory allocation. */
-    /* Legal values will be defined in layered extensions. */
-    cl_uint  allocation_type;
-            
-	/* Host cache policy for this external memory allocation. */
-    cl_uint  host_cache_policy;
-
-} cl_mem_ext_host_ptr;
-
-/*********************************
-* cl_qcom_ion_host_ptr extension
-*********************************/
-
-#define CL_MEM_ION_HOST_PTR_QCOM                  0x40A8
-
-typedef struct _cl_mem_ion_host_ptr
-{
-    /* Type of external memory allocation. */
-    /* Must be CL_MEM_ION_HOST_PTR_QCOM for ION allocations. */
-    cl_mem_ext_host_ptr  ext_host_ptr;
-
-    /* ION file descriptor */
-    int                  ion_filedesc;
-            
-    /* Host pointer to the ION allocated memory */
-    void*                ion_hostptr;
-
-} cl_mem_ion_host_ptr;
-
-#endif /* CL_VERSION_1_1 */
-
-#ifdef __cplusplus
-}
-#endif
-
-
-#endif /* __CL_EXT_H */

Godeps/_workspace/src/github.com/Gustav-Simonsson/go-opencl/cl/headers/1.2/cl_gl.h

@@ -1,158 +0,0 @@
-/**********************************************************************************
- * Copyright (c) 2008 - 2012 The Khronos Group Inc.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and/or associated documentation files (the
- * "Materials"), to deal in the Materials without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sublicense, and/or sell copies of the Materials, and to
- * permit persons to whom the Materials are furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Materials.
- *
- * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
- * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
- * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
- **********************************************************************************/
-
-#ifndef __OPENCL_CL_GL_H
-#define __OPENCL_CL_GL_H
-
-#include <cl.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef cl_uint     cl_gl_object_type;
-typedef cl_uint     cl_gl_texture_info;
-typedef cl_uint     cl_gl_platform_info;
-typedef struct __GLsync *cl_GLsync;
-
-/* cl_gl_object_type = 0x2000 - 0x200F enum values are currently taken           */
-#define CL_GL_OBJECT_BUFFER                     0x2000
-#define CL_GL_OBJECT_TEXTURE2D                  0x2001
-#define CL_GL_OBJECT_TEXTURE3D                  0x2002
-#define CL_GL_OBJECT_RENDERBUFFER               0x2003
-#define CL_GL_OBJECT_TEXTURE2D_ARRAY            0x200E
-#define CL_GL_OBJECT_TEXTURE1D                  0x200F
-#define CL_GL_OBJECT_TEXTURE1D_ARRAY            0x2010
-#define CL_GL_OBJECT_TEXTURE_BUFFER             0x2011
-
-/* cl_gl_texture_info           */
-#define CL_GL_TEXTURE_TARGET                    0x2004
-#define CL_GL_MIPMAP_LEVEL                      0x2005
-#define CL_GL_NUM_SAMPLES                       0x2012
-
-
-extern CL_API_ENTRY cl_mem CL_API_CALL
-clCreateFromGLBuffer(cl_context     /* context */,
-                     cl_mem_flags   /* flags */,
-                     cl_GLuint      /* bufobj */,
-                     int *          /* errcode_ret */) CL_API_SUFFIX__VERSION_1_0;
-
-extern CL_API_ENTRY cl_mem CL_API_CALL
-clCreateFromGLTexture(cl_context      /* context */,
-                      cl_mem_flags    /* flags */,
-                      cl_GLenum       /* target */,
-                      cl_GLint        /* miplevel */,
-                      cl_GLuint       /* texture */,
-                      cl_int *        /* errcode_ret */) CL_API_SUFFIX__VERSION_1_2;
-    
-extern CL_API_ENTRY cl_mem CL_API_CALL
-clCreateFromGLRenderbuffer(cl_context   /* context */,
-                           cl_mem_flags /* flags */,
-                           cl_GLuint    /* renderbuffer */,
-                           cl_int *     /* errcode_ret */) CL_API_SUFFIX__VERSION_1_0;
-
-extern CL_API_ENTRY cl_int CL_API_CALL
-clGetGLObjectInfo(cl_mem                /* memobj */,
-                  cl_gl_object_type *   /* gl_object_type */,
-                  cl_GLuint *           /* gl_object_name */) CL_API_SUFFIX__VERSION_1_0;
-                  
-extern CL_API_ENTRY cl_int CL_API_CALL
-clGetGLTextureInfo(cl_mem               /* memobj */,
-                   cl_gl_texture_info   /* param_name */,
-                   size_t               /* param_value_size */,
-                   void *               /* param_value */,
-                   size_t *             /* param_value_size_ret */) CL_API_SUFFIX__VERSION_1_0;
-
-extern CL_API_ENTRY cl_int CL_API_CALL
-clEnqueueAcquireGLObjects(cl_command_queue      /* command_queue */,
-                          cl_uint               /* num_objects */,
-                          const cl_mem *        /* mem_objects */,
-                          cl_uint               /* num_events_in_wait_list */,
-                          const cl_event *      /* event_wait_list */,
-                          cl_event *            /* event */) CL_API_SUFFIX__VERSION_1_0;
-
-extern CL_API_ENTRY cl_int CL_API_CALL
-clEnqueueReleaseGLObjects(cl_command_queue      /* command_queue */,
-                          cl_uint               /* num_objects */,
-                          const cl_mem *        /* mem_objects */,
-                          cl_uint               /* num_events_in_wait_list */,
-                          const cl_event *      /* event_wait_list */,
-                          cl_event *            /* event */) CL_API_SUFFIX__VERSION_1_0;
-
-
-/* Deprecated OpenCL 1.1 APIs */
-extern CL_API_ENTRY CL_EXT_PREFIX__VERSION_1_1_DEPRECATED cl_mem CL_API_CALL
-clCreateFromGLTexture2D(cl_context      /* context */,
-                        cl_mem_flags    /* flags */,
-                        cl_GLenum       /* target */,
-                        cl_GLint        /* miplevel */,
-                        cl_GLuint       /* texture */,
-                        cl_int *        /* errcode_ret */) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED;
-    
-extern CL_API_ENTRY CL_EXT_PREFIX__VERSION_1_1_DEPRECATED cl_mem CL_API_CALL
-clCreateFromGLTexture3D(cl_context      /* context */,
-                        cl_mem_flags    /* flags */,
-                        cl_GLenum       /* target */,
-                        cl_GLint        /* miplevel */,
-                        cl_GLuint       /* texture */,
-                        cl_int *        /* errcode_ret */) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED;
-    
-/* cl_khr_gl_sharing extension  */
-    
-#define cl_khr_gl_sharing 1
-    
-typedef cl_uint     cl_gl_context_info;
-    
-/* Additional Error Codes  */
-#define CL_INVALID_GL_SHAREGROUP_REFERENCE_KHR  -1000
-    
-/* cl_gl_context_info  */
-#define CL_CURRENT_DEVICE_FOR_GL_CONTEXT_KHR    0x2006
-#define CL_DEVICES_FOR_GL_CONTEXT_KHR           0x2007
-    
-/* Additional cl_context_properties  */
-#define CL_GL_CONTEXT_KHR                       0x2008
-#define CL_EGL_DISPLAY_KHR                      0x2009
-#define CL_GLX_DISPLAY_KHR                      0x200A
-#define CL_WGL_HDC_KHR                          0x200B
-#define CL_CGL_SHAREGROUP_KHR                   0x200C
-    
-extern CL_API_ENTRY cl_int CL_API_CALL
-clGetGLContextInfoKHR(const cl_context_properties * /* properties */,
-                      cl_gl_context_info            /* param_name */,
-                      size_t                        /* param_value_size */,
-                      void *                        /* param_value */,
-                      size_t *                      /* param_value_size_ret */) CL_API_SUFFIX__VERSION_1_0;
-    
-typedef CL_API_ENTRY cl_int (CL_API_CALL *clGetGLContextInfoKHR_fn)(
-    const cl_context_properties * properties,
-    cl_gl_context_info            param_name,
-    size_t                        param_value_size,
-    void *                        param_value,
-    size_t *                      param_value_size_ret);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif  /* __OPENCL_CL_GL_H */

Godeps/_workspace/src/github.com/Gustav-Simonsson/go-opencl/cl/headers/1.2/cl_gl_ext.h

@@ -1,65 +0,0 @@
-/**********************************************************************************
- * Copyright (c) 2008-2012 The Khronos Group Inc.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and/or associated documentation files (the
- * "Materials"), to deal in the Materials without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sublicense, and/or sell copies of the Materials, and to
- * permit persons to whom the Materials are furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Materials.
- *
- * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
- * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
- * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
- **********************************************************************************/
-
-/* $Revision: 11708 $ on $Date: 2010-06-13 23:36:24 -0700 (Sun, 13 Jun 2010) $ */
-
-/* cl_gl_ext.h contains vendor (non-KHR) OpenCL extensions which have           */
-/* OpenGL dependencies.                                                         */
-
-#ifndef __OPENCL_CL_GL_EXT_H
-#define __OPENCL_CL_GL_EXT_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include <cl_gl.h>
-
-/*
- * For each extension, follow this template
- *  cl_VEN_extname extension  */
-/* #define cl_VEN_extname 1
- * ... define new types, if any
- * ... define new tokens, if any
- * ... define new APIs, if any
- *
- *  If you need GLtypes here, mirror them with a cl_GLtype, rather than including a GL header
- *  This allows us to avoid having to decide whether to include GL headers or GLES here.
- */
-
-/* 
- *  cl_khr_gl_event  extension
- *  See section 9.9 in the OpenCL 1.1 spec for more information
- */
-#define CL_COMMAND_GL_FENCE_SYNC_OBJECT_KHR     0x200D
-
-extern CL_API_ENTRY cl_event CL_API_CALL
-clCreateEventFromGLsyncKHR(cl_context           /* context */,
-                           cl_GLsync            /* cl_GLsync */,
-                           cl_int *             /* errcode_ret */) CL_EXT_SUFFIX__VERSION_1_1;
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif	/* __OPENCL_CL_GL_EXT_H  */

Godeps/_workspace/src/github.com/Gustav-Simonsson/go-opencl/cl/headers/1.2/opencl.h

@@ -1,43 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2008-2012 The Khronos Group Inc.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and/or associated documentation files (the
- * "Materials"), to deal in the Materials without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sublicense, and/or sell copies of the Materials, and to
- * permit persons to whom the Materials are furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Materials.
- *
- * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
- * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
- * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
- ******************************************************************************/
-
-/* $Revision: 11708 $ on $Date: 2010-06-13 23:36:24 -0700 (Sun, 13 Jun 2010) $ */
-
-#ifndef __OPENCL_H
-#define __OPENCL_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include <cl.h>
-#include <cl_gl.h>
-#include <cl_gl_ext.h>
-#include <cl_ext.h>
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif  /* __OPENCL_H   */
-

Godeps/_workspace/src/github.com/Gustav-Simonsson/go-opencl/cl/image.go

@@ -1,83 +0,0 @@
-// +build cl12
-
-package cl
-
-// #ifdef __APPLE__
-// #include "OpenCL/opencl.h"
-// #else
-// #include "cl.h"
-// #endif
-import "C"
-import (
-	"image"
-	"unsafe"
-)
-
-func (ctx *Context) CreateImage(flags MemFlag, imageFormat ImageFormat, imageDesc ImageDescription, data []byte) (*MemObject, error) {
-	format := imageFormat.toCl()
-	desc := imageDesc.toCl()
-	var dataPtr unsafe.Pointer
-	if data != nil {
-		dataPtr = unsafe.Pointer(&data[0])
-	}
-	var err C.cl_int
-	clBuffer := C.clCreateImage(ctx.clContext, C.cl_mem_flags(flags), &format, &desc, dataPtr, &err)
-	if err != C.CL_SUCCESS {
-		return nil, toError(err)
-	}
-	if clBuffer == nil {
-		return nil, ErrUnknown
-	}
-	return newMemObject(clBuffer, len(data)), nil
-}
-
-func (ctx *Context) CreateImageSimple(flags MemFlag, width, height int, channelOrder ChannelOrder, channelDataType ChannelDataType, data []byte) (*MemObject, error) {
-	format := ImageFormat{channelOrder, channelDataType}
-	desc := ImageDescription{
-		Type:   MemObjectTypeImage2D,
-		Width:  width,
-		Height: height,
-	}
-	return ctx.CreateImage(flags, format, desc, data)
-}
-
-func (ctx *Context) CreateImageFromImage(flags MemFlag, img image.Image) (*MemObject, error) {
-	switch m := img.(type) {
-	case *image.Gray:
-		format := ImageFormat{ChannelOrderIntensity, ChannelDataTypeUNormInt8}
-		desc := ImageDescription{
-			Type:     MemObjectTypeImage2D,
-			Width:    m.Bounds().Dx(),
-			Height:   m.Bounds().Dy(),
-			RowPitch: m.Stride,
-		}
-		return ctx.CreateImage(flags, format, desc, m.Pix)
-	case *image.RGBA:
-		format := ImageFormat{ChannelOrderRGBA, ChannelDataTypeUNormInt8}
-		desc := ImageDescription{
-			Type:     MemObjectTypeImage2D,
-			Width:    m.Bounds().Dx(),
-			Height:   m.Bounds().Dy(),
-			RowPitch: m.Stride,
-		}
-		return ctx.CreateImage(flags, format, desc, m.Pix)
-	}
-
-	b := img.Bounds()
-	w := b.Dx()
-	h := b.Dy()
-	data := make([]byte, w*h*4)
-	dataOffset := 0
-	for y := 0; y < h; y++ {
-		for x := 0; x < w; x++ {
-			c := img.At(x+b.Min.X, y+b.Min.Y)
-			r, g, b, a := c.RGBA()
-			data[dataOffset] = uint8(r >> 8)
-			data[dataOffset+1] = uint8(g >> 8)
-			data[dataOffset+2] = uint8(b >> 8)
-			data[dataOffset+3] = uint8(a >> 8)
-			dataOffset += 4
-		}
-	}
-	return ctx.CreateImageSimple(flags, w, h, ChannelOrderRGBA, ChannelDataTypeUNormInt8, data)
-}

Godeps/_workspace/src/github.com/Gustav-Simonsson/go-opencl/cl/kernel.go

@@ -1,127 +0,0 @@
-package cl
-
-// #ifdef __APPLE__
-// #include "OpenCL/opencl.h"
-// #else
-// #include "cl.h"
-// #endif
-import "C"
-
-import (
-	"fmt"
-	"unsafe"
-)
-
-type ErrUnsupportedArgumentType struct {
-	Index int
-	Value interface{}
-}
-
-func (e ErrUnsupportedArgumentType) Error() string {
-	return fmt.Sprintf("cl: unsupported argument type for index %d: %+v", e.Index, e.Value)
-}
-
-type Kernel struct {
-	clKernel C.cl_kernel
-	name     string
-}
-
-type LocalBuffer int
-
-func releaseKernel(k *Kernel) {
-	if k.clKernel != nil {
-		C.clReleaseKernel(k.clKernel)
-		k.clKernel = nil
-	}
-}
-
-func (k *Kernel) Release() {
-	releaseKernel(k)
-}
-
-func (k *Kernel) SetArgs(args ...interface{}) error {
-	for index, arg := range args {
-		if err := k.SetArg(index, arg); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func (k *Kernel) SetArg(index int, arg interface{}) error {
-	switch val := arg.(type) {
-	case uint8:
-		return k.SetArgUint8(index, val)
-	case int8:
-		return k.SetArgInt8(index, val)
-	case uint32:
-		return k.SetArgUint32(index, val)
-	case uint64:
-		return k.SetArgUint64(index, val)
-	case int32:
-		return k.SetArgInt32(index, val)
-	case float32:
-		return k.SetArgFloat32(index, val)
-	case *MemObject:
-		return k.SetArgBuffer(index, val)
-	case LocalBuffer:
-		return k.SetArgLocal(index, int(val))
-	default:
-		return ErrUnsupportedArgumentType{Index: index, Value: arg}
-	}
-}
-
-func (k *Kernel) SetArgBuffer(index int, buffer *MemObject) error {
-	return k.SetArgUnsafe(index, int(unsafe.Sizeof(buffer.clMem)), unsafe.Pointer(&buffer.clMem))
-}
-
-func (k *Kernel) SetArgFloat32(index int, val float32) error {
-	return k.SetArgUnsafe(index, int(unsafe.Sizeof(val)), unsafe.Pointer(&val))
-}
-
-func (k *Kernel) SetArgInt8(index int, val int8) error {
-	return k.SetArgUnsafe(index, int(unsafe.Sizeof(val)), unsafe.Pointer(&val))
-}
-
-func (k *Kernel) SetArgUint8(index int, val uint8) error {
-	return k.SetArgUnsafe(index, int(unsafe.Sizeof(val)), unsafe.Pointer(&val))
-}
-
-func (k *Kernel) SetArgInt32(index int, val int32) error {
-	return k.SetArgUnsafe(index, int(unsafe.Sizeof(val)), unsafe.Pointer(&val))
-}
-
-func (k *Kernel) SetArgUint32(index int, val uint32) error {
-	return k.SetArgUnsafe(index, int(unsafe.Sizeof(val)), unsafe.Pointer(&val))
-}
-
-func (k *Kernel) SetArgUint64(index int, val uint64) error {
-	return k.SetArgUnsafe(index, int(unsafe.Sizeof(val)), unsafe.Pointer(&val))
-}
-
-func (k *Kernel) SetArgLocal(index int, size int) error {
-	return k.SetArgUnsafe(index, size, nil)
-}
-
-func (k *Kernel) SetArgUnsafe(index, argSize int, arg unsafe.Pointer) error {
-	//fmt.Println("FUNKY: ", index, argSize)
-	return toError(C.clSetKernelArg(k.clKernel, C.cl_uint(index), C.size_t(argSize), arg))
-}
-
-func (k *Kernel) PreferredWorkGroupSizeMultiple(device *Device) (int, error) {
-	var size C.size_t
-	err := C.clGetKernelWorkGroupInfo(k.clKernel, device.nullableId(), C.CL_KERNEL_PREFERRED_WORK_GROUP_SIZE_MULTIPLE, C.size_t(unsafe.Sizeof(size)), unsafe.Pointer(&size), nil)
-	return int(size), toError(err)
-}
-
-func (k *Kernel) WorkGroupSize(device *Device) (int, error) {
-	var size C.size_t
-	err := C.clGetKernelWorkGroupInfo(k.clKernel, device.nullableId(), C.CL_KERNEL_WORK_GROUP_SIZE, C.size_t(unsafe.Sizeof(size)), unsafe.Pointer(&size), nil)
-	return int(size), toError(err)
-}
-
-func (k *Kernel) NumArgs() (int, error) {
-	var num C.cl_uint
-	err := C.clGetKernelInfo(k.clKernel, C.CL_KERNEL_NUM_ARGS, C.size_t(unsafe.Sizeof(num)), unsafe.Pointer(&num), nil)
-	return int(num), toError(err)
-}

Godeps/_workspace/src/github.com/Gustav-Simonsson/go-opencl/cl/kernel10.go

@@ -1,7 +0,0 @@
-// +build !cl12
-
-package cl
-
-func (k *Kernel) ArgName(index int) (string, error) {
-	return "", ErrUnsupported
-}

Godeps/_workspace/src/github.com/Gustav-Simonsson/go-opencl/cl/kernel12.go

@@ -1,20 +0,0 @@
-// +build cl12
-
-package cl
-
-// #ifdef __APPLE__
-// #include "OpenCL/opencl.h"
-// #else
-// #include "cl.h"
-// #endif
-import "C"
-import "unsafe"
-
-func (k *Kernel) ArgName(index int) (string, error) {
-	var strC [1024]byte
-	var strN C.size_t
-	if err := C.clGetKernelArgInfo(k.clKernel, C.cl_uint(index), C.CL_KERNEL_ARG_NAME, 1024, unsafe.Pointer(&strC[0]), &strN); err != C.CL_SUCCESS {
-		return "", toError(err)
-	}
-	return string(strC[:strN]), nil
-}

Godeps/_workspace/src/github.com/Gustav-Simonsson/go-opencl/cl/platform.go

@@ -1,83 +0,0 @@
-package cl
-
-// #ifdef __APPLE__
-// #include "OpenCL/opencl.h"
-// #else
-// #include "cl.h"
-// #endif
-import "C"
-
-import "unsafe"
-
-const maxPlatforms = 32
-
-type Platform struct {
-	id C.cl_platform_id
-}
-
-// Obtain the list of platforms available.
-func GetPlatforms() ([]*Platform, error) {
-	var platformIds [maxPlatforms]C.cl_platform_id
-	var nPlatforms C.cl_uint
-	if err := C.clGetPlatformIDs(C.cl_uint(maxPlatforms), &platformIds[0], &nPlatforms); err != C.CL_SUCCESS {
-		return nil, toError(err)
-	}
-	platforms := make([]*Platform, nPlatforms)
-	for i := 0; i < int(nPlatforms); i++ {
-		platforms[i] = &Platform{id: platformIds[i]}
-	}
-	return platforms, nil
-}
-
-func (p *Platform) GetDevices(deviceType DeviceType) ([]*Device, error) {
-	return GetDevices(p, deviceType)
-}
-
-func (p *Platform) getInfoString(param C.cl_platform_info) (string, error) {
-	var strC [2048]byte
-	var strN C.size_t
-	if err := C.clGetPlatformInfo(p.id, param, 2048, unsafe.Pointer(&strC[0]), &strN); err != C.CL_SUCCESS {
-		return "", toError(err)
-	}
-	return string(strC[:(strN - 1)]), nil
-}
-
-func (p *Platform) Name() string {
-	if str, err := p.getInfoString(C.CL_PLATFORM_NAME); err != nil {
-		panic("Platform.Name() should never fail")
-	} else {
-		return str
-	}
-}
-
-func (p *Platform) Vendor() string {
-	if str, err := p.getInfoString(C.CL_PLATFORM_VENDOR); err != nil {
-		panic("Platform.Vendor() should never fail")
-	} else {
-		return str
-	}
-}
-
-func (p *Platform) Profile() string {
-	if str, err := p.getInfoString(C.CL_PLATFORM_PROFILE); err != nil {
-		panic("Platform.Profile() should never fail")
-	} else {
-		return str
-	}
-}
-
-func (p *Platform) Version() string {
-	if str, err := p.getInfoString(C.CL_PLATFORM_VERSION); err != nil {
-		panic("Platform.Version() should never fail")
-	} else {
-		return str
-	}
-}
-
-func (p *Platform) Extensions() string {
-	if str, err := p.getInfoString(C.CL_PLATFORM_EXTENSIONS); err != nil {
-		panic("Platform.Extensions() should never fail")
-	} else {
-		return str
-	}
-}

Godeps/_workspace/src/github.com/Gustav-Simonsson/go-opencl/cl/program.go

@@ -1,105 +0,0 @@
-package cl
-
-// #include <stdlib.h>
-// #ifdef __APPLE__
-// #include "OpenCL/opencl.h"
-// #else
-// #include "cl.h"
-// #endif
-import "C"
-
-import (
-	"fmt"
-	"runtime"
-	"unsafe"
-)
-
-type BuildError struct {
-	Message string
-	Device  *Device
-}
-
-func (e BuildError) Error() string {
-	if e.Device != nil {
-		return fmt.Sprintf("cl: build error on %q: %s", e.Device.Name(), e.Message)
-	} else {
-		return fmt.Sprintf("cl: build error: %s", e.Message)
-	}
-}
-
-type Program struct {
-	clProgram C.cl_program
-	devices   []*Device
-}
-
-func releaseProgram(p *Program) {
-	if p.clProgram != nil {
-		C.clReleaseProgram(p.clProgram)
-		p.clProgram = nil
-	}
-}
-
-func (p *Program) Release() {
-	releaseProgram(p)
-}
-
-func (p *Program) BuildProgram(devices []*Device, options string) error {
-	var cOptions *C.char
-	if options != "" {
-		cOptions = C.CString(options)
-		defer C.free(unsafe.Pointer(cOptions))
-	}
-	var deviceList []C.cl_device_id
-	var deviceListPtr *C.cl_device_id
-	numDevices := C.cl_uint(len(devices))
-	if devices != nil && len(devices) > 0 {
-		deviceList = buildDeviceIdList(devices)
-		deviceListPtr = &deviceList[0]
-	}
-	if err := C.clBuildProgram(p.clProgram, numDevices, deviceListPtr, cOptions, nil, nil); err != C.CL_SUCCESS {
-		buffer := make([]byte, 4096)
-		var bLen C.size_t
-		var err C.cl_int
-
-		for _, dev := range p.devices {
-			for i := 2; i >= 0; i-- {
-				err = C.clGetProgramBuildInfo(p.clProgram, dev.id, C.CL_PROGRAM_BUILD_LOG, C.size_t(len(buffer)), unsafe.Pointer(&buffer[0]), &bLen)
-				if err == C.CL_INVALID_VALUE && i > 0 && bLen < 1024*1024 {
-					// INVALID_VALUE probably means our buffer isn't large enough
-					buffer = make([]byte, bLen)
-				} else {
-					break
-				}
-			}
-			if err != C.CL_SUCCESS {
-				return toError(err)
-			}
-
-			if bLen > 1 {
-				return BuildError{
-					Device:  dev,
-					Message: string(buffer[:bLen-1]),
-				}
-			}
-		}
-
-		return BuildError{
-			Device:  nil,
-			Message: "build failed and produced no log entries",
-		}
-	}
-	return nil
-}
-
-func (p *Program) CreateKernel(name string) (*Kernel, error) {
-	cName := C.CString(name)
-	defer C.free(unsafe.Pointer(cName))
-	var err C.cl_int
-	clKernel := C.clCreateKernel(p.clProgram, cName, &err)
-	if err != C.CL_SUCCESS {
-		return nil, toError(err)
-	}
-	kernel := &Kernel{clKernel: clKernel, name: name}
-	runtime.SetFinalizer(kernel, releaseKernel)
-	return kernel, nil
-}

Godeps/_workspace/src/github.com/Gustav-Simonsson/go-opencl/cl/queue.go

@@ -1,193 +0,0 @@
-package cl
-
-// #ifdef __APPLE__
-// #include "OpenCL/opencl.h"
-// #else
-// #include "cl.h"
-// #endif
-import "C"
-
-import "unsafe"
-
-type CommandQueueProperty int
-
-const (
-	CommandQueueOutOfOrderExecModeEnable CommandQueueProperty = C.CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE
-	CommandQueueProfilingEnable          CommandQueueProperty = C.CL_QUEUE_PROFILING_ENABLE
-)
-
-type CommandQueue struct {
-	clQueue C.cl_command_queue
-	device  *Device
-}
-
-func releaseCommandQueue(q *CommandQueue) {
-	if q.clQueue != nil {
-		C.clReleaseCommandQueue(q.clQueue)
-		q.clQueue = nil
-	}
-}
-
-// Call clReleaseCommandQueue on the CommandQueue. Using the CommandQueue after Release will cause a panick.
-func (q *CommandQueue) Release() {
-	releaseCommandQueue(q)
-}
-
-// Blocks until all previously queued OpenCL commands in a command-queue are issued to the associated device and have completed.
-func (q *CommandQueue) Finish() error {
-	return toError(C.clFinish(q.clQueue))
-}
-
-// Issues all previously queued OpenCL commands in a command-queue to the device associated with the command-queue.
-func (q *CommandQueue) Flush() error {
-	return toError(C.clFlush(q.clQueue))
-}
-
-// Enqueues a command to map a region of the buffer object given by buffer into the host address space and returns a pointer to this mapped region.
-func (q *CommandQueue) EnqueueMapBuffer(buffer *MemObject, blocking bool, flags MapFlag, offset, size int, eventWaitList []*Event) (*MappedMemObject, *Event, error) {
-	var event C.cl_event
-	var err C.cl_int
-	ptr := C.clEnqueueMapBuffer(q.clQueue, buffer.clMem, clBool(blocking), flags.toCl(), C.size_t(offset), C.size_t(size), C.cl_uint(len(eventWaitList)), eventListPtr(eventWaitList), &event, &err)
-	if err != C.CL_SUCCESS {
-		return nil, nil, toError(err)
-	}
-	ev := newEvent(event)
-	if ptr == nil {
-		return nil, ev, ErrUnknown
-	}
-	return &MappedMemObject{ptr: ptr, size: size}, ev, nil
-}
-
-// Enqueues a command to map a region of an image object into the host address space and returns a pointer to this mapped region.
-func (q *CommandQueue) EnqueueMapImage(buffer *MemObject, blocking bool, flags MapFlag, origin, region [3]int, eventWaitList []*Event) (*MappedMemObject, *Event, error) {
-	cOrigin := sizeT3(origin)
-	cRegion := sizeT3(region)
-	var event C.cl_event
-	var err C.cl_int
-	var rowPitch, slicePitch C.size_t
-	ptr := C.clEnqueueMapImage(q.clQueue, buffer.clMem, clBool(blocking), flags.toCl(), &cOrigin[0], &cRegion[0], &rowPitch, &slicePitch, C.cl_uint(len(eventWaitList)), eventListPtr(eventWaitList), &event, &err)
-	if err != C.CL_SUCCESS {
-		return nil, nil, toError(err)
-	}
-	ev := newEvent(event)
-	if ptr == nil {
-		return nil, ev, ErrUnknown
-	}
-	size := 0 // TODO: could calculate this
-	return &MappedMemObject{ptr: ptr, size: size, rowPitch: int(rowPitch), slicePitch: int(slicePitch)}, ev, nil
-}
-
-// Enqueues a command to unmap a previously mapped region of a memory object.
-func (q *CommandQueue) EnqueueUnmapMemObject(buffer *MemObject, mappedObj *MappedMemObject, eventWaitList []*Event) (*Event, error) {
-	var event C.cl_event
-	if err := C.clEnqueueUnmapMemObject(q.clQueue, buffer.clMem, mappedObj.ptr, C.cl_uint(len(eventWaitList)), eventListPtr(eventWaitList), &event); err != C.CL_SUCCESS {
-		return nil, toError(err)
-	}
-	return newEvent(event), nil
-}
-
-// Enqueues a command to copy a buffer object to another buffer object.
-func (q *CommandQueue) EnqueueCopyBuffer(srcBuffer, dstBuffer *MemObject, srcOffset, dstOffset, byteCount int, eventWaitList []*Event) (*Event, error) {
-	var event C.cl_event
-	err := toError(C.clEnqueueCopyBuffer(q.clQueue, srcBuffer.clMem, dstBuffer.clMem, C.size_t(srcOffset), C.size_t(dstOffset), C.size_t(byteCount), C.cl_uint(len(eventWaitList)), eventListPtr(eventWaitList), &event))
-	return newEvent(event), err
-}
-
-// Enqueue commands to write to a buffer object from host memory.
-func (q *CommandQueue) EnqueueWriteBuffer(buffer *MemObject, blocking bool, offset, dataSize int, dataPtr unsafe.Pointer, eventWaitList []*Event) (*Event, error) {
-	var event C.cl_event
-	err := toError(C.clEnqueueWriteBuffer(q.clQueue, buffer.clMem, clBool(blocking), C.size_t(offset), C.size_t(dataSize), dataPtr, C.cl_uint(len(eventWaitList)), eventListPtr(eventWaitList), &event))
-	return newEvent(event), err
-}
-
-func (q *CommandQueue) EnqueueWriteBufferFloat32(buffer *MemObject, blocking bool, offset int, data []float32, eventWaitList []*Event) (*Event, error) {
-	dataPtr := unsafe.Pointer(&data[0])
-	dataSize := int(unsafe.Sizeof(data[0])) * len(data)
-	return q.EnqueueWriteBuffer(buffer, blocking, offset, dataSize, dataPtr, eventWaitList)
-}
-
-// Enqueue commands to read from a buffer object to host memory.
-func (q *CommandQueue) EnqueueReadBuffer(buffer *MemObject, blocking bool, offset, dataSize int, dataPtr unsafe.Pointer, eventWaitList []*Event) (*Event, error) {
-	var event C.cl_event
-	err := toError(C.clEnqueueReadBuffer(q.clQueue, buffer.clMem, clBool(blocking), C.size_t(offset), C.size_t(dataSize), dataPtr, C.cl_uint(len(eventWaitList)), eventListPtr(eventWaitList), &event))
-	return newEvent(event), err
-}
-
-func (q *CommandQueue) EnqueueReadBufferFloat32(buffer *MemObject, blocking bool, offset int, data []float32, eventWaitList []*Event) (*Event, error) {
-	dataPtr := unsafe.Pointer(&data[0])
-	dataSize := int(unsafe.Sizeof(data[0])) * len(data)
-	return q.EnqueueReadBuffer(buffer, blocking, offset, dataSize, dataPtr, eventWaitList)
-}
-
-// Enqueues a command to execute a kernel on a device.
-func (q *CommandQueue) EnqueueNDRangeKernel(kernel *Kernel, globalWorkOffset, globalWorkSize, localWorkSize []int, eventWaitList []*Event) (*Event, error) {
-	workDim := len(globalWorkSize)
-	var globalWorkOffsetList []C.size_t
-	var globalWorkOffsetPtr *C.size_t
-	if globalWorkOffset != nil {
-		globalWorkOffsetList = make([]C.size_t, len(globalWorkOffset))
-		for i, off := range globalWorkOffset {
-			globalWorkOffsetList[i] = C.size_t(off)
-		}
-		globalWorkOffsetPtr = &globalWorkOffsetList[0]
-	}
-	var globalWorkSizeList []C.size_t
-	var globalWorkSizePtr *C.size_t
-	if globalWorkSize != nil {
-		globalWorkSizeList = make([]C.size_t, len(globalWorkSize))
-		for i, off := range globalWorkSize {
-			globalWorkSizeList[i] = C.size_t(off)
-		}
-		globalWorkSizePtr = &globalWorkSizeList[0]
-	}
-	var localWorkSizeList []C.size_t
-	var localWorkSizePtr *C.size_t
-	if localWorkSize != nil {
-		localWorkSizeList = make([]C.size_t, len(localWorkSize))
-		for i, off := range localWorkSize {
-			localWorkSizeList[i] = C.size_t(off)
-		}
-		localWorkSizePtr = &localWorkSizeList[0]
-	}
-	var event C.cl_event
-	err := toError(C.clEnqueueNDRangeKernel(q.clQueue, kernel.clKernel, C.cl_uint(workDim), globalWorkOffsetPtr, globalWorkSizePtr, localWorkSizePtr, C.cl_uint(len(eventWaitList)), eventListPtr(eventWaitList), &event))
-	return newEvent(event), err
-}
-
-// Enqueues a command to read from a 2D or 3D image object to host memory.
-func (q *CommandQueue) EnqueueReadImage(image *MemObject, blocking bool, origin, region [3]int, rowPitch, slicePitch int, data []byte, eventWaitList []*Event) (*Event, error) {
-	cOrigin := sizeT3(origin)
-	cRegion := sizeT3(region)
-	var event C.cl_event
-	err := toError(C.clEnqueueReadImage(q.clQueue, image.clMem, clBool(blocking), &cOrigin[0], &cRegion[0], C.size_t(rowPitch), C.size_t(slicePitch), unsafe.Pointer(&data[0]), C.cl_uint(len(eventWaitList)), eventListPtr(eventWaitList), &event))
-	return newEvent(event), err
-}
-
-// Enqueues a command to write from a 2D or 3D image object to host memory.
-func (q *CommandQueue) EnqueueWriteImage(image *MemObject, blocking bool, origin, region [3]int, rowPitch, slicePitch int, data []byte, eventWaitList []*Event) (*Event, error) {
-	cOrigin := sizeT3(origin)
-	cRegion := sizeT3(region)
-	var event C.cl_event
-	err := toError(C.clEnqueueWriteImage(q.clQueue, image.clMem, clBool(blocking), &cOrigin[0], &cRegion[0], C.size_t(rowPitch), C.size_t(slicePitch), unsafe.Pointer(&data[0]), C.cl_uint(len(eventWaitList)), eventListPtr(eventWaitList), &event))
-	return newEvent(event), err
-}
-
-func (q *CommandQueue) EnqueueFillBuffer(buffer *MemObject, pattern unsafe.Pointer, patternSize, offset, size int, eventWaitList []*Event) (*Event, error) {
-	var event C.cl_event
-	err := toError(C.clEnqueueFillBuffer(q.clQueue, buffer.clMem, pattern, C.size_t(patternSize), C.size_t(offset), C.size_t(size), C.cl_uint(len(eventWaitList)), eventListPtr(eventWaitList), &event))
-	return newEvent(event), err
-}
-
-// A synchronization point that enqueues a barrier operation.
-func (q *CommandQueue) EnqueueBarrierWithWaitList(eventWaitList []*Event) (*Event, error) {
-	var event C.cl_event
-	err := toError(C.clEnqueueBarrierWithWaitList(q.clQueue, C.cl_uint(len(eventWaitList)), eventListPtr(eventWaitList), &event))
-	return newEvent(event), err
-}
-
-// Enqueues a marker command which waits for either a list of events to complete, or all previously enqueued commands to complete.
-func (q *CommandQueue) EnqueueMarkerWithWaitList(eventWaitList []*Event) (*Event, error) {
-	var event C.cl_event
-	err := toError(C.clEnqueueMarkerWithWaitList(q.clQueue, C.cl_uint(len(eventWaitList)), eventListPtr(eventWaitList), &event))
-	return newEvent(event), err
-}

Godeps/_workspace/src/github.com/Gustav-Simonsson/go-opencl/cl/types.go

@@ -1,487 +0,0 @@
-package cl
-
-// #ifdef __APPLE__
-// #include "OpenCL/opencl.h"
-// #else
-// #include "cl.h"
-// #endif
-import "C"
-
-import (
-	"errors"
-	"fmt"
-	"reflect"
-	"runtime"
-	"strings"
-	"unsafe"
-)
-
-var (
-	ErrUnknown = errors.New("cl: unknown error") // Generally an unexpected result from an OpenCL function (e.g. CL_SUCCESS but null pointer)
-)
-
-type ErrOther int
-
-func (e ErrOther) Error() string {
-	return fmt.Sprintf("cl: error %d", int(e))
-}
-
-var (
-	ErrDeviceNotFound                     = errors.New("cl: Device Not Found")
-	ErrDeviceNotAvailable                 = errors.New("cl: Device Not Available")
-	ErrCompilerNotAvailable               = errors.New("cl: Compiler Not Available")
-	ErrMemObjectAllocationFailure         = errors.New("cl: Mem Object Allocation Failure")
-	ErrOutOfResources                     = errors.New("cl: Out Of Resources")
-	ErrOutOfHostMemory                    = errors.New("cl: Out Of Host Memory")
-	ErrProfilingInfoNotAvailable          = errors.New("cl: Profiling Info Not Available")
-	ErrMemCopyOverlap                     = errors.New("cl: Mem Copy Overlap")
-	ErrImageFormatMismatch                = errors.New("cl: Image Format Mismatch")
-	ErrImageFormatNotSupported            = errors.New("cl: Image Format Not Supported")
-	ErrBuildProgramFailure                = errors.New("cl: Build Program Failure")
-	ErrMapFailure                         = errors.New("cl: Map Failure")
-	ErrMisalignedSubBufferOffset          = errors.New("cl: Misaligned Sub Buffer Offset")
-	ErrExecStatusErrorForEventsInWaitList = errors.New("cl: Exec Status Error For Events In Wait List")
-	ErrCompileProgramFailure              = errors.New("cl: Compile Program Failure")
-	ErrLinkerNotAvailable                 = errors.New("cl: Linker Not Available")
-	ErrLinkProgramFailure                 = errors.New("cl: Link Program Failure")
-	ErrDevicePartitionFailed              = errors.New("cl: Device Partition Failed")
-	ErrKernelArgInfoNotAvailable          = errors.New("cl: Kernel Arg Info Not Available")
-	ErrInvalidValue                       = errors.New("cl: Invalid Value")
-	ErrInvalidDeviceType                  = errors.New("cl: Invalid Device Type")
-	ErrInvalidPlatform                    = errors.New("cl: Invalid Platform")
-	ErrInvalidDevice                      = errors.New("cl: Invalid Device")
-	ErrInvalidContext                     = errors.New("cl: Invalid Context")
-	ErrInvalidQueueProperties             = errors.New("cl: Invalid Queue Properties")
-	ErrInvalidCommandQueue                = errors.New("cl: Invalid Command Queue")
-	ErrInvalidHostPtr                     = errors.New("cl: Invalid Host Ptr")
-	ErrInvalidMemObject                   = errors.New("cl: Invalid Mem Object")
-	ErrInvalidImageFormatDescriptor       = errors.New("cl: Invalid Image Format Descriptor")
-	ErrInvalidImageSize                   = errors.New("cl: Invalid Image Size")
-	ErrInvalidSampler                     = errors.New("cl: Invalid Sampler")
-	ErrInvalidBinary                      = errors.New("cl: Invalid Binary")
-	ErrInvalidBuildOptions                = errors.New("cl: Invalid Build Options")
-	ErrInvalidProgram                     = errors.New("cl: Invalid Program")
-	ErrInvalidProgramExecutable           = errors.New("cl: Invalid Program Executable")
-	ErrInvalidKernelName                  = errors.New("cl: Invalid Kernel Name")
-	ErrInvalidKernelDefinition            = errors.New("cl: Invalid Kernel Definition")
-	ErrInvalidKernel                      = errors.New("cl: Invalid Kernel")
-	ErrInvalidArgIndex                    = errors.New("cl: Invalid Arg Index")
-	ErrInvalidArgValue                    = errors.New("cl: Invalid Arg Value")
-	ErrInvalidArgSize                     = errors.New("cl: Invalid Arg Size")
-	ErrInvalidKernelArgs                  = errors.New("cl: Invalid Kernel Args")
-	ErrInvalidWorkDimension               = errors.New("cl: Invalid Work Dimension")
-	ErrInvalidWorkGroupSize               = errors.New("cl: Invalid Work Group Size")
-	ErrInvalidWorkItemSize                = errors.New("cl: Invalid Work Item Size")
-	ErrInvalidGlobalOffset                = errors.New("cl: Invalid Global Offset")
-	ErrInvalidEventWaitList               = errors.New("cl: Invalid Event Wait List")
-	ErrInvalidEvent                       = errors.New("cl: Invalid Event")
-	ErrInvalidOperation                   = errors.New("cl: Invalid Operation")
-	ErrInvalidGlObject                    = errors.New("cl: Invalid Gl Object")
-	ErrInvalidBufferSize                  = errors.New("cl: Invalid Buffer Size")
-	ErrInvalidMipLevel                    = errors.New("cl: Invalid Mip Level")
-	ErrInvalidGlobalWorkSize              = errors.New("cl: Invalid Global Work Size")
-	ErrInvalidProperty                    = errors.New("cl: Invalid Property")
-	ErrInvalidImageDescriptor             = errors.New("cl: Invalid Image Descriptor")
-	ErrInvalidCompilerOptions             = errors.New("cl: Invalid Compiler Options")
-	ErrInvalidLinkerOptions               = errors.New("cl: Invalid Linker Options")
-	ErrInvalidDevicePartitionCount        = errors.New("cl: Invalid Device Partition Count")
-)
-var errorMap = map[C.cl_int]error{
-	C.CL_SUCCESS:                                   nil,
-	C.CL_DEVICE_NOT_FOUND:                          ErrDeviceNotFound,
-	C.CL_DEVICE_NOT_AVAILABLE:                      ErrDeviceNotAvailable,
-	C.CL_COMPILER_NOT_AVAILABLE:                    ErrCompilerNotAvailable,
-	C.CL_MEM_OBJECT_ALLOCATION_FAILURE:             ErrMemObjectAllocationFailure,
-	C.CL_OUT_OF_RESOURCES:                          ErrOutOfResources,
-	C.CL_OUT_OF_HOST_MEMORY:                        ErrOutOfHostMemory,
-	C.CL_PROFILING_INFO_NOT_AVAILABLE:              ErrProfilingInfoNotAvailable,
-	C.CL_MEM_COPY_OVERLAP:                          ErrMemCopyOverlap,
-	C.CL_IMAGE_FORMAT_MISMATCH:                     ErrImageFormatMismatch,
-	C.CL_IMAGE_FORMAT_NOT_SUPPORTED:                ErrImageFormatNotSupported,
-	C.CL_BUILD_PROGRAM_FAILURE:                     ErrBuildProgramFailure,
-	C.CL_MAP_FAILURE:                               ErrMapFailure,
-	C.CL_MISALIGNED_SUB_BUFFER_OFFSET:              ErrMisalignedSubBufferOffset,
-	C.CL_EXEC_STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST: ErrExecStatusErrorForEventsInWaitList,
-	C.CL_INVALID_VALUE:                             ErrInvalidValue,
-	C.CL_INVALID_DEVICE_TYPE:                       ErrInvalidDeviceType,
-	C.CL_INVALID_PLATFORM:                          ErrInvalidPlatform,
-	C.CL_INVALID_DEVICE:                            ErrInvalidDevice,
-	C.CL_INVALID_CONTEXT:                           ErrInvalidContext,
-	C.CL_INVALID_QUEUE_PROPERTIES:                  ErrInvalidQueueProperties,
-	C.CL_INVALID_COMMAND_QUEUE:                     ErrInvalidCommandQueue,
-	C.CL_INVALID_HOST_PTR:                          ErrInvalidHostPtr,
-	C.CL_INVALID_MEM_OBJECT:                        ErrInvalidMemObject,
-	C.CL_INVALID_IMAGE_FORMAT_DESCRIPTOR:           ErrInvalidImageFormatDescriptor,
-	C.CL_INVALID_IMAGE_SIZE:                        ErrInvalidImageSize,
-	C.CL_INVALID_SAMPLER:                           ErrInvalidSampler,
-	C.CL_INVALID_BINARY:                            ErrInvalidBinary,
-	C.CL_INVALID_BUILD_OPTIONS:                     ErrInvalidBuildOptions,
-	C.CL_INVALID_PROGRAM:                           ErrInvalidProgram,
-	C.CL_INVALID_PROGRAM_EXECUTABLE:                ErrInvalidProgramExecutable,
-	C.CL_INVALID_KERNEL_NAME:                       ErrInvalidKernelName,
-	C.CL_INVALID_KERNEL_DEFINITION:                 ErrInvalidKernelDefinition,
-	C.CL_INVALID_KERNEL:                            ErrInvalidKernel,
-	C.CL_INVALID_ARG_INDEX:                         ErrInvalidArgIndex,
-	C.CL_INVALID_ARG_VALUE:                         ErrInvalidArgValue,
-	C.CL_INVALID_ARG_SIZE:                          ErrInvalidArgSize,
-	C.CL_INVALID_KERNEL_ARGS:                       ErrInvalidKernelArgs,
-	C.CL_INVALID_WORK_DIMENSION:                    ErrInvalidWorkDimension,
-	C.CL_INVALID_WORK_GROUP_SIZE:                   ErrInvalidWorkGroupSize,
-	C.CL_INVALID_WORK_ITEM_SIZE:                    ErrInvalidWorkItemSize,
-	C.CL_INVALID_GLOBAL_OFFSET:                     ErrInvalidGlobalOffset,
-	C.CL_INVALID_EVENT_WAIT_LIST:                   ErrInvalidEventWaitList,
-	C.CL_INVALID_EVENT:                             ErrInvalidEvent,
-	C.CL_INVALID_OPERATION:                         ErrInvalidOperation,
-	C.CL_INVALID_GL_OBJECT:                         ErrInvalidGlObject,
-	C.CL_INVALID_BUFFER_SIZE:                       ErrInvalidBufferSize,
-	C.CL_INVALID_MIP_LEVEL:                         ErrInvalidMipLevel,
-	C.CL_INVALID_GLOBAL_WORK_SIZE:                  ErrInvalidGlobalWorkSize,
-	C.CL_INVALID_PROPERTY:                          ErrInvalidProperty,
-}
-
-func toError(code C.cl_int) error {
-	if err, ok := errorMap[code]; ok {
-		return err
-	}
-	return ErrOther(code)
-}
-
-type LocalMemType int
-
-const (
-	LocalMemTypeNone   LocalMemType = C.CL_NONE
-	LocalMemTypeGlobal LocalMemType = C.CL_GLOBAL
-	LocalMemTypeLocal  LocalMemType = C.CL_LOCAL
-)
-
-var localMemTypeMap = map[LocalMemType]string{
-	LocalMemTypeNone:   "None",
-	LocalMemTypeGlobal: "Global",
-	LocalMemTypeLocal:  "Local",
-}
-
-func (t LocalMemType) String() string {
-	name := localMemTypeMap[t]
-	if name == "" {
-		name = "Unknown"
-	}
-	return name
-}
-
-type ExecCapability int
-
-const (
-	ExecCapabilityKernel       ExecCapability = C.CL_EXEC_KERNEL        // The OpenCL device can execute OpenCL kernels.
-	ExecCapabilityNativeKernel ExecCapability = C.CL_EXEC_NATIVE_KERNEL // The OpenCL device can execute native kernels.
-)
-
-func (ec ExecCapability) String() string {
-	var parts []string
-	if ec&ExecCapabilityKernel != 0 {
-		parts = append(parts, "Kernel")
-	}
-	if ec&ExecCapabilityNativeKernel != 0 {
-		parts = append(parts, "NativeKernel")
-	}
-	if parts == nil {
-		return ""
-	}
-	return strings.Join(parts, "|")
-}
-
-type MemCacheType int
-
-const (
-	MemCacheTypeNone           MemCacheType = C.CL_NONE
-	MemCacheTypeReadOnlyCache  MemCacheType = C.CL_READ_ONLY_CACHE
-	MemCacheTypeReadWriteCache MemCacheType = C.CL_READ_WRITE_CACHE
-)
-
-func (ct MemCacheType) String() string {
-	switch ct {
-	case MemCacheTypeNone:
-		return "None"
-	case MemCacheTypeReadOnlyCache:
-		return "ReadOnly"
-	case MemCacheTypeReadWriteCache:
-		return "ReadWrite"
-	}
-	return fmt.Sprintf("Unknown(%x)", int(ct))
-}
-
-type MemFlag int
-
-const (
-	MemReadWrite    MemFlag = C.CL_MEM_READ_WRITE
-	MemWriteOnly    MemFlag = C.CL_MEM_WRITE_ONLY
-	MemReadOnly     MemFlag = C.CL_MEM_READ_ONLY
-	MemUseHostPtr   MemFlag = C.CL_MEM_USE_HOST_PTR
-	MemAllocHostPtr MemFlag = C.CL_MEM_ALLOC_HOST_PTR
-	MemCopyHostPtr  MemFlag = C.CL_MEM_COPY_HOST_PTR
-
-	MemWriteOnlyHost MemFlag = C.CL_MEM_HOST_WRITE_ONLY
-	MemReadOnlyHost  MemFlag = C.CL_MEM_HOST_READ_ONLY
-	MemNoAccessHost  MemFlag = C.CL_MEM_HOST_NO_ACCESS
-)
-
-type MemObjectType int
-
-const (
-	MemObjectTypeBuffer  MemObjectType = C.CL_MEM_OBJECT_BUFFER
-	MemObjectTypeImage2D MemObjectType = C.CL_MEM_OBJECT_IMAGE2D
-	MemObjectTypeImage3D MemObjectType = C.CL_MEM_OBJECT_IMAGE3D
-)
-
-type MapFlag int
-
-const (
-	// This flag specifies that the region being mapped in the memory object is being mapped for reading.
-	MapFlagRead                  MapFlag = C.CL_MAP_READ
-	MapFlagWrite                 MapFlag = C.CL_MAP_WRITE
-	MapFlagWriteInvalidateRegion MapFlag = C.CL_MAP_WRITE_INVALIDATE_REGION
-)
-
-func (mf MapFlag) toCl() C.cl_map_flags {
-	return C.cl_map_flags(mf)
-}
-
-type ChannelOrder int
-
-const (
-	ChannelOrderR         ChannelOrder = C.CL_R
-	ChannelOrderA         ChannelOrder = C.CL_A
-	ChannelOrderRG        ChannelOrder = C.CL_RG
-	ChannelOrderRA        ChannelOrder = C.CL_RA
-	ChannelOrderRGB       ChannelOrder = C.CL_RGB
-	ChannelOrderRGBA      ChannelOrder = C.CL_RGBA
-	ChannelOrderBGRA      ChannelOrder = C.CL_BGRA
-	ChannelOrderARGB      ChannelOrder = C.CL_ARGB
-	ChannelOrderIntensity ChannelOrder = C.CL_INTENSITY
-	ChannelOrderLuminance ChannelOrder = C.CL_LUMINANCE
-	ChannelOrderRx        ChannelOrder = C.CL_Rx
-	ChannelOrderRGx       ChannelOrder = C.CL_RGx
-	ChannelOrderRGBx      ChannelOrder = C.CL_RGBx
-)
-
-var channelOrderNameMap = map[ChannelOrder]string{
-	ChannelOrderR:         "R",
-	ChannelOrderA:         "A",
-	ChannelOrderRG:        "RG",
-	ChannelOrderRA:        "RA",
-	ChannelOrderRGB:       "RGB",
-	ChannelOrderRGBA:      "RGBA",
-	ChannelOrderBGRA:      "BGRA",
-	ChannelOrderARGB:      "ARGB",
-	ChannelOrderIntensity: "Intensity",
-	ChannelOrderLuminance: "Luminance",
-	ChannelOrderRx:        "Rx",
-	ChannelOrderRGx:       "RGx",
-	ChannelOrderRGBx:      "RGBx",
-}
-
-func (co ChannelOrder) String() string {
-	name := channelOrderNameMap[co]
-	if name == "" {
-		name = fmt.Sprintf("Unknown(%x)", int(co))
-	}
-	return name
-}
-
-type ChannelDataType int
-
-const (
-	ChannelDataTypeSNormInt8      ChannelDataType = C.CL_SNORM_INT8
-	ChannelDataTypeSNormInt16     ChannelDataType = C.CL_SNORM_INT16
-	ChannelDataTypeUNormInt8      ChannelDataType = C.CL_UNORM_INT8
-	ChannelDataTypeUNormInt16     ChannelDataType = C.CL_UNORM_INT16
-	ChannelDataTypeUNormShort565  ChannelDataType = C.CL_UNORM_SHORT_565
-	ChannelDataTypeUNormShort555  ChannelDataType = C.CL_UNORM_SHORT_555
-	ChannelDataTypeUNormInt101010 ChannelDataType = C.CL_UNORM_INT_101010
-	ChannelDataTypeSignedInt8     ChannelDataType = C.CL_SIGNED_INT8
-	ChannelDataTypeSignedInt16    ChannelDataType = C.CL_SIGNED_INT16
-	ChannelDataTypeSignedInt32    ChannelDataType = C.CL_SIGNED_INT32
-	ChannelDataTypeUnsignedInt8   ChannelDataType = C.CL_UNSIGNED_INT8
-	ChannelDataTypeUnsignedInt16  ChannelDataType = C.CL_UNSIGNED_INT16
-	ChannelDataTypeUnsignedInt32  ChannelDataType = C.CL_UNSIGNED_INT32
-	ChannelDataTypeHalfFloat      ChannelDataType = C.CL_HALF_FLOAT
-	ChannelDataTypeFloat          ChannelDataType = C.CL_FLOAT
-)
-
-var channelDataTypeNameMap = map[ChannelDataType]string{
-	ChannelDataTypeSNormInt8:      "SNormInt8",
-	ChannelDataTypeSNormInt16:     "SNormInt16",
-	ChannelDataTypeUNormInt8:      "UNormInt8",
-	ChannelDataTypeUNormInt16:     "UNormInt16",
-	ChannelDataTypeUNormShort565:  "UNormShort565",
-	ChannelDataTypeUNormShort555:  "UNormShort555",
-	ChannelDataTypeUNormInt101010: "UNormInt101010",
-	ChannelDataTypeSignedInt8:     "SignedInt8",
-	ChannelDataTypeSignedInt16:    "SignedInt16",
-	ChannelDataTypeSignedInt32:    "SignedInt32",
-	ChannelDataTypeUnsignedInt8:   "UnsignedInt8",
-	ChannelDataTypeUnsignedInt16:  "UnsignedInt16",
-	ChannelDataTypeUnsignedInt32:  "UnsignedInt32",
-	ChannelDataTypeHalfFloat:      "HalfFloat",
-	ChannelDataTypeFloat:          "Float",
-}
-
-func (ct ChannelDataType) String() string {
-	name := channelDataTypeNameMap[ct]
-	if name == "" {
-		name = fmt.Sprintf("Unknown(%x)", int(ct))
-	}
-	return name
-}
-
-type ImageFormat struct {
-	ChannelOrder    ChannelOrder
-	ChannelDataType ChannelDataType
-}
-
-func (f ImageFormat) toCl() C.cl_image_format {
-	var format C.cl_image_format
-	format.image_channel_order = C.cl_channel_order(f.ChannelOrder)
-	format.image_channel_data_type = C.cl_channel_type(f.ChannelDataType)
-	return format
-}
-
-type ProfilingInfo int
-
-const (
-	// A 64-bit value that describes the current device time counter in
-	// nanoseconds when the command identified by event is enqueued in
-	// a command-queue by the host.
-	ProfilingInfoCommandQueued ProfilingInfo = C.CL_PROFILING_COMMAND_QUEUED
-	// A 64-bit value that describes the current device time counter in
-	// nanoseconds when the command identified by event that has been
-	// enqueued is submitted by the host to the device associated with the command-queue.
-	ProfilingInfoCommandSubmit ProfilingInfo = C.CL_PROFILING_COMMAND_SUBMIT
-	// A 64-bit value that describes the current device time counter in
-	// nanoseconds when the command identified by event starts execution on the device.
-	ProfilingInfoCommandStart ProfilingInfo = C.CL_PROFILING_COMMAND_START
-	// A 64-bit value that describes the current device time counter in
-	// nanoseconds when the command identified by event has finished
-	// execution on the device.
-	ProfilingInfoCommandEnd ProfilingInfo = C.CL_PROFILING_COMMAND_END
-)
-
-type CommmandExecStatus int
-
-const (
-	CommmandExecStatusComplete  CommmandExecStatus = C.CL_COMPLETE
-	CommmandExecStatusRunning   CommmandExecStatus = C.CL_RUNNING
-	CommmandExecStatusSubmitted CommmandExecStatus = C.CL_SUBMITTED
-	CommmandExecStatusQueued    CommmandExecStatus = C.CL_QUEUED
-)
-
-type Event struct {
-	clEvent C.cl_event
-}
-
-func releaseEvent(ev *Event) {
-	if ev.clEvent != nil {
-		C.clReleaseEvent(ev.clEvent)
-		ev.clEvent = nil
-	}
-}
-
-func (e *Event) Release() {
-	releaseEvent(e)
-}
-
-func (e *Event) GetEventProfilingInfo(paramName ProfilingInfo) (int64, error) {
-	var paramValue C.cl_ulong
-	if err := C.clGetEventProfilingInfo(e.clEvent, C.cl_profiling_info(paramName), C.size_t(unsafe.Sizeof(paramValue)), unsafe.Pointer(&paramValue), nil); err != C.CL_SUCCESS {
-		return 0, toError(err)
-	}
-	return int64(paramValue), nil
-}
-
-// Sets the execution status of a user event object.
-//
-// `status` specifies the new execution status to be set and
-// can be CL_COMPLETE or a negative integer value to indicate
-// an error. A negative integer value causes all enqueued commands
-// that wait on this user event to be terminated. clSetUserEventStatus
-// can only be called once to change the execution status of event.
-func (e *Event) SetUserEventStatus(status int) error {
-	return toError(C.clSetUserEventStatus(e.clEvent, C.cl_int(status)))
-}
-
-// Waits on the host thread for commands identified by event objects in
-// events to complete. A command is considered complete if its execution
-// status is CL_COMPLETE or a negative value. The events specified in
-// event_list act as synchronization points.
-//
-// If the cl_khr_gl_event extension is enabled, event objects can also be
-// used to reflect the status of an OpenGL sync object. The sync object
-// in turn refers to a fence command executing in an OpenGL command
-// stream. This provides another method of coordinating sharing of buffers
-// and images between OpenGL and OpenCL.
-func WaitForEvents(events []*Event) error {
-	return toError(C.clWaitForEvents(C.cl_uint(len(events)), eventListPtr(events)))
-}
-
-func newEvent(clEvent C.cl_event) *Event {
-	ev := &Event{clEvent: clEvent}
-	runtime.SetFinalizer(ev, releaseEvent)
-	return ev
-}
-
-func eventListPtr(el []*Event) *C.cl_event {
-	if el == nil {
-		return nil
-	}
-	elist := make([]C.cl_event, len(el))
-	for i, e := range el {
-		elist[i] = e.clEvent
-	}
-	return (*C.cl_event)(&elist[0])
-}
-
-func clBool(b bool) C.cl_bool {
-	if b {
-		return C.CL_TRUE
-	}
-	return C.CL_FALSE
-}
-
-func sizeT3(i3 [3]int) [3]C.size_t {
-	var val [3]C.size_t
-	val[0] = C.size_t(i3[0])
-	val[1] = C.size_t(i3[1])
-	val[2] = C.size_t(i3[2])
-	return val
-}
-
-type MappedMemObject struct {
-	ptr        unsafe.Pointer
-	size       int
-	rowPitch   int
-	slicePitch int
-}
-
-func (mb *MappedMemObject) ByteSlice() []byte {
-	var byteSlice []byte
-	sliceHeader := (*reflect.SliceHeader)(unsafe.Pointer(&byteSlice))
-	sliceHeader.Cap = mb.size
-	sliceHeader.Len = mb.size
-	sliceHeader.Data = uintptr(mb.ptr)
-	return byteSlice
-}
-
-func (mb *MappedMemObject) Ptr() unsafe.Pointer {
-	return mb.ptr
-}
-
-func (mb *MappedMemObject) Size() int {
-	return mb.size
-}
-
-func (mb *MappedMemObject) RowPitch() int {
-	return mb.rowPitch
-}
-
-func (mb *MappedMemObject) SlicePitch() int {
-	return mb.slicePitch
-}

Godeps/_workspace/src/github.com/Gustav-Simonsson/go-opencl/cl/types12.go

@@ -1,71 +0,0 @@
-// +build cl12
-
-package cl
-
-// #ifdef __APPLE__
-// #include "OpenCL/opencl.h"
-// #else
-// #include "cl.h"
-// #endif
-import "C"
-
-const (
-	ChannelDataTypeUNormInt24  ChannelDataType = C.CL_UNORM_INT24
-	ChannelOrderDepth          ChannelOrder    = C.CL_DEPTH
-	ChannelOrderDepthStencil   ChannelOrder    = C.CL_DEPTH_STENCIL
-	MemHostNoAccess            MemFlag         = C.CL_MEM_HOST_NO_ACCESS  // OpenCL 1.2
-	MemHostReadOnly            MemFlag         = C.CL_MEM_HOST_READ_ONLY  // OpenCL 1.2
-	MemHostWriteOnly           MemFlag         = C.CL_MEM_HOST_WRITE_ONLY // OpenCL 1.2
-	MemObjectTypeImage1D       MemObjectType   = C.CL_MEM_OBJECT_IMAGE1D
-	MemObjectTypeImage1DArray  MemObjectType   = C.CL_MEM_OBJECT_IMAGE1D_ARRAY
-	MemObjectTypeImage1DBuffer MemObjectType   = C.CL_MEM_OBJECT_IMAGE1D_BUFFER
-	MemObjectTypeImage2DArray  MemObjectType   = C.CL_MEM_OBJECT_IMAGE2D_ARRAY
-	// This flag specifies that the region being mapped in the memory object is being mapped for writing.
-	//
-	// The contents of the region being mapped are to be discarded. This is typically the case when the
-	// region being mapped is overwritten by the host. This flag allows the implementation to no longer
-	// guarantee that the pointer returned by clEnqueueMapBuffer or clEnqueueMapImage contains the
-	// latest bits in the region being mapped which can be a significant performance enhancement.
-	MapFlagWriteInvalidateRegion MapFlag = C.CL_MAP_WRITE_INVALIDATE_REGION
-)
-
-func init() {
-	errorMap[C.CL_COMPILE_PROGRAM_FAILURE] = ErrCompileProgramFailure
-	errorMap[C.CL_DEVICE_PARTITION_FAILED] = ErrDevicePartitionFailed
-	errorMap[C.CL_INVALID_COMPILER_OPTIONS] = ErrInvalidCompilerOptions
-	errorMap[C.CL_INVALID_DEVICE_PARTITION_COUNT] = ErrInvalidDevicePartitionCount
-	errorMap[C.CL_INVALID_IMAGE_DESCRIPTOR] = ErrInvalidImageDescriptor
-	errorMap[C.CL_INVALID_LINKER_OPTIONS] = ErrInvalidLinkerOptions
-	errorMap[C.CL_KERNEL_ARG_INFO_NOT_AVAILABLE] = ErrKernelArgInfoNotAvailable
-	errorMap[C.CL_LINK_PROGRAM_FAILURE] = ErrLinkProgramFailure
-	errorMap[C.CL_LINKER_NOT_AVAILABLE] = ErrLinkerNotAvailable
-	channelOrderNameMap[ChannelOrderDepth] = "Depth"
-	channelOrderNameMap[ChannelOrderDepthStencil] = "DepthStencil"
-	channelDataTypeNameMap[ChannelDataTypeUNormInt24] = "UNormInt24"
-}
-
-type ImageDescription struct {
-	Type                            MemObjectType
-	Width, Height, Depth            int
-	ArraySize, RowPitch, SlicePitch int
-	NumMipLevels, NumSamples        int
-	Buffer                          *MemObject
-}
-
-func (d ImageDescription) toCl() C.cl_image_desc {
-	var desc C.cl_image_desc
-	desc.image_type = C.cl_mem_object_type(d.Type)
-	desc.image_width = C.size_t(d.Width)
-	desc.image_height = C.size_t(d.Height)
-	desc.image_depth = C.size_t(d.Depth)
-	desc.image_array_size = C.size_t(d.ArraySize)
-	desc.image_row_pitch = C.size_t(d.RowPitch)
-	desc.image_slice_pitch = C.size_t(d.SlicePitch)
-	desc.num_mip_levels = C.cl_uint(d.NumMipLevels)
-	desc.num_samples = C.cl_uint(d.NumSamples)
-	desc.buffer = nil
-	if d.Buffer != nil {
-		desc.buffer = d.Buffer.clMem
-	}
-	return desc
-}

Godeps/_workspace/src/github.com/Gustav-Simonsson/go-opencl/cl/types_darwin.go

@@ -1,45 +0,0 @@
-package cl
-
-// #ifdef __APPLE__
-// #include "OpenCL/opencl.h"
-// #else
-// #include "cl.h"
-// #endif
-import "C"
-
-// Extension: cl_APPLE_fixed_alpha_channel_orders
-//
-// These selectors may be passed to clCreateImage2D() in the cl_image_format.image_channel_order field.
-// They are like CL_BGRA and CL_ARGB except that the alpha channel to be ignored.  On calls to read_imagef,
-// the alpha will be 0xff (1.0f) if the sample falls in the image and 0 if it does not fall in the image.
-// On calls to write_imagef, the alpha value is ignored and 0xff (1.0f) is written. These formats are
-// currently only available for the CL_UNORM_INT8 cl_channel_type. They are intended to support legacy
-// image formats.
-const (
-	ChannelOrder1RGBApple ChannelOrder = C.CL_1RGB_APPLE // Introduced in MacOS X.7.
-	ChannelOrderBGR1Apple ChannelOrder = C.CL_BGR1_APPLE // Introduced in MacOS X.7.
-)
-
-// Extension: cl_APPLE_biased_fixed_point_image_formats
-//
-// This selector may be passed to clCreateImage2D() in the cl_image_format.image_channel_data_type field.
-// It defines a biased signed 1.14 fixed point storage format, with range [-1, 3). The conversion from
-// float to this fixed point format is defined as follows:
-//
-//      ushort float_to_sfixed14( float x ){
-//          int i = convert_int_sat_rte( x * 0x1.0p14f );         // scale [-1, 3.0) to [-16384, 3*16384), round to nearest integer
-//          i = add_sat( i, 0x4000 );                             // apply bias, to convert to [0, 65535) range
-//          return convert_ushort_sat(i);                         // clamp to destination size
-//      }
-//
-// The inverse conversion is the reverse process. The formats are currently only available on the CPU with
-// the CL_RGBA channel layout.
-const (
-	ChannelDataTypeSFixed14Apple ChannelDataType = C.CL_SFIXED14_APPLE // Introduced in MacOS X.7.
-)
-
-func init() {
-	channelOrderNameMap[ChannelOrder1RGBApple] = "1RGBApple"
-	channelOrderNameMap[ChannelOrderBGR1Apple] = "RGB1Apple"
-	channelDataTypeNameMap[ChannelDataTypeSFixed14Apple] = "SFixed14Apple"
-}

Godeps/_workspace/src/github.com/davecgh/go-spew/LICENSE

@@ -1,13 +0,0 @@
-Copyright (c) 2012-2013 Dave Collins <dave@davec.name>
-
-Permission to use, copy, modify, and distribute this software for any
-purpose with or without fee is hereby granted, provided that the above
-copyright notice and this permission notice appear in all copies.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

Godeps/_workspace/src/github.com/davecgh/go-spew/spew/common.go

@@ -1,341 +0,0 @@
-/*
- * Copyright (c) 2013 Dave Collins <dave@davec.name>
- *
- * Permission to use, copy, modify, and distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
- * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
- * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
- * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- */
-
-package spew
-
-import (
-	"bytes"
-	"fmt"
-	"io"
-	"reflect"
-	"sort"
-	"strconv"
-)
-
-// Some constants in the form of bytes to avoid string overhead.  This mirrors
-// the technique used in the fmt package.
-var (
-	panicBytes            = []byte("(PANIC=")
-	plusBytes             = []byte("+")
-	iBytes                = []byte("i")
-	trueBytes             = []byte("true")
-	falseBytes            = []byte("false")
-	interfaceBytes        = []byte("(interface {})")
-	commaNewlineBytes     = []byte(",\n")
-	newlineBytes          = []byte("\n")
-	openBraceBytes        = []byte("{")
-	openBraceNewlineBytes = []byte("{\n")
-	closeBraceBytes       = []byte("}")
-	asteriskBytes         = []byte("*")
-	colonBytes            = []byte(":")
-	colonSpaceBytes       = []byte(": ")
-	openParenBytes        = []byte("(")
-	closeParenBytes       = []byte(")")
-	spaceBytes            = []byte(" ")
-	pointerChainBytes     = []byte("->")
-	nilAngleBytes         = []byte("<nil>")
-	maxNewlineBytes       = []byte("<max depth reached>\n")
-	maxShortBytes         = []byte("<max>")
-	circularBytes         = []byte("<already shown>")
-	circularShortBytes    = []byte("<shown>")
-	invalidAngleBytes     = []byte("<invalid>")
-	openBracketBytes      = []byte("[")
-	closeBracketBytes     = []byte("]")
-	percentBytes          = []byte("%")
-	precisionBytes        = []byte(".")
-	openAngleBytes        = []byte("<")
-	closeAngleBytes       = []byte(">")
-	openMapBytes          = []byte("map[")
-	closeMapBytes         = []byte("]")
-	lenEqualsBytes        = []byte("len=")
-	capEqualsBytes        = []byte("cap=")
-)
-
-// hexDigits is used to map a decimal value to a hex digit.
-var hexDigits = "0123456789abcdef"
-
-// catchPanic handles any panics that might occur during the handleMethods
-// calls.
-func catchPanic(w io.Writer, v reflect.Value) {
-	if err := recover(); err != nil {
-		w.Write(panicBytes)
-		fmt.Fprintf(w, "%v", err)
-		w.Write(closeParenBytes)
-	}
-}
-
-// handleMethods attempts to call the Error and String methods on the underlying
-// type the passed reflect.Value represents and outputes the result to Writer w.
-//
-// It handles panics in any called methods by catching and displaying the error
-// as the formatted value.
-func handleMethods(cs *ConfigState, w io.Writer, v reflect.Value) (handled bool) {
-	// We need an interface to check if the type implements the error or
-	// Stringer interface.  However, the reflect package won't give us an
-	// interface on certain things like unexported struct fields in order
-	// to enforce visibility rules.  We use unsafe, when it's available,
-	// to bypass these restrictions since this package does not mutate the
-	// values.
-	if !v.CanInterface() {
-		if UnsafeDisabled {
-			return false
-		}
-
-		v = unsafeReflectValue(v)
-	}
-
-	// Choose whether or not to do error and Stringer interface lookups against
-	// the base type or a pointer to the base type depending on settings.
-	// Technically calling one of these methods with a pointer receiver can
-	// mutate the value, however, types which choose to satisify an error or
-	// Stringer interface with a pointer receiver should not be mutating their
-	// state inside these interface methods.
-	if !cs.DisablePointerMethods && !UnsafeDisabled && !v.CanAddr() {
-		v = unsafeReflectValue(v)
-	}
-	if v.CanAddr() {
-		v = v.Addr()
-	}
-
-	// Is it an error or Stringer?
-	switch iface := v.Interface().(type) {
-	case error:
-		defer catchPanic(w, v)
-		if cs.ContinueOnMethod {
-			w.Write(openParenBytes)
-			w.Write([]byte(iface.Error()))
-			w.Write(closeParenBytes)
-			w.Write(spaceBytes)
-			return false
-		}
-
-		w.Write([]byte(iface.Error()))
-		return true
-
-	case fmt.Stringer:
-		defer catchPanic(w, v)
-		if cs.ContinueOnMethod {
-			w.Write(openParenBytes)
-			w.Write([]byte(iface.String()))
-			w.Write(closeParenBytes)
-			w.Write(spaceBytes)
-			return false
-		}
-		w.Write([]byte(iface.String()))
-		return true
-	}
-	return false
-}
-
-// printBool outputs a boolean value as true or false to Writer w.
-func printBool(w io.Writer, val bool) {
-	if val {
-		w.Write(trueBytes)
-	} else {
-		w.Write(falseBytes)
-	}
-}
-
-// printInt outputs a signed integer value to Writer w.
-func printInt(w io.Writer, val int64, base int) {
-	w.Write([]byte(strconv.FormatInt(val, base)))
-}
-
-// printUint outputs an unsigned integer value to Writer w.
-func printUint(w io.Writer, val uint64, base int) {
-	w.Write([]byte(strconv.FormatUint(val, base)))
-}
-
-// printFloat outputs a floating point value using the specified precision,
-// which is expected to be 32 or 64bit, to Writer w.
-func printFloat(w io.Writer, val float64, precision int) {
-	w.Write([]byte(strconv.FormatFloat(val, 'g', -1, precision)))
-}
-
-// printComplex outputs a complex value using the specified float precision
-// for the real and imaginary parts to Writer w.
-func printComplex(w io.Writer, c complex128, floatPrecision int) {
-	r := real(c)
-	w.Write(openParenBytes)
-	w.Write([]byte(strconv.FormatFloat(r, 'g', -1, floatPrecision)))
-	i := imag(c)
-	if i >= 0 {
-		w.Write(plusBytes)
-	}
-	w.Write([]byte(strconv.FormatFloat(i, 'g', -1, floatPrecision)))
-	w.Write(iBytes)
-	w.Write(closeParenBytes)
-}
-
-// printHexPtr outputs a uintptr formatted as hexidecimal with a leading '0x'
-// prefix to Writer w.
-func printHexPtr(w io.Writer, p uintptr) {
-	// Null pointer.
-	num := uint64(p)
-	if num == 0 {
-		w.Write(nilAngleBytes)
-		return
-	}
-
-	// Max uint64 is 16 bytes in hex + 2 bytes for '0x' prefix
-	buf := make([]byte, 18)
-
-	// It's simpler to construct the hex string right to left.
-	base := uint64(16)
-	i := len(buf) - 1
-	for num >= base {
-		buf[i] = hexDigits[num%base]
-		num /= base
-		i--
-	}
-	buf[i] = hexDigits[num]
-
-	// Add '0x' prefix.
-	i--
-	buf[i] = 'x'
-	i--
-	buf[i] = '0'
-
-	// Strip unused leading bytes.
-	buf = buf[i:]
-	w.Write(buf)
-}
-
-// valuesSorter implements sort.Interface to allow a slice of reflect.Value
-// elements to be sorted.
-type valuesSorter struct {
-	values  []reflect.Value
-	strings []string // either nil or same len and values
-	cs      *ConfigState
-}
-
-// newValuesSorter initializes a valuesSorter instance, which holds a set of
-// surrogate keys on which the data should be sorted.  It uses flags in
-// ConfigState to decide if and how to populate those surrogate keys.
-func newValuesSorter(values []reflect.Value, cs *ConfigState) sort.Interface {
-	vs := &valuesSorter{values: values, cs: cs}
-	if canSortSimply(vs.values[0].Kind()) {
-		return vs
-	}
-	if !cs.DisableMethods {
-		vs.strings = make([]string, len(values))
-		for i := range vs.values {
-			b := bytes.Buffer{}
-			if !handleMethods(cs, &b, vs.values[i]) {
-				vs.strings = nil
-				break
-			}
-			vs.strings[i] = b.String()
-		}
-	}
-	if vs.strings == nil && cs.SpewKeys {
-		vs.strings = make([]string, len(values))
-		for i := range vs.values {
-			vs.strings[i] = Sprintf("%#v", vs.values[i].Interface())
-		}
-	}
-	return vs
-}
-
-// canSortSimply tests whether a reflect.Kind is a primitive that can be sorted
-// directly, or whether it should be considered for sorting by surrogate keys
-// (if the ConfigState allows it).
-func canSortSimply(kind reflect.Kind) bool {
-	// This switch parallels valueSortLess, except for the default case.
-	switch kind {
-	case reflect.Bool:
-		return true
-	case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int:
-		return true
-	case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint:
-		return true
-	case reflect.Float32, reflect.Float64:
-		return true
-	case reflect.String:
-		return true
-	case reflect.Uintptr:
-		return true
-	case reflect.Array:
-		return true
-	}
-	return false
-}
-
-// Len returns the number of values in the slice.  It is part of the
-// sort.Interface implementation.
-func (s *valuesSorter) Len() int {
-	return len(s.values)
-}
-
-// Swap swaps the values at the passed indices.  It is part of the
-// sort.Interface implementation.
-func (s *valuesSorter) Swap(i, j int) {
-	s.values[i], s.values[j] = s.values[j], s.values[i]
-	if s.strings != nil {
-		s.strings[i], s.strings[j] = s.strings[j], s.strings[i]
-	}
-}
-
-// valueSortLess returns whether the first value should sort before the second
-// value.  It is used by valueSorter.Less as part of the sort.Interface
-// implementation.
-func valueSortLess(a, b reflect.Value) bool {
-	switch a.Kind() {
-	case reflect.Bool:
-		return !a.Bool() && b.Bool()
-	case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int:
-		return a.Int() < b.Int()
-	case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint:
-		return a.Uint() < b.Uint()
-	case reflect.Float32, reflect.Float64:
-		return a.Float() < b.Float()
-	case reflect.String:
-		return a.String() < b.String()
-	case reflect.Uintptr:
-		return a.Uint() < b.Uint()
-	case reflect.Array:
-		// Compare the contents of both arrays.
-		l := a.Len()
-		for i := 0; i < l; i++ {
-			av := a.Index(i)
-			bv := b.Index(i)
-			if av.Interface() == bv.Interface() {
-				continue
-			}
-			return valueSortLess(av, bv)
-		}
-	}
-	return a.String() < b.String()
-}
-
-// Less returns whether the value at index i should sort before the
-// value at index j.  It is part of the sort.Interface implementation.
-func (s *valuesSorter) Less(i, j int) bool {
-	if s.strings == nil {
-		return valueSortLess(s.values[i], s.values[j])
-	}
-	return s.strings[i] < s.strings[j]
-}
-
-// sortValues is a sort function that handles both native types and any type that
-// can be converted to error or Stringer.  Other inputs are sorted according to
-// their Value.String() value to ensure display stability.
-func sortValues(values []reflect.Value, cs *ConfigState) {
-	if len(values) == 0 {
-		return
-	}
-	sort.Sort(newValuesSorter(values, cs))
-}

Godeps/_workspace/src/github.com/davecgh/go-spew/spew/config.go

@@ -1,297 +0,0 @@
-/*
- * Copyright (c) 2013 Dave Collins <dave@davec.name>
- *
- * Permission to use, copy, modify, and distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
- * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
- * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
- * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- */
-
-package spew
-
-import (
-	"bytes"
-	"fmt"
-	"io"
-	"os"
-)
-
-// ConfigState houses the configuration options used by spew to format and
-// display values.  There is a global instance, Config, that is used to control
-// all top-level Formatter and Dump functionality.  Each ConfigState instance
-// provides methods equivalent to the top-level functions.
-//
-// The zero value for ConfigState provides no indentation.  You would typically
-// want to set it to a space or a tab.
-//
-// Alternatively, you can use NewDefaultConfig to get a ConfigState instance
-// with default settings.  See the documentation of NewDefaultConfig for default
-// values.
-type ConfigState struct {
-	// Indent specifies the string to use for each indentation level.  The
-	// global config instance that all top-level functions use set this to a
-	// single space by default.  If you would like more indentation, you might
-	// set this to a tab with "\t" or perhaps two spaces with "  ".
-	Indent string
-
-	// MaxDepth controls the maximum number of levels to descend into nested
-	// data structures.  The default, 0, means there is no limit.
-	//
-	// NOTE: Circular data structures are properly detected, so it is not
-	// necessary to set this value unless you specifically want to limit deeply
-	// nested data structures.
-	MaxDepth int
-
-	// DisableMethods specifies whether or not error and Stringer interfaces are
-	// invoked for types that implement them.
-	DisableMethods bool
-
-	// DisablePointerMethods specifies whether or not to check for and invoke
-	// error and Stringer interfaces on types which only accept a pointer
-	// receiver when the current type is not a pointer.
-	//
-	// NOTE: This might be an unsafe action since calling one of these methods
-	// with a pointer receiver could technically mutate the value, however,
-	// in practice, types which choose to satisify an error or Stringer
-	// interface with a pointer receiver should not be mutating their state
-	// inside these interface methods.  As a result, this option relies on
-	// access to the unsafe package, so it will not have any effect when
-	// running in environments without access to the unsafe package such as
-	// Google App Engine or with the "disableunsafe" build tag specified.
-	DisablePointerMethods bool
-
-	// ContinueOnMethod specifies whether or not recursion should continue once
-	// a custom error or Stringer interface is invoked.  The default, false,
-	// means it will print the results of invoking the custom error or Stringer
-	// interface and return immediately instead of continuing to recurse into
-	// the internals of the data type.
-	//
-	// NOTE: This flag does not have any effect if method invocation is disabled
-	// via the DisableMethods or DisablePointerMethods options.
-	ContinueOnMethod bool
-
-	// SortKeys specifies map keys should be sorted before being printed. Use
-	// this to have a more deterministic, diffable output.  Note that only
-	// native types (bool, int, uint, floats, uintptr and string) and types
-	// that support the error or Stringer interfaces (if methods are
-	// enabled) are supported, with other types sorted according to the
-	// reflect.Value.String() output which guarantees display stability.
-	SortKeys bool
-
-	// SpewKeys specifies that, as a last resort attempt, map keys should
-	// be spewed to strings and sorted by those strings.  This is only
-	// considered if SortKeys is true.
-	SpewKeys bool
-}
-
-// Config is the active configuration of the top-level functions.
-// The configuration can be changed by modifying the contents of spew.Config.
-var Config = ConfigState{Indent: " "}
-
-// Errorf is a wrapper for fmt.Errorf that treats each argument as if it were
-// passed with a Formatter interface returned by c.NewFormatter.  It returns
-// the formatted string as a value that satisfies error.  See NewFormatter
-// for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-//	fmt.Errorf(format, c.NewFormatter(a), c.NewFormatter(b))
-func (c *ConfigState) Errorf(format string, a ...interface{}) (err error) {
-	return fmt.Errorf(format, c.convertArgs(a)...)
-}
-
-// Fprint is a wrapper for fmt.Fprint that treats each argument as if it were
-// passed with a Formatter interface returned by c.NewFormatter.  It returns
-// the number of bytes written and any write error encountered.  See
-// NewFormatter for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-//	fmt.Fprint(w, c.NewFormatter(a), c.NewFormatter(b))
-func (c *ConfigState) Fprint(w io.Writer, a ...interface{}) (n int, err error) {
-	return fmt.Fprint(w, c.convertArgs(a)...)
-}
-
-// Fprintf is a wrapper for fmt.Fprintf that treats each argument as if it were
-// passed with a Formatter interface returned by c.NewFormatter.  It returns
-// the number of bytes written and any write error encountered.  See
-// NewFormatter for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-//	fmt.Fprintf(w, format, c.NewFormatter(a), c.NewFormatter(b))
-func (c *ConfigState) Fprintf(w io.Writer, format string, a ...interface{}) (n int, err error) {
-	return fmt.Fprintf(w, format, c.convertArgs(a)...)
-}
-
-// Fprintln is a wrapper for fmt.Fprintln that treats each argument as if it
-// passed with a Formatter interface returned by c.NewFormatter.  See
-// NewFormatter for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-//	fmt.Fprintln(w, c.NewFormatter(a), c.NewFormatter(b))
-func (c *ConfigState) Fprintln(w io.Writer, a ...interface{}) (n int, err error) {
-	return fmt.Fprintln(w, c.convertArgs(a)...)
-}
-
-// Print is a wrapper for fmt.Print that treats each argument as if it were
-// passed with a Formatter interface returned by c.NewFormatter.  It returns
-// the number of bytes written and any write error encountered.  See
-// NewFormatter for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-//	fmt.Print(c.NewFormatter(a), c.NewFormatter(b))
-func (c *ConfigState) Print(a ...interface{}) (n int, err error) {
-	return fmt.Print(c.convertArgs(a)...)
-}
-
-// Printf is a wrapper for fmt.Printf that treats each argument as if it were
-// passed with a Formatter interface returned by c.NewFormatter.  It returns
-// the number of bytes written and any write error encountered.  See
-// NewFormatter for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-//	fmt.Printf(format, c.NewFormatter(a), c.NewFormatter(b))
-func (c *ConfigState) Printf(format string, a ...interface{}) (n int, err error) {
-	return fmt.Printf(format, c.convertArgs(a)...)
-}
-
-// Println is a wrapper for fmt.Println that treats each argument as if it were
-// passed with a Formatter interface returned by c.NewFormatter.  It returns
-// the number of bytes written and any write error encountered.  See
-// NewFormatter for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-//	fmt.Println(c.NewFormatter(a), c.NewFormatter(b))
-func (c *ConfigState) Println(a ...interface{}) (n int, err error) {
-	return fmt.Println(c.convertArgs(a)...)
-}
-
-// Sprint is a wrapper for fmt.Sprint that treats each argument as if it were
-// passed with a Formatter interface returned by c.NewFormatter.  It returns
-// the resulting string.  See NewFormatter for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-//	fmt.Sprint(c.NewFormatter(a), c.NewFormatter(b))
-func (c *ConfigState) Sprint(a ...interface{}) string {
-	return fmt.Sprint(c.convertArgs(a)...)
-}
-
-// Sprintf is a wrapper for fmt.Sprintf that treats each argument as if it were
-// passed with a Formatter interface returned by c.NewFormatter.  It returns
-// the resulting string.  See NewFormatter for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-//	fmt.Sprintf(format, c.NewFormatter(a), c.NewFormatter(b))
-func (c *ConfigState) Sprintf(format string, a ...interface{}) string {
-	return fmt.Sprintf(format, c.convertArgs(a)...)
-}
-
-// Sprintln is a wrapper for fmt.Sprintln that treats each argument as if it
-// were passed with a Formatter interface returned by c.NewFormatter.  It
-// returns the resulting string.  See NewFormatter for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-//	fmt.Sprintln(c.NewFormatter(a), c.NewFormatter(b))
-func (c *ConfigState) Sprintln(a ...interface{}) string {
-	return fmt.Sprintln(c.convertArgs(a)...)
-}
-
-/*
-NewFormatter returns a custom formatter that satisfies the fmt.Formatter
-interface.  As a result, it integrates cleanly with standard fmt package
-printing functions.  The formatter is useful for inline printing of smaller data
-types similar to the standard %v format specifier.
-
-The custom formatter only responds to the %v (most compact), %+v (adds pointer
-addresses), %#v (adds types), and %#+v (adds types and pointer addresses) verb
-combinations.  Any other verbs such as %x and %q will be sent to the the
-standard fmt package for formatting.  In addition, the custom formatter ignores
-the width and precision arguments (however they will still work on the format
-specifiers not handled by the custom formatter).
-
-Typically this function shouldn't be called directly.  It is much easier to make
-use of the custom formatter by calling one of the convenience functions such as
-c.Printf, c.Println, or c.Printf.
-*/
-func (c *ConfigState) NewFormatter(v interface{}) fmt.Formatter {
-	return newFormatter(c, v)
-}
-
-// Fdump formats and displays the passed arguments to io.Writer w.  It formats
-// exactly the same as Dump.
-func (c *ConfigState) Fdump(w io.Writer, a ...interface{}) {
-	fdump(c, w, a...)
-}
-
-/*
-Dump displays the passed parameters to standard out with newlines, customizable
-indentation, and additional debug information such as complete types and all
-pointer addresses used to indirect to the final value.  It provides the
-following features over the built-in printing facilities provided by the fmt
-package:
-
-	* Pointers are dereferenced and followed
-	* Circular data structures are detected and handled properly
-	* Custom Stringer/error interfaces are optionally invoked, including
-	  on unexported types
-	* Custom types which only implement the Stringer/error interfaces via
-	  a pointer receiver are optionally invoked when passing non-pointer
-	  variables
-	* Byte arrays and slices are dumped like the hexdump -C command which
-	  includes offsets, byte values in hex, and ASCII output
-
-The configuration options are controlled by modifying the public members
-of c.  See ConfigState for options documentation.
-
-See Fdump if you would prefer dumping to an arbitrary io.Writer or Sdump to
-get the formatted result as a string.
-*/
-func (c *ConfigState) Dump(a ...interface{}) {
-	fdump(c, os.Stdout, a...)
-}
-
-// Sdump returns a string with the passed arguments formatted exactly the same
-// as Dump.
-func (c *ConfigState) Sdump(a ...interface{}) string {
-	var buf bytes.Buffer
-	fdump(c, &buf, a...)
-	return buf.String()
-}
-
-// convertArgs accepts a slice of arguments and returns a slice of the same
-// length with each argument converted to a spew Formatter interface using
-// the ConfigState associated with s.
-func (c *ConfigState) convertArgs(args []interface{}) (formatters []interface{}) {
-	formatters = make([]interface{}, len(args))
-	for index, arg := range args {
-		formatters[index] = newFormatter(c, arg)
-	}
-	return formatters
-}
-
-// NewDefaultConfig returns a ConfigState with the following default settings.
-//
-// 	Indent: " "
-// 	MaxDepth: 0
-// 	DisableMethods: false
-// 	DisablePointerMethods: false
-// 	ContinueOnMethod: false
-// 	SortKeys: false
-func NewDefaultConfig() *ConfigState {
-	return &ConfigState{Indent: " "}
-}

Godeps/_workspace/src/github.com/davecgh/go-spew/spew/doc.go

@@ -1,202 +0,0 @@
-/*
- * Copyright (c) 2013 Dave Collins <dave@davec.name>
- *
- * Permission to use, copy, modify, and distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
- * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
- * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
- * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- */
-
-/*
-Package spew implements a deep pretty printer for Go data structures to aid in
-debugging.
-
-A quick overview of the additional features spew provides over the built-in
-printing facilities for Go data types are as follows:
-
-	* Pointers are dereferenced and followed
-	* Circular data structures are detected and handled properly
-	* Custom Stringer/error interfaces are optionally invoked, including
-	  on unexported types
-	* Custom types which only implement the Stringer/error interfaces via
-	  a pointer receiver are optionally invoked when passing non-pointer
-	  variables
-	* Byte arrays and slices are dumped like the hexdump -C command which
-	  includes offsets, byte values in hex, and ASCII output (only when using
-	  Dump style)
-
-There are two different approaches spew allows for dumping Go data structures:
-
-	* Dump style which prints with newlines, customizable indentation,
-	  and additional debug information such as types and all pointer addresses
-	  used to indirect to the final value
-	* A custom Formatter interface that integrates cleanly with the standard fmt
-	  package and replaces %v, %+v, %#v, and %#+v to provide inline printing
-	  similar to the default %v while providing the additional functionality
-	  outlined above and passing unsupported format verbs such as %x and %q
-	  along to fmt
-
-Quick Start
-
-This section demonstrates how to quickly get started with spew.  See the
-sections below for further details on formatting and configuration options.
-
-To dump a variable with full newlines, indentation, type, and pointer
-information use Dump, Fdump, or Sdump:
-	spew.Dump(myVar1, myVar2, ...)
-	spew.Fdump(someWriter, myVar1, myVar2, ...)
-	str := spew.Sdump(myVar1, myVar2, ...)
-
-Alternatively, if you would prefer to use format strings with a compacted inline
-printing style, use the convenience wrappers Printf, Fprintf, etc with
-%v (most compact), %+v (adds pointer addresses), %#v (adds types), or
-%#+v (adds types and pointer addresses):
-	spew.Printf("myVar1: %v -- myVar2: %+v", myVar1, myVar2)
-	spew.Printf("myVar3: %#v -- myVar4: %#+v", myVar3, myVar4)
-	spew.Fprintf(someWriter, "myVar1: %v -- myVar2: %+v", myVar1, myVar2)
-	spew.Fprintf(someWriter, "myVar3: %#v -- myVar4: %#+v", myVar3, myVar4)
-
-Configuration Options
-
-Configuration of spew is handled by fields in the ConfigState type.  For
-convenience, all of the top-level functions use a global state available
-via the spew.Config global.
-
-It is also possible to create a ConfigState instance that provides methods
-equivalent to the top-level functions.  This allows concurrent configuration
-options.  See the ConfigState documentation for more details.
-
-The following configuration options are available:
-	* Indent
-		String to use for each indentation level for Dump functions.
-		It is a single space by default.  A popular alternative is "\t".
-
-	* MaxDepth
-		Maximum number of levels to descend into nested data structures.
-		There is no limit by default.
-
-	* DisableMethods
-		Disables invocation of error and Stringer interface methods.
-		Method invocation is enabled by default.
-
-	* DisablePointerMethods
-		Disables invocation of error and Stringer interface methods on types
-		which only accept pointer receivers from non-pointer variables.
-		Pointer method invocation is enabled by default.
-
-	* ContinueOnMethod
-		Enables recursion into types after invoking error and Stringer interface
-		methods. Recursion after method invocation is disabled by default.
-
-	* SortKeys
-		Specifies map keys should be sorted before being printed. Use
-		this to have a more deterministic, diffable output.  Note that
-		only native types (bool, int, uint, floats, uintptr and string)
-		and types which implement error or Stringer interfaces are
-		supported with other types sorted according to the
-		reflect.Value.String() output which guarantees display
-		stability.  Natural map order is used by default.
-
-	* SpewKeys
-		Specifies that, as a last resort attempt, map keys should be
-		spewed to strings and sorted by those strings.  This is only
-		considered if SortKeys is true.
-
-Dump Usage
-
-Simply call spew.Dump with a list of variables you want to dump:
-
-	spew.Dump(myVar1, myVar2, ...)
-
-You may also call spew.Fdump if you would prefer to output to an arbitrary
-io.Writer.  For example, to dump to standard error:
-
-	spew.Fdump(os.Stderr, myVar1, myVar2, ...)
-
-A third option is to call spew.Sdump to get the formatted output as a string:
-
-	str := spew.Sdump(myVar1, myVar2, ...)
-
-Sample Dump Output
-
-See the Dump example for details on the setup of the types and variables being
-shown here.
-
-	(main.Foo) {
-	 unexportedField: (*main.Bar)(0xf84002e210)({
-	  flag: (main.Flag) flagTwo,
-	  data: (uintptr) <nil>
-	 }),
-	 ExportedField: (map[interface {}]interface {}) (len=1) {
-	  (string) (len=3) "one": (bool) true
-	 }
-	}
-
-Byte (and uint8) arrays and slices are displayed uniquely like the hexdump -C
-command as shown.
-	([]uint8) (len=32 cap=32) {
-	 00000000  11 12 13 14 15 16 17 18  19 1a 1b 1c 1d 1e 1f 20  |............... |
-	 00000010  21 22 23 24 25 26 27 28  29 2a 2b 2c 2d 2e 2f 30  |!"#$%&'()*+,-./0|
-	 00000020  31 32                                             |12|
-	}
-
-Custom Formatter
-
-Spew provides a custom formatter that implements the fmt.Formatter interface
-so that it integrates cleanly with standard fmt package printing functions. The
-formatter is useful for inline printing of smaller data types similar to the
-standard %v format specifier.
-
-The custom formatter only responds to the %v (most compact), %+v (adds pointer
-addresses), %#v (adds types), or %#+v (adds types and pointer addresses) verb
-combinations.  Any other verbs such as %x and %q will be sent to the the
-standard fmt package for formatting.  In addition, the custom formatter ignores
-the width and precision arguments (however they will still work on the format
-specifiers not handled by the custom formatter).
-
-Custom Formatter Usage
-
-The simplest way to make use of the spew custom formatter is to call one of the
-convenience functions such as spew.Printf, spew.Println, or spew.Printf.  The
-functions have syntax you are most likely already familiar with:
-
-	spew.Printf("myVar1: %v -- myVar2: %+v", myVar1, myVar2)
-	spew.Printf("myVar3: %#v -- myVar4: %#+v", myVar3, myVar4)
-	spew.Println(myVar, myVar2)
-	spew.Fprintf(os.Stderr, "myVar1: %v -- myVar2: %+v", myVar1, myVar2)
-	spew.Fprintf(os.Stderr, "myVar3: %#v -- myVar4: %#+v", myVar3, myVar4)
-
-See the Index for the full list convenience functions.
-
-Sample Formatter Output
-
-Double pointer to a uint8:
-	  %v: <**>5
-	 %+v: <**>(0xf8400420d0->0xf8400420c8)5
-	 %#v: (**uint8)5
-	%#+v: (**uint8)(0xf8400420d0->0xf8400420c8)5
-
-Pointer to circular struct with a uint8 field and a pointer to itself:
-	  %v: <*>{1 <*><shown>}
-	 %+v: <*>(0xf84003e260){ui8:1 c:<*>(0xf84003e260)<shown>}
-	 %#v: (*main.circular){ui8:(uint8)1 c:(*main.circular)<shown>}
-	%#+v: (*main.circular)(0xf84003e260){ui8:(uint8)1 c:(*main.circular)(0xf84003e260)<shown>}
-
-See the Printf example for details on the setup of variables being shown
-here.
-
-Errors
-
-Since it is possible for custom Stringer/error interfaces to panic, spew
-detects them and handles them internally by printing the panic information
-inline with the output.  Since spew is intended to provide deep pretty printing
-capabilities on structures, it intentionally does not return any errors.
-*/
-package spew

Godeps/_workspace/src/github.com/davecgh/go-spew/spew/format.go

@@ -1,419 +0,0 @@
-/*
- * Copyright (c) 2013 Dave Collins <dave@davec.name>
- *
- * Permission to use, copy, modify, and distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
- * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
- * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
- * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- */
-
-package spew
-
-import (
-	"bytes"
-	"fmt"
-	"reflect"
-	"strconv"
-	"strings"
-)
-
-// supportedFlags is a list of all the character flags supported by fmt package.
-const supportedFlags = "0-+# "
-
-// formatState implements the fmt.Formatter interface and contains information
-// about the state of a formatting operation.  The NewFormatter function can
-// be used to get a new Formatter which can be used directly as arguments
-// in standard fmt package printing calls.
-type formatState struct {
-	value          interface{}
-	fs             fmt.State
-	depth          int
-	pointers       map[uintptr]int
-	ignoreNextType bool
-	cs             *ConfigState
-}
-
-// buildDefaultFormat recreates the original format string without precision
-// and width information to pass in to fmt.Sprintf in the case of an
-// unrecognized type.  Unless new types are added to the language, this
-// function won't ever be called.
-func (f *formatState) buildDefaultFormat() (format string) {
-	buf := bytes.NewBuffer(percentBytes)
-
-	for _, flag := range supportedFlags {
-		if f.fs.Flag(int(flag)) {
-			buf.WriteRune(flag)
-		}
-	}
-
-	buf.WriteRune('v')
-
-	format = buf.String()
-	return format
-}
-
-// constructOrigFormat recreates the original format string including precision
-// and width information to pass along to the standard fmt package.  This allows
-// automatic deferral of all format strings this package doesn't support.
-func (f *formatState) constructOrigFormat(verb rune) (format string) {
-	buf := bytes.NewBuffer(percentBytes)
-
-	for _, flag := range supportedFlags {
-		if f.fs.Flag(int(flag)) {
-			buf.WriteRune(flag)
-		}
-	}
-
-	if width, ok := f.fs.Width(); ok {
-		buf.WriteString(strconv.Itoa(width))
-	}
-
-	if precision, ok := f.fs.Precision(); ok {
-		buf.Write(precisionBytes)
-		buf.WriteString(strconv.Itoa(precision))
-	}
-
-	buf.WriteRune(verb)
-
-	format = buf.String()
-	return format
-}
-
-// unpackValue returns values inside of non-nil interfaces when possible and
-// ensures that types for values which have been unpacked from an interface
-// are displayed when the show types flag is also set.
-// This is useful for data types like structs, arrays, slices, and maps which
-// can contain varying types packed inside an interface.
-func (f *formatState) unpackValue(v reflect.Value) reflect.Value {
-	if v.Kind() == reflect.Interface {
-		f.ignoreNextType = false
-		if !v.IsNil() {
-			v = v.Elem()
-		}
-	}
-	return v
-}
-
-// formatPtr handles formatting of pointers by indirecting them as necessary.
-func (f *formatState) formatPtr(v reflect.Value) {
-	// Display nil if top level pointer is nil.
-	showTypes := f.fs.Flag('#')
-	if v.IsNil() && (!showTypes || f.ignoreNextType) {
-		f.fs.Write(nilAngleBytes)
-		return
-	}
-
-	// Remove pointers at or below the current depth from map used to detect
-	// circular refs.
-	for k, depth := range f.pointers {
-		if depth >= f.depth {
-			delete(f.pointers, k)
-		}
-	}
-
-	// Keep list of all dereferenced pointers to possibly show later.
-	pointerChain := make([]uintptr, 0)
-
-	// Figure out how many levels of indirection there are by derferencing
-	// pointers and unpacking interfaces down the chain while detecting circular
-	// references.
-	nilFound := false
-	cycleFound := false
-	indirects := 0
-	ve := v
-	for ve.Kind() == reflect.Ptr {
-		if ve.IsNil() {
-			nilFound = true
-			break
-		}
-		indirects++
-		addr := ve.Pointer()
-		pointerChain = append(pointerChain, addr)
-		if pd, ok := f.pointers[addr]; ok && pd < f.depth {
-			cycleFound = true
-			indirects--
-			break
-		}
-		f.pointers[addr] = f.depth
-
-		ve = ve.Elem()
-		if ve.Kind() == reflect.Interface {
-			if ve.IsNil() {
-				nilFound = true
-				break
-			}
-			ve = ve.Elem()
-		}
-	}
-
-	// Display type or indirection level depending on flags.
-	if showTypes && !f.ignoreNextType {
-		f.fs.Write(openParenBytes)
-		f.fs.Write(bytes.Repeat(asteriskBytes, indirects))
-		f.fs.Write([]byte(ve.Type().String()))
-		f.fs.Write(closeParenBytes)
-	} else {
-		if nilFound || cycleFound {
-			indirects += strings.Count(ve.Type().String(), "*")
-		}
-		f.fs.Write(openAngleBytes)
-		f.fs.Write([]byte(strings.Repeat("*", indirects)))
-		f.fs.Write(closeAngleBytes)
-	}
-
-	// Display pointer information depending on flags.
-	if f.fs.Flag('+') && (len(pointerChain) > 0) {
-		f.fs.Write(openParenBytes)
-		for i, addr := range pointerChain {
-			if i > 0 {
-				f.fs.Write(pointerChainBytes)
-			}
-			printHexPtr(f.fs, addr)
-		}
-		f.fs.Write(closeParenBytes)
-	}
-
-	// Display dereferenced value.
-	switch {
-	case nilFound == true:
-		f.fs.Write(nilAngleBytes)
-
-	case cycleFound == true:
-		f.fs.Write(circularShortBytes)
-
-	default:
-		f.ignoreNextType = true
-		f.format(ve)
-	}
-}
-
-// format is the main workhorse for providing the Formatter interface.  It
-// uses the passed reflect value to figure out what kind of object we are
-// dealing with and formats it appropriately.  It is a recursive function,
-// however circular data structures are detected and handled properly.
-func (f *formatState) format(v reflect.Value) {
-	// Handle invalid reflect values immediately.
-	kind := v.Kind()
-	if kind == reflect.Invalid {
-		f.fs.Write(invalidAngleBytes)
-		return
-	}
-
-	// Handle pointers specially.
-	if kind == reflect.Ptr {
-		f.formatPtr(v)
-		return
-	}
-
-	// Print type information unless already handled elsewhere.
-	if !f.ignoreNextType && f.fs.Flag('#') {
-		f.fs.Write(openParenBytes)
-		f.fs.Write([]byte(v.Type().String()))
-		f.fs.Write(closeParenBytes)
-	}
-	f.ignoreNextType = false
-
-	// Call Stringer/error interfaces if they exist and the handle methods
-	// flag is enabled.
-	if !f.cs.DisableMethods {
-		if (kind != reflect.Invalid) && (kind != reflect.Interface) {
-			if handled := handleMethods(f.cs, f.fs, v); handled {
-				return
-			}
-		}
-	}
-
-	switch kind {
-	case reflect.Invalid:
-		// Do nothing.  We should never get here since invalid has already
-		// been handled above.
-
-	case reflect.Bool:
-		printBool(f.fs, v.Bool())
-
-	case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int:
-		printInt(f.fs, v.Int(), 10)
-
-	case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint:
-		printUint(f.fs, v.Uint(), 10)
-
-	case reflect.Float32:
-		printFloat(f.fs, v.Float(), 32)
-
-	case reflect.Float64:
-		printFloat(f.fs, v.Float(), 64)
-
-	case reflect.Complex64:
-		printComplex(f.fs, v.Complex(), 32)
-
-	case reflect.Complex128:
-		printComplex(f.fs, v.Complex(), 64)
-
-	case reflect.Slice:
-		if v.IsNil() {
-			f.fs.Write(nilAngleBytes)
-			break
-		}
-		fallthrough
-
-	case reflect.Array:
-		f.fs.Write(openBracketBytes)
-		f.depth++
-		if (f.cs.MaxDepth != 0) && (f.depth > f.cs.MaxDepth) {
-			f.fs.Write(maxShortBytes)
-		} else {
-			numEntries := v.Len()
-			for i := 0; i < numEntries; i++ {
-				if i > 0 {
-					f.fs.Write(spaceBytes)
-				}
-				f.ignoreNextType = true
-				f.format(f.unpackValue(v.Index(i)))
-			}
-		}
-		f.depth--
-		f.fs.Write(closeBracketBytes)
-
-	case reflect.String:
-		f.fs.Write([]byte(v.String()))
-
-	case reflect.Interface:
-		// The only time we should get here is for nil interfaces due to
-		// unpackValue calls.
-		if v.IsNil() {
-			f.fs.Write(nilAngleBytes)
-		}
-
-	case reflect.Ptr:
-		// Do nothing.  We should never get here since pointers have already
-		// been handled above.
-
-	case reflect.Map:
-		// nil maps should be indicated as different than empty maps
-		if v.IsNil() {
-			f.fs.Write(nilAngleBytes)
-			break
-		}
-
-		f.fs.Write(openMapBytes)
-		f.depth++
-		if (f.cs.MaxDepth != 0) && (f.depth > f.cs.MaxDepth) {
-			f.fs.Write(maxShortBytes)
-		} else {
-			keys := v.MapKeys()
-			if f.cs.SortKeys {
-				sortValues(keys, f.cs)
-			}
-			for i, key := range keys {
-				if i > 0 {
-					f.fs.Write(spaceBytes)
-				}
-				f.ignoreNextType = true
-				f.format(f.unpackValue(key))
-				f.fs.Write(colonBytes)
-				f.ignoreNextType = true
-				f.format(f.unpackValue(v.MapIndex(key)))
-			}
-		}
-		f.depth--
-		f.fs.Write(closeMapBytes)
-
-	case reflect.Struct:
-		numFields := v.NumField()
-		f.fs.Write(openBraceBytes)
-		f.depth++
-		if (f.cs.MaxDepth != 0) && (f.depth > f.cs.MaxDepth) {
-			f.fs.Write(maxShortBytes)
-		} else {
-			vt := v.Type()
-			for i := 0; i < numFields; i++ {
-				if i > 0 {
-					f.fs.Write(spaceBytes)
-				}
-				vtf := vt.Field(i)
-				if f.fs.Flag('+') || f.fs.Flag('#') {
-					f.fs.Write([]byte(vtf.Name))
-					f.fs.Write(colonBytes)
-				}
-				f.format(f.unpackValue(v.Field(i)))
-			}
-		}
-		f.depth--
-		f.fs.Write(closeBraceBytes)
-
-	case reflect.Uintptr:
-		printHexPtr(f.fs, uintptr(v.Uint()))
-
-	case reflect.UnsafePointer, reflect.Chan, reflect.Func:
-		printHexPtr(f.fs, v.Pointer())
-
-	// There were not any other types at the time this code was written, but
-	// fall back to letting the default fmt package handle it if any get added.
-	default:
-		format := f.buildDefaultFormat()
-		if v.CanInterface() {
-			fmt.Fprintf(f.fs, format, v.Interface())
-		} else {
-			fmt.Fprintf(f.fs, format, v.String())
-		}
-	}
-}
-
-// Format satisfies the fmt.Formatter interface. See NewFormatter for usage
-// details.
-func (f *formatState) Format(fs fmt.State, verb rune) {
-	f.fs = fs
-
-	// Use standard formatting for verbs that are not v.
-	if verb != 'v' {
-		format := f.constructOrigFormat(verb)
-		fmt.Fprintf(fs, format, f.value)
-		return
-	}
-
-	if f.value == nil {
-		if fs.Flag('#') {
-			fs.Write(interfaceBytes)
-		}
-		fs.Write(nilAngleBytes)
-		return
-	}
-
-	f.format(reflect.ValueOf(f.value))
-}
-
-// newFormatter is a helper function to consolidate the logic from the various
-// public methods which take varying config states.
-func newFormatter(cs *ConfigState, v interface{}) fmt.Formatter {
-	fs := &formatState{value: v, cs: cs}
-	fs.pointers = make(map[uintptr]int)
-	return fs
-}
-
-/*
-NewFormatter returns a custom formatter that satisfies the fmt.Formatter
-interface.  As a result, it integrates cleanly with standard fmt package
-printing functions.  The formatter is useful for inline printing of smaller data
-types similar to the standard %v format specifier.
-
-The custom formatter only responds to the %v (most compact), %+v (adds pointer
-addresses), %#v (adds types), or %#+v (adds types and pointer addresses) verb
-combinations.  Any other verbs such as %x and %q will be sent to the the
-standard fmt package for formatting.  In addition, the custom formatter ignores
-the width and precision arguments (however they will still work on the format
-specifiers not handled by the custom formatter).
-
-Typically this function shouldn't be called directly.  It is much easier to make
-use of the custom formatter by calling one of the convenience functions such as
-Printf, Println, or Fprintf.
-*/
-func NewFormatter(v interface{}) fmt.Formatter {
-	return newFormatter(&Config, v)
-}

Godeps/_workspace/src/github.com/ethereum/ethash/.gitignore

@@ -1,12 +0,0 @@
-.idea/
-.DS_Store
-*/**/*un~
-.vagrant/
-*.pyc
-build/
-pyethash.egg-info/
-*.so
-*~
-*.swp
-MANIFEST
-dist/

Godeps/_workspace/src/github.com/ethereum/ethash/.travis.yml

@@ -1,23 +0,0 @@
-language: go
-go:
-  - 1.4.2
-
-before_install:
-  # for g++4.8 and C++11
-  - sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test
-
-  # Set up go-ethereum
-  - sudo apt-get update -y -qq
-  - sudo apt-get install -yqq libgmp3-dev 
-  - git clone --depth=10 https://github.com/ethereum/go-ethereum ${GOPATH}/src/github.com/ethereum/go-ethereum
-  # use canned dependencies from the go-ethereum repository
-  - export GOPATH=$GOPATH:$GOPATH/src/github.com/ethereum/go-ethereum/Godeps/_workspace/
-  - echo $GOPATH
-
-install:
-  # need to explicitly request version 1.48 since by default we get 1.46 which does not work with C++11
-  - sudo apt-get install -qq --yes --force-yes g++-4.8
-  - sudo update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-4.8 50
-  - sudo apt-get install -qq wget cmake bash libboost-test1.48-dev libboost-system1.48-dev libboost-filesystem1.48-dev nodejs python-pip python-dev valgrind
-  - sudo pip install virtualenv -q
-script: "./test/test.sh"

Godeps/_workspace/src/github.com/ethereum/ethash/CMakeLists.txt

@@ -1,14 +0,0 @@
-cmake_minimum_required(VERSION 2.8.7)
-project(ethash)
-
-set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/cmake/modules/")
-set(ETHHASH_LIBS ethash)
-
-if (WIN32 AND WANT_CRYPTOPP)
-	add_subdirectory(cryptopp)
-endif()
-
-add_subdirectory(src/libethash)
-
-add_subdirectory(src/benchmark EXCLUDE_FROM_ALL)
-add_subdirectory(test/c)

Godeps/_workspace/src/github.com/ethereum/ethash/MANIFEST.in

@@ -1,17 +0,0 @@
-include setup.py
-
-# C sources
-include src/libethash/internal.c
-include src/libethash/sha3.c
-include src/libethash/util.c
-include src/python/core.c
-
-# Headers
-include src/libethash/compiler.h
-include src/libethash/data_sizes.h
-include src/libethash/endian.h
-include src/libethash/ethash.h
-include src/libethash/fnv.h
-include src/libethash/internal.h
-include src/libethash/sha3.h
-include src/libethash/util.h

Godeps/_workspace/src/github.com/ethereum/ethash/Makefile

@@ -1,6 +0,0 @@
-.PHONY: clean test
-test:
-	./test/test.sh
-
-clean:
-	rm -rf *.so pyethash.egg-info/ build/ test/python/python-virtual-env/ test/c/build/ pyethash.so test/python/*.pyc dist/ MANIFEST

Godeps/_workspace/src/github.com/ethereum/ethash/README.md

@@ -1,22 +0,0 @@
-[![Build Status](https://travis-ci.org/ethereum/ethash.svg?branch=master)](https://travis-ci.org/ethereum/ethash)
-[![Windows Build Status](https://ci.appveyor.com/api/projects/status/github/debris/ethash?branch=master&svg=true)](https://ci.appveyor.com/project/debris/ethash-nr37r/branch/master)
-
-# Ethash
-
-For details on this project, please see the Ethereum wiki:
-https://github.com/ethereum/wiki/wiki/Ethash
-
-### Coding Style for C++ code:
-
-Follow the same exact style as in [cpp-ethereum](https://github.com/ethereum/cpp-ethereum/blob/develop/CodingStandards.txt)
-
-### Coding Style for C code:
-
-The main thing above all is code consistency.
-
-- Tabs for indentation. A tab is 4 spaces
-- Try to stick to the [K&R](http://en.wikipedia.org/wiki/Indent_style#K.26R_style),
-  especially for the C code.
-- Keep the line lengths reasonable. No hard limit on 80 characters but don't go further
-  than 110. Some people work with multiple buffers next to each other.
-  Make them like you :)

Godeps/_workspace/src/github.com/ethereum/ethash/Vagrantfile

@@ -1,7 +0,0 @@
-# -*- mode: ruby -*-
-# vi: set ft=ruby :
-
-Vagrant.configure(2) do |config|
-  config.vm.box = "Ubuntu 12.04"
-  config.vm.box_url = "https://cloud-images.ubuntu.com/vagrant/precise/current/precise-server-cloudimg-amd64-vagrant-disk1.box"
-end

Godeps/_workspace/src/github.com/ethereum/ethash/appveyor.yml

@@ -1,43 +0,0 @@
-version: 1.0.0.{build}
-
-environment:
-    BOOST_ROOT: "c:/projects/ethash/deps/boost"
-
-branches:
-    only:
-        - master
-        - develop
-
-os: Windows Server 2012 R2
-
-clone_folder: c:\projects\ethash
-
-#platform: Any CPU
-#configuration: Debug
-
-install:
-    # by default, all script lines are interpreted as batch
-
-# scripts to run before build
-before_build:
-    - echo "Downloading boost..."
-    - mkdir c:\projects\ethash\deps
-    - cd c:\projects\ethash\deps
-    - curl -O https://build.ethdev.com/builds/windows-precompiled/boost.tar.gz
-    - echo "Unzipping boost..."
-    - 7z x boost.tar.gz > nul
-    - 7z x boost.tar > nul
-    - ls
-    - echo "Running cmake..."
-    - cd c:\projects\ethash
-    - cmake .
-
-build:
-    project: ALL_BUILD.vcxproj      # path to Visual Studio solution or project
-
-after_build:
-    - echo "Running tests..."
-    - cd c:\projects\ethash\test\c\Debug
-    - Test.exe
-    - echo "Finished!"
-

Godeps/_workspace/src/github.com/ethereum/ethash/ethash.go

@@ -1,441 +0,0 @@
-// Copyright 2015 The go-ethereum Authors
-// Copyright 2015 Lefteris Karapetsas <lefteris@refu.co>
-// Copyright 2015 Matthew Wampler-Doty <matthew.wampler.doty@gmail.com>
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package ethash
-
-/*
-#include "src/libethash/internal.h"
-
-int ethashGoCallback_cgo(unsigned);
-*/
-import "C"
-
-import (
-	"errors"
-	"fmt"
-	"io/ioutil"
-	"math/big"
-	"math/rand"
-	"os"
-	"os/user"
-	"path/filepath"
-	"runtime"
-	"sync"
-	"sync/atomic"
-	"time"
-	"unsafe"
-
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/crypto"
-	"github.com/ethereum/go-ethereum/logger"
-	"github.com/ethereum/go-ethereum/logger/glog"
-	"github.com/ethereum/go-ethereum/pow"
-)
-
-var (
-	maxUint256  = new(big.Int).Exp(big.NewInt(2), big.NewInt(256), big.NewInt(0))
-	sharedLight = new(Light)
-)
-
-const (
-	epochLength         uint64     = 30000
-	cacheSizeForTesting C.uint64_t = 1024
-	dagSizeForTesting   C.uint64_t = 1024 * 32
-)
-
-var DefaultDir = defaultDir()
-
-func defaultDir() string {
-	home := os.Getenv("HOME")
-	if user, err := user.Current(); err == nil {
-		home = user.HomeDir
-	}
-	if runtime.GOOS == "windows" {
-		return filepath.Join(home, "AppData", "Ethash")
-	}
-	return filepath.Join(home, ".ethash")
-}
-
-// cache wraps an ethash_light_t with some metadata
-// and automatic memory management.
-type cache struct {
-	epoch uint64
-	used  time.Time
-	test  bool
-
-	gen sync.Once // ensures cache is only generated once.
-	ptr *C.struct_ethash_light
-}
-
-// generate creates the actual cache. it can be called from multiple
-// goroutines. the first call will generate the cache, subsequent
-// calls wait until it is generated.
-func (cache *cache) generate() {
-	cache.gen.Do(func() {
-		started := time.Now()
-		seedHash := makeSeedHash(cache.epoch)
-		glog.V(logger.Debug).Infof("Generating cache for epoch %d (%x)", cache.epoch, seedHash)
-		size := C.ethash_get_cachesize(C.uint64_t(cache.epoch * epochLength))
-		if cache.test {
-			size = cacheSizeForTesting
-		}
-		cache.ptr = C.ethash_light_new_internal(size, (*C.ethash_h256_t)(unsafe.Pointer(&seedHash[0])))
-		runtime.SetFinalizer(cache, freeCache)
-		glog.V(logger.Debug).Infof("Done generating cache for epoch %d, it took %v", cache.epoch, time.Since(started))
-	})
-}
-
-func freeCache(cache *cache) {
-	C.ethash_light_delete(cache.ptr)
-	cache.ptr = nil
-}
-
-func (cache *cache) compute(dagSize uint64, hash common.Hash, nonce uint64) (ok bool, mixDigest, result common.Hash) {
-	ret := C.ethash_light_compute_internal(cache.ptr, C.uint64_t(dagSize), hashToH256(hash), C.uint64_t(nonce))
-	// Make sure cache is live until after the C call.
-	// This is important because a GC might happen and execute
-	// the finalizer before the call completes.
-	_ = cache
-	return bool(ret.success), h256ToHash(ret.mix_hash), h256ToHash(ret.result)
-}
-
-// Light implements the Verify half of the proof of work. It uses a few small
-// in-memory caches to verify the nonces found by Full.
-type Light struct {
-	test bool // If set, use a smaller cache size
-
-	mu     sync.Mutex        // Protects the per-epoch map of verification caches
-	caches map[uint64]*cache // Currently maintained verification caches
-	future *cache            // Pre-generated cache for the estimated future DAG
-
-	NumCaches int // Maximum number of caches to keep before eviction (only init, don't modify)
-}
-
-// Verify checks whether the block's nonce is valid.
-func (l *Light) Verify(block pow.Block) bool {
-	// TODO: do ethash_quick_verify before getCache in order
-	// to prevent DOS attacks.
-	blockNum := block.NumberU64()
-	if blockNum >= epochLength*2048 {
-		glog.V(logger.Debug).Infof("block number %d too high, limit is %d", epochLength*2048)
-		return false
-	}
-
-	difficulty := block.Difficulty()
-	/* Cannot happen if block header diff is validated prior to PoW, but can
-		 happen if PoW is checked first due to parallel PoW checking.
-		 We could check the minimum valid difficulty but for SoC we avoid (duplicating)
-	   Ethereum protocol consensus rules here which are not in scope of Ethash
-	*/
-	if difficulty.Cmp(common.Big0) == 0 {
-		glog.V(logger.Debug).Infof("invalid block difficulty")
-		return false
-	}
-
-	cache := l.getCache(blockNum)
-	dagSize := C.ethash_get_datasize(C.uint64_t(blockNum))
-	if l.test {
-		dagSize = dagSizeForTesting
-	}
-	// Recompute the hash using the cache.
-	ok, mixDigest, result := cache.compute(uint64(dagSize), block.HashNoNonce(), block.Nonce())
-	if !ok {
-		return false
-	}
-
-	// avoid mixdigest malleability as it's not included in a block's "hashNononce"
-	if block.MixDigest() != mixDigest {
-		return false
-	}
-
-	// The actual check.
-	target := new(big.Int).Div(maxUint256, difficulty)
-	return result.Big().Cmp(target) <= 0
-}
-
-func h256ToHash(in C.ethash_h256_t) common.Hash {
-	return *(*common.Hash)(unsafe.Pointer(&in.b))
-}
-
-func hashToH256(in common.Hash) C.ethash_h256_t {
-	return C.ethash_h256_t{b: *(*[32]C.uint8_t)(unsafe.Pointer(&in[0]))}
-}
-
-func (l *Light) getCache(blockNum uint64) *cache {
-	var c *cache
-	epoch := blockNum / epochLength
-
-	// If we have a PoW for that epoch, use that
-	l.mu.Lock()
-	if l.caches == nil {
-		l.caches = make(map[uint64]*cache)
-	}
-	if l.NumCaches == 0 {
-		l.NumCaches = 3
-	}
-	c = l.caches[epoch]
-	if c == nil {
-		// No cached DAG, evict the oldest if the cache limit was reached
-		if len(l.caches) >= l.NumCaches {
-			var evict *cache
-			for _, cache := range l.caches {
-				if evict == nil || evict.used.After(cache.used) {
-					evict = cache
-				}
-			}
-			glog.V(logger.Debug).Infof("Evicting DAG for epoch %d in favour of epoch %d", evict.epoch, epoch)
-			delete(l.caches, evict.epoch)
-		}
-		// If we have the new DAG pre-generated, use that, otherwise create a new one
-		if l.future != nil && l.future.epoch == epoch {
-			glog.V(logger.Debug).Infof("Using pre-generated DAG for epoch %d", epoch)
-			c, l.future = l.future, nil
-		} else {
-			glog.V(logger.Debug).Infof("No pre-generated DAG available, creating new for epoch %d", epoch)
-			c = &cache{epoch: epoch, test: l.test}
-		}
-		l.caches[epoch] = c
-
-		// If we just used up the future cache, or need a refresh, regenerate
-		if l.future == nil || l.future.epoch <= epoch {
-			glog.V(logger.Debug).Infof("Pre-generating DAG for epoch %d", epoch+1)
-			l.future = &cache{epoch: epoch + 1, test: l.test}
-			go l.future.generate()
-		}
-	}
-	c.used = time.Now()
-	l.mu.Unlock()
-
-	// Wait for generation finish and return the cache
-	c.generate()
-	return c
-}
-
-// dag wraps an ethash_full_t with some metadata
-// and automatic memory management.
-type dag struct {
-	epoch uint64
-	test  bool
-	dir   string
-
-	gen sync.Once // ensures DAG is only generated once.
-	ptr *C.struct_ethash_full
-}
-
-// generate creates the actual DAG. it can be called from multiple
-// goroutines. the first call will generate the DAG, subsequent
-// calls wait until it is generated.
-func (d *dag) generate() {
-	d.gen.Do(func() {
-		var (
-			started   = time.Now()
-			seedHash  = makeSeedHash(d.epoch)
-			blockNum  = C.uint64_t(d.epoch * epochLength)
-			cacheSize = C.ethash_get_cachesize(blockNum)
-			dagSize   = C.ethash_get_datasize(blockNum)
-		)
-		if d.test {
-			cacheSize = cacheSizeForTesting
-			dagSize = dagSizeForTesting
-		}
-		if d.dir == "" {
-			d.dir = DefaultDir
-		}
-		glog.V(logger.Info).Infof("Generating DAG for epoch %d (size %d) (%x)", d.epoch, dagSize, seedHash)
-		// Generate a temporary cache.
-		// TODO: this could share the cache with Light
-		cache := C.ethash_light_new_internal(cacheSize, (*C.ethash_h256_t)(unsafe.Pointer(&seedHash[0])))
-		defer C.ethash_light_delete(cache)
-		// Generate the actual DAG.
-		d.ptr = C.ethash_full_new_internal(
-			C.CString(d.dir),
-			hashToH256(seedHash),
-			dagSize,
-			cache,
-			(C.ethash_callback_t)(unsafe.Pointer(C.ethashGoCallback_cgo)),
-		)
-		if d.ptr == nil {
-			panic("ethash_full_new IO or memory error")
-		}
-		runtime.SetFinalizer(d, freeDAG)
-		glog.V(logger.Info).Infof("Done generating DAG for epoch %d, it took %v", d.epoch, time.Since(started))
-	})
-}
-
-func freeDAG(d *dag) {
-	C.ethash_full_delete(d.ptr)
-	d.ptr = nil
-}
-
-func (d *dag) Ptr() unsafe.Pointer {
-	return unsafe.Pointer(d.ptr.data)
-}
-
-//export ethashGoCallback
-func ethashGoCallback(percent C.unsigned) C.int {
-	glog.V(logger.Info).Infof("Generating DAG: %d%%", percent)
-	return 0
-}
-
-// MakeDAG pre-generates a DAG file for the given block number in the
-// given directory. If dir is the empty string, the default directory
-// is used.
-func MakeDAG(blockNum uint64, dir string) error {
-	d := &dag{epoch: blockNum / epochLength, dir: dir}
-	if blockNum >= epochLength*2048 {
-		return fmt.Errorf("block number too high, limit is %d", epochLength*2048)
-	}
-	d.generate()
-	if d.ptr == nil {
-		return errors.New("failed")
-	}
-	return nil
-}
-
-// Full implements the Search half of the proof of work.
-type Full struct {
-	Dir string // use this to specify a non-default DAG directory
-
-	test     bool // if set use a smaller DAG size
-	turbo    bool
-	hashRate int32
-
-	mu      sync.Mutex // protects dag
-	current *dag       // current full DAG
-}
-
-func (pow *Full) getDAG(blockNum uint64) (d *dag) {
-	epoch := blockNum / epochLength
-	pow.mu.Lock()
-	if pow.current != nil && pow.current.epoch == epoch {
-		d = pow.current
-	} else {
-		d = &dag{epoch: epoch, test: pow.test, dir: pow.Dir}
-		pow.current = d
-	}
-	pow.mu.Unlock()
-	// wait for it to finish generating.
-	d.generate()
-	return d
-}
-
-func (pow *Full) Search(block pow.Block, stop <-chan struct{}, index int) (nonce uint64, mixDigest []byte) {
-	dag := pow.getDAG(block.NumberU64())
-
-	r := rand.New(rand.NewSource(time.Now().UnixNano()))
-	diff := block.Difficulty()
-
-	i := int64(0)
-	starti := i
-	start := time.Now().UnixNano()
-	previousHashrate := int32(0)
-
-	nonce = uint64(r.Int63())
-	hash := hashToH256(block.HashNoNonce())
-	target := new(big.Int).Div(maxUint256, diff)
-	for {
-		select {
-		case <-stop:
-			atomic.AddInt32(&pow.hashRate, -previousHashrate)
-			return 0, nil
-		default:
-			i++
-
-			// we don't have to update hash rate on every nonce, so update after
-			// first nonce check and then after 2^X nonces
-			if i == 2 || ((i % (1 << 16)) == 0) {
-				elapsed := time.Now().UnixNano() - start
-				hashes := (float64(1e9) / float64(elapsed)) * float64(i-starti)
-				hashrateDiff := int32(hashes) - previousHashrate
-				previousHashrate = int32(hashes)
-				atomic.AddInt32(&pow.hashRate, hashrateDiff)
-			}
-
-			ret := C.ethash_full_compute(dag.ptr, hash, C.uint64_t(nonce))
-			result := h256ToHash(ret.result).Big()
-
-			// TODO: disagrees with the spec https://github.com/ethereum/wiki/wiki/Ethash#mining
-			if ret.success && result.Cmp(target) <= 0 {
-				mixDigest = C.GoBytes(unsafe.Pointer(&ret.mix_hash), C.int(32))
-				atomic.AddInt32(&pow.hashRate, -previousHashrate)
-				return nonce, mixDigest
-			}
-			nonce += 1
-		}
-
-		if !pow.turbo {
-			time.Sleep(20 * time.Microsecond)
-		}
-	}
-}
-
-func (pow *Full) GetHashrate() int64 {
-	return int64(atomic.LoadInt32(&pow.hashRate))
-}
-
-func (pow *Full) Turbo(on bool) {
-	// TODO: this needs to use an atomic operation.
-	pow.turbo = on
-}
-
-// Ethash combines block verification with Light and
-// nonce searching with Full into a single proof of work.
-type Ethash struct {
-	*Light
-	*Full
-}
-
-// New creates an instance of the proof of work.
-func New() *Ethash {
-	return &Ethash{new(Light), &Full{turbo: true}}
-}
-
-// NewShared creates an instance of the proof of work., where a single instance
-// of the Light cache is shared across all instances created with NewShared.
-func NewShared() *Ethash {
-	return &Ethash{sharedLight, &Full{turbo: true}}
-}
-
-// NewForTesting creates a proof of work for use in unit tests.
-// It uses a smaller DAG and cache size to keep test times low.
-// DAG files are stored in a temporary directory.
-//
-// Nonces found by a testing instance are not verifiable with a
-// regular-size cache.
-func NewForTesting() (*Ethash, error) {
-	dir, err := ioutil.TempDir("", "ethash-test")
-	if err != nil {
-		return nil, err
-	}
-	return &Ethash{&Light{test: true}, &Full{Dir: dir, test: true}}, nil
-}
-
-func GetSeedHash(blockNum uint64) ([]byte, error) {
-	if blockNum >= epochLength*2048 {
-		return nil, fmt.Errorf("block number too high, limit is %d", epochLength*2048)
-	}
-	sh := makeSeedHash(blockNum / epochLength)
-	return sh[:], nil
-}
-
-func makeSeedHash(epoch uint64) (sh common.Hash) {
-	for ; epoch > 0; epoch-- {
-		sh = crypto.Sha3Hash(sh[:])
-	}
-	return sh
-}

Godeps/_workspace/src/github.com/ethereum/ethash/ethash_opencl.go

@@ -1,628 +0,0 @@
-// Copyright 2014 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-// +build opencl
-
-package ethash
-
-//#cgo LDFLAGS: -w
-//#include <stdint.h>
-//#include <string.h>
-//#include "src/libethash/internal.h"
-import "C"
-
-import (
-	crand "crypto/rand"
-	"encoding/binary"
-	"fmt"
-	"math"
-	"math/big"
-	mrand "math/rand"
-	"strconv"
-	"strings"
-	"sync"
-	"sync/atomic"
-	"time"
-	"unsafe"
-
-	"github.com/Gustav-Simonsson/go-opencl/cl"
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/pow"
-)
-
-/*
-
-  This code have two main entry points:
-
-  1. The initCL(...)  function configures one or more OpenCL device
-     (for now only GPU) and loads the Ethash DAG onto device memory
-
-  2. The Search(...) function loads a Ethash nonce into device(s) memory and
-     executes the Ethash OpenCL kernel.
-
-  Throughout the code, we refer to "host memory" and "device memory".
-  For most systems (e.g. regular PC GPU miner) the host memory is RAM and
-  device memory is the GPU global memory (e.g. GDDR5).
-
-  References mentioned in code comments:
-
-  1. https://github.com/ethereum/wiki/wiki/Ethash
-  2. https://github.com/ethereum/cpp-ethereum/blob/develop/libethash-cl/ethash_cl_miner.cpp
-  3. https://www.khronos.org/registry/cl/sdk/1.2/docs/man/xhtml/
-  4. http://amd-dev.wpengine.netdna-cdn.com/wordpress/media/2013/12/AMD_OpenCL_Programming_User_Guide.pdf
-
-*/
-
-type OpenCLDevice struct {
-	deviceId int
-	device   *cl.Device
-	openCL11 bool // OpenCL version 1.1 and 1.2 are handled a bit different
-	openCL12 bool
-
-	dagBuf        *cl.MemObject // Ethash full DAG in device mem
-	headerBuf     *cl.MemObject // Hash of block-to-mine in device mem
-	searchBuffers []*cl.MemObject
-
-	searchKernel *cl.Kernel
-	hashKernel   *cl.Kernel
-
-	queue         *cl.CommandQueue
-	ctx           *cl.Context
-	workGroupSize int
-
-	nonceRand *mrand.Rand // seeded by crypto/rand, see comments where it's initialised
-	result    common.Hash
-}
-
-type OpenCLMiner struct {
-	mu sync.Mutex
-
-	ethash *Ethash // Ethash full DAG & cache in host mem
-
-	deviceIds []int
-	devices   []*OpenCLDevice
-
-	dagSize uint64
-
-	hashRate int32 // Go atomics & uint64 have some issues; int32 is supported on all platforms
-}
-
-type pendingSearch struct {
-	bufIndex   uint32
-	startNonce uint64
-}
-
-const (
-	SIZEOF_UINT32 = 4
-
-	// See [1]
-	ethashMixBytesLen = 128
-	ethashAccesses    = 64
-
-	// See [4]
-	workGroupSize    = 32 // must be multiple of 8
-	maxSearchResults = 63
-	searchBufSize    = 2
-	globalWorkSize   = 1024 * 256
-)
-
-func NewCL(deviceIds []int) *OpenCLMiner {
-	ids := make([]int, len(deviceIds))
-	copy(ids, deviceIds)
-	return &OpenCLMiner{
-		ethash:    New(),
-		dagSize:   0, // to see if we need to update DAG.
-		deviceIds: ids,
-	}
-}
-
-func PrintDevices() {
-	fmt.Println("=============================================")
-	fmt.Println("============ OpenCL Device Info =============")
-	fmt.Println("=============================================")
-
-	var found []*cl.Device
-
-	platforms, err := cl.GetPlatforms()
-	if err != nil {
-		fmt.Println("Plaform error (check your OpenCL installation):", err)
-		return
-	}
-
-	for i, p := range platforms {
-		fmt.Println("Platform id             ", i)
-		fmt.Println("Platform Name           ", p.Name())
-		fmt.Println("Platform Vendor         ", p.Vendor())
-		fmt.Println("Platform Version        ", p.Version())
-		fmt.Println("Platform Extensions     ", p.Extensions())
-		fmt.Println("Platform Profile        ", p.Profile())
-		fmt.Println("")
-
-		devices, err := cl.GetDevices(p, cl.DeviceTypeGPU)
-		if err != nil {
-			fmt.Println("Device error (check your GPU drivers) :", err)
-			return
-		}
-
-		for _, d := range devices {
-			fmt.Println("Device OpenCL id        ", i)
-			fmt.Println("Device id for mining    ", len(found))
-			fmt.Println("Device Name             ", d.Name())
-			fmt.Println("Vendor                  ", d.Vendor())
-			fmt.Println("Version                 ", d.Version())
-			fmt.Println("Driver version          ", d.DriverVersion())
-			fmt.Println("Address bits            ", d.AddressBits())
-			fmt.Println("Max clock freq          ", d.MaxClockFrequency())
-			fmt.Println("Global mem size         ", d.GlobalMemSize())
-			fmt.Println("Max constant buffer size", d.MaxConstantBufferSize())
-			fmt.Println("Max mem alloc size      ", d.MaxMemAllocSize())
-			fmt.Println("Max compute units       ", d.MaxComputeUnits())
-			fmt.Println("Max work group size     ", d.MaxWorkGroupSize())
-			fmt.Println("Max work item sizes     ", d.MaxWorkItemSizes())
-			fmt.Println("=============================================")
-
-			found = append(found, d)
-		}
-	}
-	if len(found) == 0 {
-		fmt.Println("Found no GPU(s). Check that your OS can see the GPU(s)")
-	} else {
-		var idsFormat string
-		for i := 0; i < len(found); i++ {
-			idsFormat += strconv.Itoa(i)
-			if i != len(found)-1 {
-				idsFormat += ","
-			}
-		}
-		fmt.Printf("Found %v devices. Benchmark first GPU:       geth gpubench 0\n", len(found))
-		fmt.Printf("Mine using all GPUs:                        geth --minegpu %v\n", idsFormat)
-	}
-}
-
-// See [2]. We basically do the same here, but the Go OpenCL bindings
-// are at a slightly higher abtraction level.
-func InitCL(blockNum uint64, c *OpenCLMiner) error {
-	platforms, err := cl.GetPlatforms()
-	if err != nil {
-		return fmt.Errorf("Plaform error: %v\nCheck your OpenCL installation and then run geth gpuinfo", err)
-	}
-
-	var devices []*cl.Device
-	for _, p := range platforms {
-		ds, err := cl.GetDevices(p, cl.DeviceTypeGPU)
-		if err != nil {
-			return fmt.Errorf("Devices error: %v\nCheck your GPU drivers and then run geth gpuinfo", err)
-		}
-		for _, d := range ds {
-			devices = append(devices, d)
-		}
-	}
-
-	pow := New()
-	_ = pow.getDAG(blockNum)     // generates DAG if we don't have it
-	pow.Light.getCache(blockNum) // and cache
-
-	c.ethash = pow
-	dagSize := uint64(C.ethash_get_datasize(C.uint64_t(blockNum)))
-	c.dagSize = dagSize
-
-	for _, id := range c.deviceIds {
-		if id > len(devices)-1 {
-			return fmt.Errorf("Device id not found. See available device ids with: geth gpuinfo")
-		} else {
-			err := initCLDevice(id, devices[id], c)
-			if err != nil {
-				return err
-			}
-		}
-	}
-	if len(c.devices) == 0 {
-		return fmt.Errorf("No GPU devices found")
-	}
-	return nil
-}
-
-func initCLDevice(deviceId int, device *cl.Device, c *OpenCLMiner) error {
-	devMaxAlloc := uint64(device.MaxMemAllocSize())
-	devGlobalMem := uint64(device.GlobalMemSize())
-
-	// TODO: more fine grained version logic
-	if device.Version() == "OpenCL 1.0" {
-		fmt.Println("Device OpenCL version not supported: ", device.Version())
-		return fmt.Errorf("opencl version not supported")
-	}
-
-	var cl11, cl12 bool
-	if device.Version() == "OpenCL 1.1" {
-		cl11 = true
-	}
-	if device.Version() == "OpenCL 1.2" {
-		cl12 = true
-	}
-
-	// log warnings but carry on; some device drivers report inaccurate values
-	if c.dagSize > devGlobalMem {
-		fmt.Printf("WARNING: device memory may be insufficient: %v. DAG size: %v.\n", devGlobalMem, c.dagSize)
-	}
-
-	if c.dagSize > devMaxAlloc {
-		fmt.Printf("WARNING: DAG size (%v) larger than device max memory allocation size (%v).\n", c.dagSize, devMaxAlloc)
-		fmt.Printf("You probably have to export GPU_MAX_ALLOC_PERCENT=95\n")
-	}
-
-	fmt.Printf("Initialising device %v: %v\n", deviceId, device.Name())
-
-	context, err := cl.CreateContext([]*cl.Device{device})
-	if err != nil {
-		return fmt.Errorf("failed creating context: %v", err)
-	}
-
-	// TODO: test running with CL_QUEUE_PROFILING_ENABLE for profiling?
-	queue, err := context.CreateCommandQueue(device, 0)
-	if err != nil {
-		return fmt.Errorf("command queue err: %v", err)
-	}
-
-	// See [4] section 3.2 and [3] "clBuildProgram".
-	// The OpenCL kernel code is compiled at run-time.
-	kvs := make(map[string]string, 4)
-	kvs["GROUP_SIZE"] = strconv.FormatUint(workGroupSize, 10)
-	kvs["DAG_SIZE"] = strconv.FormatUint(c.dagSize/ethashMixBytesLen, 10)
-	kvs["ACCESSES"] = strconv.FormatUint(ethashAccesses, 10)
-	kvs["MAX_OUTPUTS"] = strconv.FormatUint(maxSearchResults, 10)
-	kernelCode := replaceWords(kernel, kvs)
-
-	program, err := context.CreateProgramWithSource([]string{kernelCode})
-	if err != nil {
-		return fmt.Errorf("program err: %v", err)
-	}
-
-	/* if using AMD OpenCL impl, you can set this to debug on x86 CPU device.
-	   see AMD OpenCL programming guide section 4.2
-
-	   export in shell before running:
-	   export AMD_OCL_BUILD_OPTIONS_APPEND="-g -O0"
-	   export CPU_MAX_COMPUTE_UNITS=1
-
-	buildOpts := "-g -cl-opt-disable"
-
-	*/
-	buildOpts := ""
-	err = program.BuildProgram([]*cl.Device{device}, buildOpts)
-	if err != nil {
-		return fmt.Errorf("program build err: %v", err)
-	}
-
-	var searchKernelName, hashKernelName string
-	searchKernelName = "ethash_search"
-	hashKernelName = "ethash_hash"
-
-	searchKernel, err := program.CreateKernel(searchKernelName)
-	hashKernel, err := program.CreateKernel(hashKernelName)
-	if err != nil {
-		return fmt.Errorf("kernel err: %v", err)
-	}
-
-	// TODO: when this DAG size appears, patch the Go bindings
-	// (context.go) to work with uint64 as size_t
-	if c.dagSize > math.MaxInt32 {
-		fmt.Println("DAG too large for allocation.")
-		return fmt.Errorf("DAG too large for alloc")
-	}
-
-	// TODO: patch up Go bindings to work with size_t, will overflow if > maxint32
-	// TODO: fuck. shit's gonna overflow around 2017-06-09 12:17:02
-	dagBuf := *(new(*cl.MemObject))
-	dagBuf, err = context.CreateEmptyBuffer(cl.MemReadOnly, int(c.dagSize))
-	if err != nil {
-		return fmt.Errorf("allocating dag buf failed: %v", err)
-	}
-
-	// write DAG to device mem
-	dagPtr := unsafe.Pointer(c.ethash.Full.current.ptr.data)
-	_, err = queue.EnqueueWriteBuffer(dagBuf, true, 0, int(c.dagSize), dagPtr, nil)
-	if err != nil {
-		return fmt.Errorf("writing to dag buf failed: %v", err)
-	}
-
-	searchBuffers := make([]*cl.MemObject, searchBufSize)
-	for i := 0; i < searchBufSize; i++ {
-		searchBuff, err := context.CreateEmptyBuffer(cl.MemWriteOnly, (1+maxSearchResults)*SIZEOF_UINT32)
-		if err != nil {
-			return fmt.Errorf("search buffer err: %v", err)
-		}
-		searchBuffers[i] = searchBuff
-	}
-
-	headerBuf, err := context.CreateEmptyBuffer(cl.MemReadOnly, 32)
-	if err != nil {
-		return fmt.Errorf("header buffer err: %v", err)
-	}
-
-	// Unique, random nonces are crucial for mining efficieny.
-	// While we do not need cryptographically secure PRNG for nonces,
-	// we want to have uniform distribution and minimal repetition of nonces.
-	// We could guarantee strict uniqueness of nonces by generating unique ranges,
-	// but a int64 seed from crypto/rand should be good enough.
-	// we then use math/rand for speed and to avoid draining OS entropy pool
-	seed, err := crand.Int(crand.Reader, big.NewInt(math.MaxInt64))
-	if err != nil {
-		return err
-	}
-	nonceRand := mrand.New(mrand.NewSource(seed.Int64()))
-
-	deviceStruct := &OpenCLDevice{
-		deviceId: deviceId,
-		device:   device,
-		openCL11: cl11,
-		openCL12: cl12,
-
-		dagBuf:        dagBuf,
-		headerBuf:     headerBuf,
-		searchBuffers: searchBuffers,
-
-		searchKernel: searchKernel,
-		hashKernel:   hashKernel,
-
-		queue: queue,
-		ctx:   context,
-
-		workGroupSize: workGroupSize,
-
-		nonceRand: nonceRand,
-	}
-	c.devices = append(c.devices, deviceStruct)
-
-	return nil
-}
-
-func (c *OpenCLMiner) Search(block pow.Block, stop <-chan struct{}, index int) (uint64, []byte) {
-	c.mu.Lock()
-	newDagSize := uint64(C.ethash_get_datasize(C.uint64_t(block.NumberU64())))
-	if newDagSize > c.dagSize {
-		// TODO: clean up buffers from previous DAG?
-		err := InitCL(block.NumberU64(), c)
-		if err != nil {
-			fmt.Println("OpenCL init error: ", err)
-			return 0, []byte{0}
-		}
-	}
-	defer c.mu.Unlock()
-
-	// Avoid unneeded OpenCL initialisation if we received stop while running InitCL
-	select {
-	case <-stop:
-		return 0, []byte{0}
-	default:
-	}
-
-	headerHash := block.HashNoNonce()
-	diff := block.Difficulty()
-	target256 := new(big.Int).Div(maxUint256, diff)
-	target64 := new(big.Int).Rsh(target256, 192).Uint64()
-	var zero uint32 = 0
-
-	d := c.devices[index]
-
-	_, err := d.queue.EnqueueWriteBuffer(d.headerBuf, false, 0, 32, unsafe.Pointer(&headerHash[0]), nil)
-	if err != nil {
-		fmt.Println("Error in Search clEnqueueWriterBuffer : ", err)
-		return 0, []byte{0}
-	}
-
-	for i := 0; i < searchBufSize; i++ {
-		_, err := d.queue.EnqueueWriteBuffer(d.searchBuffers[i], false, 0, 4, unsafe.Pointer(&zero), nil)
-		if err != nil {
-			fmt.Println("Error in Search clEnqueueWriterBuffer : ", err)
-			return 0, []byte{0}
-		}
-	}
-
-	// wait for all search buffers to complete
-	err = d.queue.Finish()
-	if err != nil {
-		fmt.Println("Error in Search clFinish : ", err)
-		return 0, []byte{0}
-	}
-
-	err = d.searchKernel.SetArg(1, d.headerBuf)
-	if err != nil {
-		fmt.Println("Error in Search clSetKernelArg : ", err)
-		return 0, []byte{0}
-	}
-
-	err = d.searchKernel.SetArg(2, d.dagBuf)
-	if err != nil {
-		fmt.Println("Error in Search clSetKernelArg : ", err)
-		return 0, []byte{0}
-	}
-
-	err = d.searchKernel.SetArg(4, target64)
-	if err != nil {
-		fmt.Println("Error in Search clSetKernelArg : ", err)
-		return 0, []byte{0}
-	}
-	err = d.searchKernel.SetArg(5, uint32(math.MaxUint32))
-	if err != nil {
-		fmt.Println("Error in Search clSetKernelArg : ", err)
-		return 0, []byte{0}
-	}
-
-	// wait on this before returning
-	var preReturnEvent *cl.Event
-	if d.openCL12 {
-		preReturnEvent, err = d.ctx.CreateUserEvent()
-		if err != nil {
-			fmt.Println("Error in Search create CL user event : ", err)
-			return 0, []byte{0}
-		}
-	}
-
-	pending := make([]pendingSearch, 0, searchBufSize)
-	var p *pendingSearch
-	searchBufIndex := uint32(0)
-	var checkNonce uint64
-	loops := int64(0)
-	prevHashRate := int32(0)
-	start := time.Now().UnixNano()
-	// we grab a single random nonce and sets this as argument to the kernel search function
-	// the device will then add each local threads gid to the nonce, creating a unique nonce
-	// for each device computing unit executing in parallel
-	initNonce := uint64(d.nonceRand.Int63())
-	for nonce := initNonce; ; nonce += uint64(globalWorkSize) {
-		select {
-		case <-stop:
-
-			/*
-				if d.openCL12 {
-					err = cl.WaitForEvents([]*cl.Event{preReturnEvent})
-					if err != nil {
-						fmt.Println("Error in Search WaitForEvents: ", err)
-					}
-				}
-			*/
-
-			atomic.AddInt32(&c.hashRate, -prevHashRate)
-			return 0, []byte{0}
-		default:
-		}
-
-		if (loops % (1 << 7)) == 0 {
-			elapsed := time.Now().UnixNano() - start
-			// TODO: verify if this is correct hash rate calculation
-			hashes := (float64(1e9) / float64(elapsed)) * float64(loops*1024*256)
-			hashrateDiff := int32(hashes) - prevHashRate
-			prevHashRate = int32(hashes)
-			atomic.AddInt32(&c.hashRate, hashrateDiff)
-		}
-		loops++
-
-		err = d.searchKernel.SetArg(0, d.searchBuffers[searchBufIndex])
-		if err != nil {
-			fmt.Println("Error in Search clSetKernelArg : ", err)
-			return 0, []byte{0}
-		}
-		err = d.searchKernel.SetArg(3, nonce)
-		if err != nil {
-			fmt.Println("Error in Search clSetKernelArg : ", err)
-			return 0, []byte{0}
-		}
-
-		// execute kernel
-		_, err := d.queue.EnqueueNDRangeKernel(
-			d.searchKernel,
-			[]int{0},
-			[]int{globalWorkSize},
-			[]int{d.workGroupSize},
-			nil)
-		if err != nil {
-			fmt.Println("Error in Search clEnqueueNDRangeKernel : ", err)
-			return 0, []byte{0}
-		}
-
-		pending = append(pending, pendingSearch{bufIndex: searchBufIndex, startNonce: nonce})
-		searchBufIndex = (searchBufIndex + 1) % searchBufSize
-
-		if len(pending) == searchBufSize {
-			p = &(pending[searchBufIndex])
-			cres, _, err := d.queue.EnqueueMapBuffer(d.searchBuffers[p.bufIndex], true,
-				cl.MapFlagRead, 0, (1+maxSearchResults)*SIZEOF_UINT32,
-				nil)
-			if err != nil {
-				fmt.Println("Error in Search clEnqueueMapBuffer: ", err)
-				return 0, []byte{0}
-			}
-
-			results := cres.ByteSlice()
-			nfound := binary.LittleEndian.Uint32(results)
-			nfound = uint32(math.Min(float64(nfound), float64(maxSearchResults)))
-			// OpenCL returns the offsets from the start nonce
-			for i := uint32(0); i < nfound; i++ {
-				lo := (i + 1) * SIZEOF_UINT32
-				hi := (i + 2) * SIZEOF_UINT32
-				upperNonce := uint64(binary.LittleEndian.Uint32(results[lo:hi]))
-				checkNonce = p.startNonce + upperNonce
-				if checkNonce != 0 {
-					// We verify that the nonce is indeed a solution by
-					// executing the Ethash verification function (on the CPU).
-					cache := c.ethash.Light.getCache(block.NumberU64())
-					ok, mixDigest, result := cache.compute(c.dagSize, headerHash, checkNonce)
-
-					// TODO: return result first
-					if ok && result.Big().Cmp(target256) <= 0 {
-						_, err = d.queue.EnqueueUnmapMemObject(d.searchBuffers[p.bufIndex], cres, nil)
-						if err != nil {
-							fmt.Println("Error in Search clEnqueueUnmapMemObject: ", err)
-						}
-						if d.openCL12 {
-							err = cl.WaitForEvents([]*cl.Event{preReturnEvent})
-							if err != nil {
-								fmt.Println("Error in Search WaitForEvents: ", err)
-							}
-						}
-						return checkNonce, mixDigest.Bytes()
-					}
-					_, err := d.queue.EnqueueWriteBuffer(d.searchBuffers[p.bufIndex], false, 0, 4, unsafe.Pointer(&zero), nil)
-					if err != nil {
-						fmt.Println("Error in Search cl: EnqueueWriteBuffer", err)
-						return 0, []byte{0}
-					}
-				}
-			}
-			_, err = d.queue.EnqueueUnmapMemObject(d.searchBuffers[p.bufIndex], cres, nil)
-			if err != nil {
-				fmt.Println("Error in Search clEnqueueUnMapMemObject: ", err)
-				return 0, []byte{0}
-			}
-			pending = append(pending[:searchBufIndex], pending[searchBufIndex+1:]...)
-		}
-	}
-	if d.openCL12 {
-		err := cl.WaitForEvents([]*cl.Event{preReturnEvent})
-		if err != nil {
-			fmt.Println("Error in Search clWaitForEvents: ", err)
-			return 0, []byte{0}
-		}
-	}
-	return 0, []byte{0}
-}
-
-func (c *OpenCLMiner) Verify(block pow.Block) bool {
-	return c.ethash.Light.Verify(block)
-}
-func (c *OpenCLMiner) GetHashrate() int64 {
-	return int64(atomic.LoadInt32(&c.hashRate))
-}
-func (c *OpenCLMiner) Turbo(on bool) {
-	// This is GPU mining. Always be turbo.
-}
-
-func replaceWords(text string, kvs map[string]string) string {
-	for k, v := range kvs {
-		text = strings.Replace(text, k, v, -1)
-	}
-	return text
-}
-
-func logErr(err error) {
-	if err != nil {
-		fmt.Println("Error in OpenCL call:", err)
-	}
-}
-
-func argErr(err error) error {
-	return fmt.Errorf("arg err: %v", err)
-}

Godeps/_workspace/src/github.com/ethereum/ethash/ethash_opencl_kernel_go_str.go

@@ -1,600 +0,0 @@
-package ethash
-
-/*  DO NOT EDIT!!!
-
-    This code is version controlled at
-    https://github.com/ethereum/cpp-ethereum/blob/develop/libethash-cl/ethash_cl_miner_kernel.cl
-
-    If needed change it there first, then copy over here.
-*/
-
-const kernel = `
-// author Tim Hughes <tim@twistedfury.com>
-// Tested on Radeon HD 7850
-// Hashrate: 15940347 hashes/s
-// Bandwidth: 124533 MB/s
-// search kernel should fit in <= 84 VGPRS (3 wavefronts)
-
-#define THREADS_PER_HASH (128 / 16)
-#define HASHES_PER_LOOP (GROUP_SIZE / THREADS_PER_HASH)
-
-#define FNV_PRIME	0x01000193
-
-__constant uint2 const Keccak_f1600_RC[24] = {
-	(uint2)(0x00000001, 0x00000000),
-	(uint2)(0x00008082, 0x00000000),
-	(uint2)(0x0000808a, 0x80000000),
-	(uint2)(0x80008000, 0x80000000),
-	(uint2)(0x0000808b, 0x00000000),
-	(uint2)(0x80000001, 0x00000000),
-	(uint2)(0x80008081, 0x80000000),
-	(uint2)(0x00008009, 0x80000000),
-	(uint2)(0x0000008a, 0x00000000),
-	(uint2)(0x00000088, 0x00000000),
-	(uint2)(0x80008009, 0x00000000),
-	(uint2)(0x8000000a, 0x00000000),
-	(uint2)(0x8000808b, 0x00000000),
-	(uint2)(0x0000008b, 0x80000000),
-	(uint2)(0x00008089, 0x80000000),
-	(uint2)(0x00008003, 0x80000000),
-	(uint2)(0x00008002, 0x80000000),
-	(uint2)(0x00000080, 0x80000000),
-	(uint2)(0x0000800a, 0x00000000),
-	(uint2)(0x8000000a, 0x80000000),
-	(uint2)(0x80008081, 0x80000000),
-	(uint2)(0x00008080, 0x80000000),
-	(uint2)(0x80000001, 0x00000000),
-	(uint2)(0x80008008, 0x80000000),
-};
-
-void keccak_f1600_round(uint2* a, uint r, uint out_size)
-{
-   #if !__ENDIAN_LITTLE__
-	for (uint i = 0; i != 25; ++i)
-		a[i] = a[i].yx;
-   #endif
-
-	uint2 b[25];
-	uint2 t;
-
-	// Theta
-	b[0] = a[0] ^ a[5] ^ a[10] ^ a[15] ^ a[20];
-	b[1] = a[1] ^ a[6] ^ a[11] ^ a[16] ^ a[21];
-	b[2] = a[2] ^ a[7] ^ a[12] ^ a[17] ^ a[22];
-	b[3] = a[3] ^ a[8] ^ a[13] ^ a[18] ^ a[23];
-	b[4] = a[4] ^ a[9] ^ a[14] ^ a[19] ^ a[24];
-	t = b[4] ^ (uint2)(b[1].x << 1 | b[1].y >> 31, b[1].y << 1 | b[1].x >> 31);
-	a[0] ^= t;
-	a[5] ^= t;
-	a[10] ^= t;
-	a[15] ^= t;
-	a[20] ^= t;
-	t = b[0] ^ (uint2)(b[2].x << 1 | b[2].y >> 31, b[2].y << 1 | b[2].x >> 31);
-	a[1] ^= t;
-	a[6] ^= t;
-	a[11] ^= t;
-	a[16] ^= t;
-	a[21] ^= t;
-	t = b[1] ^ (uint2)(b[3].x << 1 | b[3].y >> 31, b[3].y << 1 | b[3].x >> 31);
-	a[2] ^= t;
-	a[7] ^= t;
-	a[12] ^= t;
-	a[17] ^= t;
-	a[22] ^= t;
-	t = b[2] ^ (uint2)(b[4].x << 1 | b[4].y >> 31, b[4].y << 1 | b[4].x >> 31);
-	a[3] ^= t;
-	a[8] ^= t;
-	a[13] ^= t;
-	a[18] ^= t;
-	a[23] ^= t;
-	t = b[3] ^ (uint2)(b[0].x << 1 | b[0].y >> 31, b[0].y << 1 | b[0].x >> 31);
-	a[4] ^= t;
-	a[9] ^= t;
-	a[14] ^= t;
-	a[19] ^= t;
-	a[24] ^= t;
-
-	// Rho Pi
-	b[0] = a[0];
-	b[10] = (uint2)(a[1].x << 1 | a[1].y >> 31, a[1].y << 1 | a[1].x >> 31);
-	b[7] = (uint2)(a[10].x << 3 | a[10].y >> 29, a[10].y << 3 | a[10].x >> 29);
-	b[11] = (uint2)(a[7].x << 6 | a[7].y >> 26, a[7].y << 6 | a[7].x >> 26);
-	b[17] = (uint2)(a[11].x << 10 | a[11].y >> 22, a[11].y << 10 | a[11].x >> 22);
-	b[18] = (uint2)(a[17].x << 15 | a[17].y >> 17, a[17].y << 15 | a[17].x >> 17);
-	b[3] = (uint2)(a[18].x << 21 | a[18].y >> 11, a[18].y << 21 | a[18].x >> 11);
-	b[5] = (uint2)(a[3].x << 28 | a[3].y >> 4, a[3].y << 28 | a[3].x >> 4);
-	b[16] = (uint2)(a[5].y << 4 | a[5].x >> 28, a[5].x << 4 | a[5].y >> 28);
-	b[8] = (uint2)(a[16].y << 13 | a[16].x >> 19, a[16].x << 13 | a[16].y >> 19);
-	b[21] = (uint2)(a[8].y << 23 | a[8].x >> 9, a[8].x << 23 | a[8].y >> 9);
-	b[24] = (uint2)(a[21].x << 2 | a[21].y >> 30, a[21].y << 2 | a[21].x >> 30);
-	b[4] = (uint2)(a[24].x << 14 | a[24].y >> 18, a[24].y << 14 | a[24].x >> 18);
-	b[15] = (uint2)(a[4].x << 27 | a[4].y >> 5, a[4].y << 27 | a[4].x >> 5);
-	b[23] = (uint2)(a[15].y << 9 | a[15].x >> 23, a[15].x << 9 | a[15].y >> 23);
-	b[19] = (uint2)(a[23].y << 24 | a[23].x >> 8, a[23].x << 24 | a[23].y >> 8);
-	b[13] = (uint2)(a[19].x << 8 | a[19].y >> 24, a[19].y << 8 | a[19].x >> 24);
-	b[12] = (uint2)(a[13].x << 25 | a[13].y >> 7, a[13].y << 25 | a[13].x >> 7);
-	b[2] = (uint2)(a[12].y << 11 | a[12].x >> 21, a[12].x << 11 | a[12].y >> 21);
-	b[20] = (uint2)(a[2].y << 30 | a[2].x >> 2, a[2].x << 30 | a[2].y >> 2);
-	b[14] = (uint2)(a[20].x << 18 | a[20].y >> 14, a[20].y << 18 | a[20].x >> 14);
-	b[22] = (uint2)(a[14].y << 7 | a[14].x >> 25, a[14].x << 7 | a[14].y >> 25);
-	b[9] = (uint2)(a[22].y << 29 | a[22].x >> 3, a[22].x << 29 | a[22].y >> 3);
-	b[6] = (uint2)(a[9].x << 20 | a[9].y >> 12, a[9].y << 20 | a[9].x >> 12);
-	b[1] = (uint2)(a[6].y << 12 | a[6].x >> 20, a[6].x << 12 | a[6].y >> 20);
-
-	// Chi
-	a[0] = bitselect(b[0] ^ b[2], b[0], b[1]);
-	a[1] = bitselect(b[1] ^ b[3], b[1], b[2]);
-	a[2] = bitselect(b[2] ^ b[4], b[2], b[3]);
-	a[3] = bitselect(b[3] ^ b[0], b[3], b[4]);
-	if (out_size >= 4)
-	{
-		a[4] = bitselect(b[4] ^ b[1], b[4], b[0]);
-		a[5] = bitselect(b[5] ^ b[7], b[5], b[6]);
-		a[6] = bitselect(b[6] ^ b[8], b[6], b[7]);
-		a[7] = bitselect(b[7] ^ b[9], b[7], b[8]);
-		a[8] = bitselect(b[8] ^ b[5], b[8], b[9]);
-		if (out_size >= 8)
-		{
-			a[9] = bitselect(b[9] ^ b[6], b[9], b[5]);
-			a[10] = bitselect(b[10] ^ b[12], b[10], b[11]);
-			a[11] = bitselect(b[11] ^ b[13], b[11], b[12]);
-			a[12] = bitselect(b[12] ^ b[14], b[12], b[13]);
-			a[13] = bitselect(b[13] ^ b[10], b[13], b[14]);
-			a[14] = bitselect(b[14] ^ b[11], b[14], b[10]);
-			a[15] = bitselect(b[15] ^ b[17], b[15], b[16]);
-			a[16] = bitselect(b[16] ^ b[18], b[16], b[17]);
-			a[17] = bitselect(b[17] ^ b[19], b[17], b[18]);
-			a[18] = bitselect(b[18] ^ b[15], b[18], b[19]);
-			a[19] = bitselect(b[19] ^ b[16], b[19], b[15]);
-			a[20] = bitselect(b[20] ^ b[22], b[20], b[21]);
-			a[21] = bitselect(b[21] ^ b[23], b[21], b[22]);
-			a[22] = bitselect(b[22] ^ b[24], b[22], b[23]);
-			a[23] = bitselect(b[23] ^ b[20], b[23], b[24]);
-			a[24] = bitselect(b[24] ^ b[21], b[24], b[20]);
-		}
-	}
-
-	// Iota
-	a[0] ^= Keccak_f1600_RC[r];
-
-   #if !__ENDIAN_LITTLE__
-	for (uint i = 0; i != 25; ++i)
-		a[i] = a[i].yx;
-   #endif
-}
-
-void keccak_f1600_no_absorb(ulong* a, uint in_size, uint out_size, uint isolate)
-{
-	for (uint i = in_size; i != 25; ++i)
-	{
-		a[i] = 0;
-	}
-#if __ENDIAN_LITTLE__
-	a[in_size] ^= 0x0000000000000001;
-	a[24-out_size*2] ^= 0x8000000000000000;
-#else
-	a[in_size] ^= 0x0100000000000000;
-	a[24-out_size*2] ^= 0x0000000000000080;
-#endif
-
-	// Originally I unrolled the first and last rounds to interface
-	// better with surrounding code, however I haven't done this
-	// without causing the AMD compiler to blow up the VGPR usage.
-	uint r = 0;
-	do
-	{
-		// This dynamic branch stops the AMD compiler unrolling the loop
-		// and additionally saves about 33% of the VGPRs, enough to gain another
-		// wavefront. Ideally we'd get 4 in flight, but 3 is the best I can
-		// massage out of the compiler. It doesn't really seem to matter how
-		// much we try and help the compiler save VGPRs because it seems to throw
-		// that information away, hence the implementation of keccak here
-		// doesn't bother.
-		if (isolate)
-		{
-			keccak_f1600_round((uint2*)a, r++, 25);
-		}
-	}
-	while (r < 23);
-
-	// final round optimised for digest size
-	keccak_f1600_round((uint2*)a, r++, out_size);
-}
-
-#define copy(dst, src, count) for (uint i = 0; i != count; ++i) { (dst)[i] = (src)[i]; }
-
-#define countof(x) (sizeof(x) / sizeof(x[0]))
-
-uint fnv(uint x, uint y)
-{
-	return x * FNV_PRIME ^ y;
-}
-
-uint4 fnv4(uint4 x, uint4 y)
-{
-	return x * FNV_PRIME ^ y;
-}
-
-uint fnv_reduce(uint4 v)
-{
-	return fnv(fnv(fnv(v.x, v.y), v.z), v.w);
-}
-
-typedef union
-{
-	ulong ulongs[32 / sizeof(ulong)];
-	uint uints[32 / sizeof(uint)];
-} hash32_t;
-
-typedef union
-{
-	ulong ulongs[64 / sizeof(ulong)];
-	uint4 uint4s[64 / sizeof(uint4)];
-} hash64_t;
-
-typedef union
-{
-	uint uints[128 / sizeof(uint)];
-	uint4 uint4s[128 / sizeof(uint4)];
-} hash128_t;
-
-hash64_t init_hash(__constant hash32_t const* header, ulong nonce, uint isolate)
-{
-	hash64_t init;
-	uint const init_size = countof(init.ulongs);
-	uint const hash_size = countof(header->ulongs);
-
-	// sha3_512(header .. nonce)
-	ulong state[25];
-	copy(state, header->ulongs, hash_size);
-	state[hash_size] = nonce;
-	keccak_f1600_no_absorb(state, hash_size + 1, init_size, isolate);
-
-	copy(init.ulongs, state, init_size);
-	return init;
-}
-
-uint inner_loop_chunks(uint4 init, uint thread_id, __local uint* share, __global hash128_t const* g_dag, __global hash128_t const* g_dag1, __global hash128_t const* g_dag2, __global hash128_t const* g_dag3, uint isolate)
-{
-	uint4 mix = init;
-
-	// share init0
-	if (thread_id == 0)
-		*share = mix.x;
-	barrier(CLK_LOCAL_MEM_FENCE);
-	uint init0 = *share;
-
-	uint a = 0;
-	do
-	{
-		bool update_share = thread_id == (a/4) % THREADS_PER_HASH;
-
-		#pragma unroll
-		for (uint i = 0; i != 4; ++i)
-		{
-			if (update_share)
-			{
-				uint m[4] = { mix.x, mix.y, mix.z, mix.w };
-				*share = fnv(init0 ^ (a+i), m[i]) % DAG_SIZE;
-			}
-			barrier(CLK_LOCAL_MEM_FENCE);
-
-			mix = fnv4(mix, *share>=3 * DAG_SIZE / 4 ? g_dag3[*share - 3 * DAG_SIZE / 4].uint4s[thread_id] : *share>=DAG_SIZE / 2 ? g_dag2[*share - DAG_SIZE / 2].uint4s[thread_id] : *share>=DAG_SIZE / 4 ? g_dag1[*share - DAG_SIZE / 4].uint4s[thread_id]:g_dag[*share].uint4s[thread_id]);
-		}
-	} while ((a += 4) != (ACCESSES & isolate));
-
-	return fnv_reduce(mix);
-}
-
-
-
-uint inner_loop(uint4 init, uint thread_id, __local uint* share, __global hash128_t const* g_dag, uint isolate)
-{
-	uint4 mix = init;
-
-	// share init0
-	if (thread_id == 0)
-		*share = mix.x;
-	barrier(CLK_LOCAL_MEM_FENCE);
-	uint init0 = *share;
-
-	uint a = 0;
-	do
-	{
-		bool update_share = thread_id == (a/4) % THREADS_PER_HASH;
-
-		#pragma unroll
-		for (uint i = 0; i != 4; ++i)
-		{
-			if (update_share)
-			{
-				uint m[4] = { mix.x, mix.y, mix.z, mix.w };
-				*share = fnv(init0 ^ (a+i), m[i]) % DAG_SIZE;
-			}
-			barrier(CLK_LOCAL_MEM_FENCE);
-
-			mix = fnv4(mix, g_dag[*share].uint4s[thread_id]);
-		}
-	}
-	while ((a += 4) != (ACCESSES & isolate));
-
-	return fnv_reduce(mix);
-}
-
-
-hash32_t final_hash(hash64_t const* init, hash32_t const* mix, uint isolate)
-{
-	ulong state[25];
-
-	hash32_t hash;
-	uint const hash_size = countof(hash.ulongs);
-	uint const init_size = countof(init->ulongs);
-	uint const mix_size = countof(mix->ulongs);
-
-	// keccak_256(keccak_512(header..nonce) .. mix);
-	copy(state, init->ulongs, init_size);
-	copy(state + init_size, mix->ulongs, mix_size);
-	keccak_f1600_no_absorb(state, init_size+mix_size, hash_size, isolate);
-
-	// copy out
-	copy(hash.ulongs, state, hash_size);
-	return hash;
-}
-
-hash32_t compute_hash_simple(
-	__constant hash32_t const* g_header,
-	__global hash128_t const* g_dag,
-	ulong nonce,
-	uint isolate
-	)
-{
-	hash64_t init = init_hash(g_header, nonce, isolate);
-
-	hash128_t mix;
-	for (uint i = 0; i != countof(mix.uint4s); ++i)
-	{
-		mix.uint4s[i] = init.uint4s[i % countof(init.uint4s)];
-	}
-
-	uint mix_val = mix.uints[0];
-	uint init0 = mix.uints[0];
-	uint a = 0;
-	do
-	{
-		uint pi = fnv(init0 ^ a, mix_val) % DAG_SIZE;
-		uint n = (a+1) % countof(mix.uints);
-
-		#pragma unroll
-		for (uint i = 0; i != countof(mix.uints); ++i)
-		{
-			mix.uints[i] = fnv(mix.uints[i], g_dag[pi].uints[i]);
-			mix_val = i == n ? mix.uints[i] : mix_val;
-		}
-	}
-	while (++a != (ACCESSES & isolate));
-
-	// reduce to output
-	hash32_t fnv_mix;
-	for (uint i = 0; i != countof(fnv_mix.uints); ++i)
-	{
-		fnv_mix.uints[i] = fnv_reduce(mix.uint4s[i]);
-	}
-
-	return final_hash(&init, &fnv_mix, isolate);
-}
-
-typedef union
-{
-	struct
-	{
-		hash64_t init;
-		uint pad; // avoid lds bank conflicts
-	};
-	hash32_t mix;
-} compute_hash_share;
-
-
-hash32_t compute_hash(
-	__local compute_hash_share* share,
-	__constant hash32_t const* g_header,
-	__global hash128_t const* g_dag,
-	ulong nonce,
-	uint isolate
-	)
-{
-	uint const gid = get_global_id(0);
-
-	// Compute one init hash per work item.
-	hash64_t init = init_hash(g_header, nonce, isolate);
-
-	// Threads work together in this phase in groups of 8.
-	uint const thread_id = gid % THREADS_PER_HASH;
-	uint const hash_id = (gid % GROUP_SIZE) / THREADS_PER_HASH;
-
-	hash32_t mix;
-	uint i = 0;
-	do
-	{
-		// share init with other threads
-		if (i == thread_id)
-			share[hash_id].init = init;
-		barrier(CLK_LOCAL_MEM_FENCE);
-
-		uint4 thread_init = share[hash_id].init.uint4s[thread_id % (64 / sizeof(uint4))];
-		barrier(CLK_LOCAL_MEM_FENCE);
-
-		uint thread_mix = inner_loop(thread_init, thread_id, share[hash_id].mix.uints, g_dag, isolate);
-
-		share[hash_id].mix.uints[thread_id] = thread_mix;
-		barrier(CLK_LOCAL_MEM_FENCE);
-
-		if (i == thread_id)
-			mix = share[hash_id].mix;
-		barrier(CLK_LOCAL_MEM_FENCE);
-	}
-	while (++i != (THREADS_PER_HASH & isolate));
-
-	return final_hash(&init, &mix, isolate);
-}
-
-
-hash32_t compute_hash_chunks(
-	__local compute_hash_share* share,
-	__constant hash32_t const* g_header,
-	__global hash128_t const* g_dag,
-	__global hash128_t const* g_dag1,
-	__global hash128_t const* g_dag2,
-	__global hash128_t const* g_dag3,
-	ulong nonce,
-	uint isolate
-	)
-{
-	uint const gid = get_global_id(0);
-
-	// Compute one init hash per work item.
-	hash64_t init = init_hash(g_header, nonce, isolate);
-
-	// Threads work together in this phase in groups of 8.
-	uint const thread_id = gid % THREADS_PER_HASH;
-	uint const hash_id = (gid % GROUP_SIZE) / THREADS_PER_HASH;
-
-	hash32_t mix;
-	uint i = 0;
-	do
-	{
-		// share init with other threads
-		if (i == thread_id)
-			share[hash_id].init = init;
-		barrier(CLK_LOCAL_MEM_FENCE);
-
-		uint4 thread_init = share[hash_id].init.uint4s[thread_id % (64 / sizeof(uint4))];
-		barrier(CLK_LOCAL_MEM_FENCE);
-
-		uint thread_mix = inner_loop_chunks(thread_init, thread_id, share[hash_id].mix.uints, g_dag, g_dag1, g_dag2, g_dag3, isolate);
-
-		share[hash_id].mix.uints[thread_id] = thread_mix;
-		barrier(CLK_LOCAL_MEM_FENCE);
-
-		if (i == thread_id)
-			mix = share[hash_id].mix;
-		barrier(CLK_LOCAL_MEM_FENCE);
-	}
-	while (++i != (THREADS_PER_HASH & isolate));
-
-	return final_hash(&init, &mix, isolate);
-}
-
-__attribute__((reqd_work_group_size(GROUP_SIZE, 1, 1)))
-__kernel void ethash_hash_simple(
-	__global hash32_t* g_hashes,
-	__constant hash32_t const* g_header,
-	__global hash128_t const* g_dag,
-	ulong start_nonce,
-	uint isolate
-	)
-{
-	uint const gid = get_global_id(0);
-	g_hashes[gid] = compute_hash_simple(g_header, g_dag, start_nonce + gid, isolate);
-}
-
-__attribute__((reqd_work_group_size(GROUP_SIZE, 1, 1)))
-__kernel void ethash_search_simple(
-	__global volatile uint* restrict g_output,
-	__constant hash32_t const* g_header,
-	__global hash128_t const* g_dag,
-	ulong start_nonce,
-	ulong target,
-	uint isolate
-	)
-{
-	uint const gid = get_global_id(0);
-	hash32_t hash = compute_hash_simple(g_header, g_dag, start_nonce + gid, isolate);
-
-	if (hash.ulongs[countof(hash.ulongs)-1] < target)
-	{
-		uint slot = min(convert_uint(MAX_OUTPUTS), convert_uint(atomic_inc(&g_output[0]) + 1));
-		g_output[slot] = gid;
-	}
-}
-
-
-__attribute__((reqd_work_group_size(GROUP_SIZE, 1, 1)))
-__kernel void ethash_hash(
-	__global hash32_t* g_hashes,
-	__constant hash32_t const* g_header,
-	__global hash128_t const* g_dag,
-	ulong start_nonce,
-	uint isolate
-	)
-{
-	__local compute_hash_share share[HASHES_PER_LOOP];
-
-	uint const gid = get_global_id(0);
-	g_hashes[gid] = compute_hash(share, g_header, g_dag, start_nonce + gid, isolate);
-}
-
-__attribute__((reqd_work_group_size(GROUP_SIZE, 1, 1)))
-__kernel void ethash_search(
-	__global volatile uint* restrict g_output,
-	__constant hash32_t const* g_header,
-	__global hash128_t const* g_dag,
-	ulong start_nonce,
-	ulong target,
-	uint isolate
-	)
-{
-	__local compute_hash_share share[HASHES_PER_LOOP];
-
-	uint const gid = get_global_id(0);
-	hash32_t hash = compute_hash(share, g_header, g_dag, start_nonce + gid, isolate);
-
-	if (as_ulong(as_uchar8(hash.ulongs[0]).s76543210) < target)
-	{
-		uint slot = min((uint)MAX_OUTPUTS, atomic_inc(&g_output[0]) + 1);
-		g_output[slot] = gid;
-	}
-}
-
-__attribute__((reqd_work_group_size(GROUP_SIZE, 1, 1)))
-__kernel void ethash_hash_chunks(
-	__global hash32_t* g_hashes,
-	__constant hash32_t const* g_header,
-	__global hash128_t const* g_dag,
-	__global hash128_t const* g_dag1,
-	__global hash128_t const* g_dag2,
-	__global hash128_t const* g_dag3,
-	ulong start_nonce,
-	uint isolate
-	)
-{
-	__local compute_hash_share share[HASHES_PER_LOOP];
-
-	uint const gid = get_global_id(0);
-	g_hashes[gid] = compute_hash_chunks(share, g_header, g_dag, g_dag1, g_dag2, g_dag3,start_nonce + gid, isolate);
-}
-
-__attribute__((reqd_work_group_size(GROUP_SIZE, 1, 1)))
-__kernel void ethash_search_chunks(
-	__global volatile uint* restrict g_output,
-	__constant hash32_t const* g_header,
-	__global hash128_t const* g_dag,
-	__global hash128_t const* g_dag1,
-	__global hash128_t const* g_dag2,
-	__global hash128_t const* g_dag3,
-	ulong start_nonce,
-	ulong target,
-	uint isolate
-	)
-{
-	__local compute_hash_share share[HASHES_PER_LOOP];
-
-	uint const gid = get_global_id(0);
-	hash32_t hash = compute_hash_chunks(share, g_header, g_dag, g_dag1, g_dag2, g_dag3, start_nonce + gid, isolate);
-
-	if (as_ulong(as_uchar8(hash.ulongs[0]).s76543210) < target)
-	{
-		uint slot = min(convert_uint(MAX_OUTPUTS), convert_uint(atomic_inc(&g_output[0]) + 1));
-		g_output[slot] = gid;
-	}
-}
-`

Godeps/_workspace/src/github.com/ethereum/ethash/ethashc.go

@@ -1,51 +0,0 @@
-// Copyright 2015 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package ethash
-
-/*
- -mno-stack-arg-probe disables stack probing which avoids the function
- __chkstk_ms being linked. this avoids a clash of this symbol as we also
- separately link the secp256k1 lib which ends up defining this symbol
-
- 1. https://gcc.gnu.org/onlinedocs/gccint/Stack-Checking.html
- 2. https://groups.google.com/forum/#!msg/golang-dev/v1bziURSQ4k/88fXuJ24e-gJ
- 3. https://groups.google.com/forum/#!topic/golang-nuts/VNP6Mwz_B6o
-
-*/
-
-/*
-#cgo CFLAGS: -std=gnu99 -Wall
-#cgo windows CFLAGS: -mno-stack-arg-probe
-#cgo LDFLAGS: -lm
-
-#include "src/libethash/internal.c"
-#include "src/libethash/sha3.c"
-#include "src/libethash/io.c"
-
-#ifdef _WIN32
-#	include "src/libethash/io_win32.c"
-#	include "src/libethash/mmap_win32.c"
-#else
-#	include "src/libethash/io_posix.c"
-#endif
-
-// 'gateway function' for calling back into go.
-extern int ethashGoCallback(unsigned);
-int ethashGoCallback_cgo(unsigned percent) { return ethashGoCallback(percent); }
-
-*/
-import "C"

Godeps/_workspace/src/github.com/ethereum/ethash/setup.py

@@ -1,47 +0,0 @@
-#!/usr/bin/env python
-import os
-from distutils.core import setup, Extension
-sources = [
-    'src/python/core.c',
-    'src/libethash/io.c',
-    'src/libethash/internal.c',
-    'src/libethash/sha3.c']
-if os.name == 'nt':
-    sources += [
-        'src/libethash/util_win32.c',
-        'src/libethash/io_win32.c',
-        'src/libethash/mmap_win32.c',
-    ]
-else:
-    sources += [
-        'src/libethash/io_posix.c'
-    ]
-depends = [
-    'src/libethash/ethash.h',
-    'src/libethash/compiler.h',
-    'src/libethash/data_sizes.h',
-    'src/libethash/endian.h',
-    'src/libethash/ethash.h',
-    'src/libethash/io.h',
-    'src/libethash/fnv.h',
-    'src/libethash/internal.h',
-    'src/libethash/sha3.h',
-    'src/libethash/util.h',
-]
-pyethash = Extension('pyethash',
-                     sources=sources,
-                     depends=depends,
-                     extra_compile_args=["-Isrc/", "-std=gnu99", "-Wall"])
-
-setup(
-    name='pyethash',
-    author="Matthew Wampler-Doty",
-    author_email="matthew.wampler.doty@gmail.com",
-    license='GPL',
-    version='0.1.23',
-    url='https://github.com/ethereum/ethash',
-    download_url='https://github.com/ethereum/ethash/tarball/v23',
-    description=('Python wrappers for ethash, the ethereum proof of work'
-                 'hashing function'),
-    ext_modules=[pyethash],
-)

Godeps/_workspace/src/github.com/fatih/color/.travis.yml

@@ -1,3 +0,0 @@
-language: go
-go: 1.3
-

Godeps/_workspace/src/github.com/fatih/color/README.md

@@ -1,151 +0,0 @@
-# Color [![GoDoc](http://img.shields.io/badge/go-documentation-blue.svg?style=flat-square)](http://godoc.org/github.com/fatih/color) [![Build Status](http://img.shields.io/travis/fatih/color.svg?style=flat-square)](https://travis-ci.org/fatih/color)
-
-
-
-Color lets you use colorized outputs in terms of [ANSI Escape Codes](http://en.wikipedia.org/wiki/ANSI_escape_code#Colors) in Go (Golang). It has support for Windows too! The API can be used in several ways, pick one that suits you.
-
-
-
-![Color](http://i.imgur.com/c1JI0lA.png)
-
-
-## Install
-
-```bash
-go get github.com/fatih/color
-```
-
-## Examples
-
-### Standard colors
-
-```go
-// Print with default helper functions
-color.Cyan("Prints text in cyan.")
-
-// A newline will be appended automatically
-color.Blue("Prints %s in blue.", "text")
-
-// These are using the default foreground colors
-color.Red("We have red")
-color.Magenta("And many others ..")
-
-```
-
-### Mix and reuse colors
-
-```go
-// Create a new color object
-c := color.New(color.FgCyan).Add(color.Underline)
-c.Println("Prints cyan text with an underline.")
-
-// Or just add them to New()
-d := color.New(color.FgCyan, color.Bold)
-d.Printf("This prints bold cyan %s\n", "too!.")
-
-// Mix up foreground and background colors, create new mixes!
-red := color.New(color.FgRed)
-
-boldRed := red.Add(color.Bold)
-boldRed.Println("This will print text in bold red.")
-
-whiteBackground := red.Add(color.BgWhite)
-whiteBackground.Println("Red text with white background.")
-```
-
-### Custom print functions (PrintFunc)
-
-```go
-// Create a custom print function for convenience
-red := color.New(color.FgRed).PrintfFunc()
-red("Warning")
-red("Error: %s", err)
-
-// Mix up multiple attributes
-notice := color.New(color.Bold, color.FgGreen).PrintlnFunc()
-notice("Don't forget this...")
-```
-
-### Insert into noncolor strings (SprintFunc)
-
-```go
-// Create SprintXxx functions to mix strings with other non-colorized strings:
-yellow := color.New(color.FgYellow).SprintFunc()
-red := color.New(color.FgRed).SprintFunc()
-fmt.Printf("This is a %s and this is %s.\n", yellow("warning"), red("error"))
-
-info := color.New(color.FgWhite, color.BgGreen).SprintFunc()
-fmt.Printf("This %s rocks!\n", info("package"))
-
-// Use helper functions
-fmt.Printf("This", color.RedString("warning"), "should be not neglected.")
-fmt.Printf(color.GreenString("Info:"), "an important message." )
-
-// Windows supported too! Just don't forget to change the output to color.Output
-fmt.Fprintf(color.Output, "Windows support: %s", color.GreenString("PASS"))
-```
-
-### Plug into existing code
-
-```go
-// Use handy standard colors
-color.Set(color.FgYellow)
-
-fmt.Println("Existing text will now be in yellow")
-fmt.Printf("This one %s\n", "too")
-
-color.Unset() // Don't forget to unset
-
-// You can mix up parameters
-color.Set(color.FgMagenta, color.Bold)
-defer color.Unset() // Use it in your function
-
-fmt.Println("All text will now be bold magenta.")
-```
-
-### Disable color
-
-There might be a case where you want to disable color output (for example to
-pipe the standard output of your app to somewhere else). `Color` has support to
-disable colors both globally and for single color definition. For example
-suppose you have a CLI app and a `--no-color` bool flag. You can easily disable
-the color output with:
-
-```go
-
-var flagNoColor = flag.Bool("no-color", false, "Disable color output")
-
-if *flagNoColor {
-	color.NoColor = true // disables colorized output
-}
-```
-
-It also has support for single color definitions (local). You can
-disable/enable color output on the fly:
-
-```go
-c := color.New(color.FgCyan)
-c.Println("Prints cyan text")
-
-c.DisableColor()
-c.Println("This is printed without any color")
-
-c.EnableColor()
-c.Println("This prints again cyan...")
-```
-
-## Todo
-
-* Save/Return previous values
-* Evaluate fmt.Formatter interface
-
-
-## Credits
-
- * [Fatih Arslan](https://github.com/fatih)
- * Windows support via @shiena: [ansicolor](https://github.com/shiena/ansicolor)
-
-## License
-
-The MIT License (MIT) - see [`LICENSE.md`](https://github.com/fatih/color/blob/master/LICENSE.md) for more details
-

Godeps/_workspace/src/github.com/fatih/color/color.go

@@ -1,402 +0,0 @@
-package color
-
-import (
-	"fmt"
-	"os"
-	"strconv"
-	"strings"
-
-	"github.com/mattn/go-colorable"
-	"github.com/mattn/go-isatty"
-)
-
-// NoColor defines if the output is colorized or not. It's dynamically set to
-// false or true based on the stdout's file descriptor referring to a terminal
-// or not. This is a global option and affects all colors. For more control
-// over each color block use the methods DisableColor() individually.
-var NoColor = !isatty.IsTerminal(os.Stdout.Fd())
-
-// Color defines a custom color object which is defined by SGR parameters.
-type Color struct {
-	params  []Attribute
-	noColor *bool
-}
-
-// Attribute defines a single SGR Code
-type Attribute int
-
-const escape = "\x1b"
-
-// Base attributes
-const (
-	Reset Attribute = iota
-	Bold
-	Faint
-	Italic
-	Underline
-	BlinkSlow
-	BlinkRapid
-	ReverseVideo
-	Concealed
-	CrossedOut
-)
-
-// Foreground text colors
-const (
-	FgBlack Attribute = iota + 30
-	FgRed
-	FgGreen
-	FgYellow
-	FgBlue
-	FgMagenta
-	FgCyan
-	FgWhite
-)
-
-// Foreground Hi-Intensity text colors
-const (
-	FgHiBlack Attribute = iota + 90
-	FgHiRed
-	FgHiGreen
-	FgHiYellow
-	FgHiBlue
-	FgHiMagenta
-	FgHiCyan
-	FgHiWhite
-)
-
-// Background text colors
-const (
-	BgBlack Attribute = iota + 40
-	BgRed
-	BgGreen
-	BgYellow
-	BgBlue
-	BgMagenta
-	BgCyan
-	BgWhite
-)
-
-// Background Hi-Intensity text colors
-const (
-	BgHiBlack Attribute = iota + 100
-	BgHiRed
-	BgHiGreen
-	BgHiYellow
-	BgHiBlue
-	BgHiMagenta
-	BgHiCyan
-	BgHiWhite
-)
-
-// New returns a newly created color object.
-func New(value ...Attribute) *Color {
-	c := &Color{params: make([]Attribute, 0)}
-	c.Add(value...)
-	return c
-}
-
-// Set sets the given parameters immediately. It will change the color of
-// output with the given SGR parameters until color.Unset() is called.
-func Set(p ...Attribute) *Color {
-	c := New(p...)
-	c.Set()
-	return c
-}
-
-// Unset resets all escape attributes and clears the output. Usually should
-// be called after Set().
-func Unset() {
-	if NoColor {
-		return
-	}
-
-	fmt.Fprintf(Output, "%s[%dm", escape, Reset)
-}
-
-// Set sets the SGR sequence.
-func (c *Color) Set() *Color {
-	if c.isNoColorSet() {
-		return c
-	}
-
-	fmt.Fprintf(Output, c.format())
-	return c
-}
-
-func (c *Color) unset() {
-	if c.isNoColorSet() {
-		return
-	}
-
-	Unset()
-}
-
-// Add is used to chain SGR parameters. Use as many as parameters to combine
-// and create custom color objects. Example: Add(color.FgRed, color.Underline).
-func (c *Color) Add(value ...Attribute) *Color {
-	c.params = append(c.params, value...)
-	return c
-}
-
-func (c *Color) prepend(value Attribute) {
-	c.params = append(c.params, 0)
-	copy(c.params[1:], c.params[0:])
-	c.params[0] = value
-}
-
-// Output defines the standard output of the print functions. By default
-// os.Stdout is used.
-var Output = colorable.NewColorableStdout()
-
-// Print formats using the default formats for its operands and writes to
-// standard output. Spaces are added between operands when neither is a
-// string. It returns the number of bytes written and any write error
-// encountered. This is the standard fmt.Print() method wrapped with the given
-// color.
-func (c *Color) Print(a ...interface{}) (n int, err error) {
-	c.Set()
-	defer c.unset()
-
-	return fmt.Fprint(Output, a...)
-}
-
-// Printf formats according to a format specifier and writes to standard output.
-// It returns the number of bytes written and any write error encountered.
-// This is the standard fmt.Printf() method wrapped with the given color.
-func (c *Color) Printf(format string, a ...interface{}) (n int, err error) {
-	c.Set()
-	defer c.unset()
-
-	return fmt.Fprintf(Output, format, a...)
-}
-
-// Println formats using the default formats for its operands and writes to
-// standard output. Spaces are always added between operands and a newline is
-// appended. It returns the number of bytes written and any write error
-// encountered. This is the standard fmt.Print() method wrapped with the given
-// color.
-func (c *Color) Println(a ...interface{}) (n int, err error) {
-	c.Set()
-	defer c.unset()
-
-	return fmt.Fprintln(Output, a...)
-}
-
-// PrintFunc returns a new function that prints the passed arguments as
-// colorized with color.Print().
-func (c *Color) PrintFunc() func(a ...interface{}) {
-	return func(a ...interface{}) { c.Print(a...) }
-}
-
-// PrintfFunc returns a new function that prints the passed arguments as
-// colorized with color.Printf().
-func (c *Color) PrintfFunc() func(format string, a ...interface{}) {
-	return func(format string, a ...interface{}) { c.Printf(format, a...) }
-}
-
-// PrintlnFunc returns a new function that prints the passed arguments as
-// colorized with color.Println().
-func (c *Color) PrintlnFunc() func(a ...interface{}) {
-	return func(a ...interface{}) { c.Println(a...) }
-}
-
-// SprintFunc returns a new function that returns colorized strings for the
-// given arguments with fmt.Sprint(). Useful to put into or mix into other
-// string. Windows users should use this in conjuction with color.Output, example:
-//
-//	put := New(FgYellow).SprintFunc()
-//	fmt.Fprintf(color.Output, "This is a %s", put("warning"))
-func (c *Color) SprintFunc() func(a ...interface{}) string {
-	return func(a ...interface{}) string {
-		return c.wrap(fmt.Sprint(a...))
-	}
-}
-
-// SprintfFunc returns a new function that returns colorized strings for the
-// given arguments with fmt.Sprintf(). Useful to put into or mix into other
-// string. Windows users should use this in conjuction with color.Output.
-func (c *Color) SprintfFunc() func(format string, a ...interface{}) string {
-	return func(format string, a ...interface{}) string {
-		return c.wrap(fmt.Sprintf(format, a...))
-	}
-}
-
-// SprintlnFunc returns a new function that returns colorized strings for the
-// given arguments with fmt.Sprintln(). Useful to put into or mix into other
-// string. Windows users should use this in conjuction with color.Output.
-func (c *Color) SprintlnFunc() func(a ...interface{}) string {
-	return func(a ...interface{}) string {
-		return c.wrap(fmt.Sprintln(a...))
-	}
-}
-
-// sequence returns a formated SGR sequence to be plugged into a "\x1b[...m"
-// an example output might be: "1;36" -> bold cyan
-func (c *Color) sequence() string {
-	format := make([]string, len(c.params))
-	for i, v := range c.params {
-		format[i] = strconv.Itoa(int(v))
-	}
-
-	return strings.Join(format, ";")
-}
-
-// wrap wraps the s string with the colors attributes. The string is ready to
-// be printed.
-func (c *Color) wrap(s string) string {
-	if c.isNoColorSet() {
-		return s
-	}
-
-	return c.format() + s + c.unformat()
-}
-
-func (c *Color) format() string {
-	return fmt.Sprintf("%s[%sm", escape, c.sequence())
-}
-
-func (c *Color) unformat() string {
-	return fmt.Sprintf("%s[%dm", escape, Reset)
-}
-
-// DisableColor disables the color output. Useful to not change any existing
-// code and still being able to output. Can be used for flags like
-// "--no-color". To enable back use EnableColor() method.
-func (c *Color) DisableColor() {
-	c.noColor = boolPtr(true)
-}
-
-// EnableColor enables the color output. Use it in conjuction with
-// DisableColor(). Otherwise this method has no side effects.
-func (c *Color) EnableColor() {
-	c.noColor = boolPtr(false)
-}
-
-func (c *Color) isNoColorSet() bool {
-	// check first if we have user setted action
-	if c.noColor != nil {
-		return *c.noColor
-	}
-
-	// if not return the global option, which is disabled by default
-	return NoColor
-}
-
-// Equals returns a boolean value indicating whether two colors are equal.
-func (c *Color) Equals(c2 *Color) bool {
-	if len(c.params) != len(c2.params) {
-		return false
-	}
-
-	for _, attr := range c.params {
-		if !c2.attrExists(attr) {
-			return false
-		}
-	}
-
-	return true
-}
-
-func (c *Color) attrExists(a Attribute) bool {
-	for _, attr := range c.params {
-		if attr == a {
-			return true
-		}
-	}
-
-	return false
-}
-
-func boolPtr(v bool) *bool {
-	return &v
-}
-
-// Black is an convenient helper function to print with black foreground. A
-// newline is appended to format by default.
-func Black(format string, a ...interface{}) { printColor(format, FgBlack, a...) }
-
-// Red is an convenient helper function to print with red foreground. A
-// newline is appended to format by default.
-func Red(format string, a ...interface{}) { printColor(format, FgRed, a...) }
-
-// Green is an convenient helper function to print with green foreground. A
-// newline is appended to format by default.
-func Green(format string, a ...interface{}) { printColor(format, FgGreen, a...) }
-
-// Yellow is an convenient helper function to print with yellow foreground.
-// A newline is appended to format by default.
-func Yellow(format string, a ...interface{}) { printColor(format, FgYellow, a...) }
-
-// Blue is an convenient helper function to print with blue foreground. A
-// newline is appended to format by default.
-func Blue(format string, a ...interface{}) { printColor(format, FgBlue, a...) }
-
-// Magenta is an convenient helper function to print with magenta foreground.
-// A newline is appended to format by default.
-func Magenta(format string, a ...interface{}) { printColor(format, FgMagenta, a...) }
-
-// Cyan is an convenient helper function to print with cyan foreground. A
-// newline is appended to format by default.
-func Cyan(format string, a ...interface{}) { printColor(format, FgCyan, a...) }
-
-// White is an convenient helper function to print with white foreground. A
-// newline is appended to format by default.
-func White(format string, a ...interface{}) { printColor(format, FgWhite, a...) }
-
-func printColor(format string, p Attribute, a ...interface{}) {
-	if !strings.HasSuffix(format, "\n") {
-		format += "\n"
-	}
-
-	c := &Color{params: []Attribute{p}}
-	c.Printf(format, a...)
-}
-
-// BlackString is an convenient helper function to return a string with black
-// foreground.
-func BlackString(format string, a ...interface{}) string {
-	return New(FgBlack).SprintfFunc()(format, a...)
-}
-
-// RedString is an convenient helper function to return a string with red
-// foreground.
-func RedString(format string, a ...interface{}) string {
-	return New(FgRed).SprintfFunc()(format, a...)
-}
-
-// GreenString is an convenient helper function to return a string with green
-// foreground.
-func GreenString(format string, a ...interface{}) string {
-	return New(FgGreen).SprintfFunc()(format, a...)
-}
-
-// YellowString is an convenient helper function to return a string with yellow
-// foreground.
-func YellowString(format string, a ...interface{}) string {
-	return New(FgYellow).SprintfFunc()(format, a...)
-}
-
-// BlueString is an convenient helper function to return a string with blue
-// foreground.
-func BlueString(format string, a ...interface{}) string {
-	return New(FgBlue).SprintfFunc()(format, a...)
-}
-
-// MagentaString is an convenient helper function to return a string with magenta
-// foreground.
-func MagentaString(format string, a ...interface{}) string {
-	return New(FgMagenta).SprintfFunc()(format, a...)
-}
-
-// CyanString is an convenient helper function to return a string with cyan
-// foreground.
-func CyanString(format string, a ...interface{}) string {
-	return New(FgCyan).SprintfFunc()(format, a...)
-}
-
-// WhiteString is an convenient helper function to return a string with white
-// foreground.
-func WhiteString(format string, a ...interface{}) string {
-	return New(FgWhite).SprintfFunc()(format, a...)
-}

Godeps/_workspace/src/github.com/fatih/color/doc.go

@@ -1,114 +0,0 @@
-/*
-Package color is an ANSI color package to output colorized or SGR defined
-output to the standard output. The API can be used in several way, pick one
-that suits you.
-
-Use simple and default helper functions with predefined foreground colors:
-
-    color.Cyan("Prints text in cyan.")
-
-    // a newline will be appended automatically
-    color.Blue("Prints %s in blue.", "text")
-
-    // More default foreground colors..
-    color.Red("We have red")
-    color.Yellow("Yellow color too!")
-    color.Magenta("And many others ..")
-
-However there are times where custom color mixes are required. Below are some
-examples to create custom color objects and use the print functions of each
-separate color object.
-
-    // Create a new color object
-    c := color.New(color.FgCyan).Add(color.Underline)
-    c.Println("Prints cyan text with an underline.")
-
-    // Or just add them to New()
-    d := color.New(color.FgCyan, color.Bold)
-    d.Printf("This prints bold cyan %s\n", "too!.")
-
-
-    // Mix up foreground and background colors, create new mixes!
-    red := color.New(color.FgRed)
-
-    boldRed := red.Add(color.Bold)
-    boldRed.Println("This will print text in bold red.")
-
-    whiteBackground := red.Add(color.BgWhite)
-    whiteBackground.Println("Red text with White background.")
-
-
-You can create PrintXxx functions to simplify even more:
-
-    // Create a custom print function for convenient
-    red := color.New(color.FgRed).PrintfFunc()
-    red("warning")
-    red("error: %s", err)
-
-    // Mix up multiple attributes
-    notice := color.New(color.Bold, color.FgGreen).PrintlnFunc()
-    notice("don't forget this...")
-
-
-Or create SprintXxx functions to mix strings with other non-colorized strings:
-
-    yellow := New(FgYellow).SprintFunc()
-    red := New(FgRed).SprintFunc()
-
-    fmt.Printf("this is a %s and this is %s.\n", yellow("warning"), red("error"))
-
-    info := New(FgWhite, BgGreen).SprintFunc()
-    fmt.Printf("this %s rocks!\n", info("package"))
-
-Windows support is enabled by default. All Print functions works as intended.
-However only for color.SprintXXX functions, user should use fmt.FprintXXX and
-set the output to color.Output:
-
-    fmt.Fprintf(color.Output, "Windows support: %s", color.GreenString("PASS"))
-
-    info := New(FgWhite, BgGreen).SprintFunc()
-    fmt.Fprintf(color.Output, "this %s rocks!\n", info("package"))
-
-Using with existing code is possible. Just use the Set() method to set the
-standard output to the given parameters. That way a rewrite of an existing
-code is not required.
-
-    // Use handy standard colors.
-    color.Set(color.FgYellow)
-
-    fmt.Println("Existing text will be now in Yellow")
-    fmt.Printf("This one %s\n", "too")
-
-    color.Unset() // don't forget to unset
-
-    // You can mix up parameters
-    color.Set(color.FgMagenta, color.Bold)
-    defer color.Unset() // use it in your function
-
-    fmt.Println("All text will be now bold magenta.")
-
-There might be a case where you want to disable color output (for example to
-pipe the standard output of your app to somewhere else). `Color` has support to
-disable colors both globally and for single color definition. For example
-suppose you have a CLI app and a `--no-color` bool flag. You can easily disable
-the color output with:
-
-    var flagNoColor = flag.Bool("no-color", false, "Disable color output")
-
-    if *flagNoColor {
-    	color.NoColor = true // disables colorized output
-    }
-
-It also has support for single color definitions (local). You can
-disable/enable color output on the fly:
-
-     c := color.New(color.FgCyan)
-     c.Println("Prints cyan text")
-
-     c.DisableColor()
-     c.Println("This is printed without any color")
-
-     c.EnableColor()
-     c.Println("This prints again cyan...")
-*/
-package color

Godeps/_workspace/src/github.com/gizak/termui/.gitignore

@@ -1,25 +0,0 @@
-# Compiled Object files, Static and Dynamic libs (Shared Objects)
-*.o
-*.a
-*.so
-
-# Folders
-_obj
-_test
-
-# Architecture specific extensions/prefixes
-*.[568vq]
-[568vq].out
-
-*.cgo1.go
-*.cgo2.c
-_cgo_defun.c
-_cgo_gotypes.go
-_cgo_export.*
-
-_testmain.go
-
-*.exe
-*.test
-*.prof
-.DS_Store

Godeps/_workspace/src/github.com/gizak/termui/.travis.yml

@@ -1,6 +0,0 @@
-language: go
-
-go:
-  - tip
-
-script: go test -v ./

Godeps/_workspace/src/github.com/gizak/termui/README.md

@@ -1,148 +0,0 @@
-# termui [![Build Status](https://travis-ci.org/gizak/termui.svg?branch=master)](https://travis-ci.org/gizak/termui) [![Doc Status](https://godoc.org/github.com/gizak/termui?status.png)](https://godoc.org/github.com/gizak/termui)
-
-<img src="./_example/dashboard.gif" alt="demo cast under osx 10.10; Terminal.app; Menlo Regular 12pt.)" width="80%">
-
-`termui` is a cross-platform, easy-to-compile, and fully-customizable terminal dashboard. It is inspired by [blessed-contrib](https://github.com/yaronn/blessed-contrib), but purely in Go.
-
-Now version v2 has arrived! It brings new event system, new theme system, new `Buffer` interface and specific colour text rendering. (some docs are missing, but it will be completed soon!)
-
-## Installation
-
-`master` mirrors v2 branch, to install:
-
-	go get -u github.com/gizak/termui
-
-For the compatible reason, you can choose to install the legacy version of `termui`:
-
-	go get gopkg.in/gizak/termui.v1
-
-## Usage
-
-### Layout
-
-To use `termui`, the very first thing you may want to know is how to manage layout. `termui` offers two ways of doing this, known as absolute layout and grid layout.
-
-__Absolute layout__
-
-Each widget has an underlying block structure which basically is a box model. It has border, label and padding properties. A border of a widget can be chosen to hide or display (with its border label), you can pick a different front/back colour for the border as well. To display such a widget at a specific location in terminal window, you need to assign `.X`, `.Y`, `.Height`, `.Width` values for each widget before send it to `.Render`. Let's demonstrate these by a code snippet:
-
-`````go
-	import ui "github.com/gizak/termui" // <- ui shortcut, optional
-
-	func main() {
-		err := ui.Init()
-		if err != nil {
-			panic(err)
-		}
-		defer ui.Close()
-
-		p := ui.NewPar(":PRESS q TO QUIT DEMO")
-		p.Height = 3
-		p.Width = 50
-		p.TextFgColor = ui.ColorWhite
-		p.BorderLabel = "Text Box"
-		p.BorderFg = ui.ColorCyan
-
-		g := ui.NewGauge()
-		g.Percent = 50
-		g.Width = 50
-		g.Height = 3
-		g.Y = 11
-		g.BorderLabel = "Gauge"
-		g.BarColor = ui.ColorRed
-		g.BorderFg = ui.ColorWhite
-		g.BorderLabelFg = ui.ColorCyan
-
-		ui.Render(p, g) // feel free to call Render, it's async and non-block
-
-		// event handler...
-	}
-`````
-
-Note that components can be overlapped (I'd rather call this a feature...), `Render(rs ...Renderer)` renders its args from left to right (i.e. each component's weight is arising from left to right).
-
-__Grid layout:__
-
-<img src="./_example/grid.gif" alt="grid" width="60%">
-
-Grid layout uses [12 columns grid system](http://www.w3schools.com/bootstrap/bootstrap_grid_system.asp) with expressive syntax. To use `Grid`, all we need to do is build a widget tree consisting of `Row`s and Cols (Actually a Col is also a `Row` but with a widget endpoint attached).
-
-```go
-	import ui "github.com/gizak/termui"
-	// init and create widgets...
-
-	// build
-	ui.Body.AddRows(
-		ui.NewRow(
-			ui.NewCol(6, 0, widget0),
-			ui.NewCol(6, 0, widget1)),
-		ui.NewRow(
-			ui.NewCol(3, 0, widget2),
-			ui.NewCol(3, 0, widget30, widget31, widget32),
-			ui.NewCol(6, 0, widget4)))
-
-	// calculate layout
-	ui.Body.Align()
-
-	ui.Render(ui.Body)
-```
-
-### Events
-
-`termui` ships with a http-like event mux handling system. All events are channeled up from different sources (typing, click, windows resize, custom event) and then encoded as universal `Event` object. `Event.Path` indicates the event type and `Event.Data` stores the event data struct. Add a handler to a certain event is easy as below:
-
-```go
-	// handle key q pressing
-	ui.Handle("/sys/kbd/q", func(ui.Event) {
-		// press q to quit
-		ui.StopLoop()
-	})
-
-	ui.Handle("/sys/kbd/C-x", func(ui.Event) {
-		// handle Ctrl + x combination
-	})
-
-	ui.Handle("/sys/kbd", func(ui.Event) {
-		// handle all other key pressing
-	})
-
-	// handle a 1s timer
-	ui.Handle("/timer/1s", func(e ui.Event) {
-		t := e.Data.(ui.EvtTimer)
-		// t is a EvtTimer
-		if t.Count%2 ==0 {
-			// do something
-		}
-	})
-
-	ui.Loop() // block until StopLoop is called
-```
-
-### Widgets
-
-Click image to see the corresponding demo codes.
-
-[<img src="./_example/par.png" alt="par" type="image/png" width="45%">](https://github.com/gizak/termui/blob/master/_example/par.go)
-[<img src="./_example/list.png" alt="list" type="image/png" width="45%">](https://github.com/gizak/termui/blob/master/_example/list.go)
-[<img src="./_example/gauge.png" alt="gauge" type="image/png" width="45%">](https://github.com/gizak/termui/blob/master/_example/gauge.go)
-[<img src="./_example/linechart.png" alt="linechart" type="image/png" width="45%">](https://github.com/gizak/termui/blob/master/_example/linechart.go)
-[<img src="./_example/barchart.png" alt="barchart" type="image/png" width="45%">](https://github.com/gizak/termui/blob/master/_example/barchart.go)
-[<img src="./_example/mbarchart.png" alt="barchart" type="image/png" width="45%">](https://github.com/gizak/termui/blob/master/_example/mbarchart.go)
-[<img src="./_example/sparklines.png" alt="sparklines" type="image/png" width="45%">](https://github.com/gizak/termui/blob/master/_example/sparklines.go)
-
-## GoDoc
-
-[godoc](https://godoc.org/github.com/gizak/termui)
-
-## TODO
-
-- [x] Grid layout
-- [x] Event system
-- [x] Canvas widget
-- [x] Refine APIs
-- [ ] Focusable widgets
-
-## Changelog
-
-## License
-This library is under the [MIT License](http://opensource.org/licenses/MIT)

Godeps/_workspace/src/github.com/gizak/termui/block.go

@@ -1,240 +0,0 @@
-// Copyright 2016 Zack Guo <gizak@icloud.com>. All rights reserved.
-// Use of this source code is governed by a MIT license that can
-// be found in the LICENSE file.
-
-package termui
-
-import "image"
-
-// Hline is a horizontal line.
-type Hline struct {
-	X   int
-	Y   int
-	Len int
-	Fg  Attribute
-	Bg  Attribute
-}
-
-// Vline is a vertical line.
-type Vline struct {
-	X   int
-	Y   int
-	Len int
-	Fg  Attribute
-	Bg  Attribute
-}
-
-// Buffer draws a horizontal line.
-func (l Hline) Buffer() Buffer {
-	if l.Len <= 0 {
-		return NewBuffer()
-	}
-	return NewFilledBuffer(l.X, l.Y, l.X+l.Len, l.Y+1, HORIZONTAL_LINE, l.Fg, l.Bg)
-}
-
-// Buffer draws a vertical line.
-func (l Vline) Buffer() Buffer {
-	if l.Len <= 0 {
-		return NewBuffer()
-	}
-	return NewFilledBuffer(l.X, l.Y, l.X+1, l.Y+l.Len, VERTICAL_LINE, l.Fg, l.Bg)
-}
-
-// Buffer draws a box border.
-func (b Block) drawBorder(buf Buffer) {
-	if !b.Border {
-		return
-	}
-
-	min := b.area.Min
-	max := b.area.Max
-
-	x0 := min.X
-	y0 := min.Y
-	x1 := max.X - 1
-	y1 := max.Y - 1
-
-	// draw lines
-	if b.BorderTop {
-		buf.Merge(Hline{x0, y0, x1 - x0, b.BorderFg, b.BorderBg}.Buffer())
-	}
-	if b.BorderBottom {
-		buf.Merge(Hline{x0, y1, x1 - x0, b.BorderFg, b.BorderBg}.Buffer())
-	}
-	if b.BorderLeft {
-		buf.Merge(Vline{x0, y0, y1 - y0, b.BorderFg, b.BorderBg}.Buffer())
-	}
-	if b.BorderRight {
-		buf.Merge(Vline{x1, y0, y1 - y0, b.BorderFg, b.BorderBg}.Buffer())
-	}
-
-	// draw corners
-	if b.BorderTop && b.BorderLeft && b.area.Dx() > 0 && b.area.Dy() > 0 {
-		buf.Set(x0, y0, Cell{TOP_LEFT, b.BorderFg, b.BorderBg})
-	}
-	if b.BorderTop && b.BorderRight && b.area.Dx() > 1 && b.area.Dy() > 0 {
-		buf.Set(x1, y0, Cell{TOP_RIGHT, b.BorderFg, b.BorderBg})
-	}
-	if b.BorderBottom && b.BorderLeft && b.area.Dx() > 0 && b.area.Dy() > 1 {
-		buf.Set(x0, y1, Cell{BOTTOM_LEFT, b.BorderFg, b.BorderBg})
-	}
-	if b.BorderBottom && b.BorderRight && b.area.Dx() > 1 && b.area.Dy() > 1 {
-		buf.Set(x1, y1, Cell{BOTTOM_RIGHT, b.BorderFg, b.BorderBg})
-	}
-}
-
-func (b Block) drawBorderLabel(buf Buffer) {
-	maxTxtW := b.area.Dx() - 2
-	tx := DTrimTxCls(DefaultTxBuilder.Build(b.BorderLabel, b.BorderLabelFg, b.BorderLabelBg), maxTxtW)
-
-	for i, w := 0, 0; i < len(tx); i++ {
-		buf.Set(b.area.Min.X+1+w, b.area.Min.Y, tx[i])
-		w += tx[i].Width()
-	}
-}
-
-// Block is a base struct for all other upper level widgets,
-// consider it as css: display:block.
-// Normally you do not need to create it manually.
-type Block struct {
-	area          image.Rectangle
-	innerArea     image.Rectangle
-	X             int
-	Y             int
-	Border        bool
-	BorderFg      Attribute
-	BorderBg      Attribute
-	BorderLeft    bool
-	BorderRight   bool
-	BorderTop     bool
-	BorderBottom  bool
-	BorderLabel   string
-	BorderLabelFg Attribute
-	BorderLabelBg Attribute
-	Display       bool
-	Bg            Attribute
-	Width         int
-	Height        int
-	PaddingTop    int
-	PaddingBottom int
-	PaddingLeft   int
-	PaddingRight  int
-	id            string
-	Float         Align
-}
-
-// NewBlock returns a *Block which inherits styles from current theme.
-func NewBlock() *Block {
-	b := Block{}
-	b.Display = true
-	b.Border = true
-	b.BorderLeft = true
-	b.BorderRight = true
-	b.BorderTop = true
-	b.BorderBottom = true
-	b.BorderBg = ThemeAttr("border.bg")
-	b.BorderFg = ThemeAttr("border.fg")
-	b.BorderLabelBg = ThemeAttr("label.bg")
-	b.BorderLabelFg = ThemeAttr("label.fg")
-	b.Bg = ThemeAttr("block.bg")
-	b.Width = 2
-	b.Height = 2
-	b.id = GenId()
-	b.Float = AlignNone
-	return &b
-}
-
-func (b Block) Id() string {
-	return b.id
-}
-
-// Align computes box model
-func (b *Block) Align() {
-	// outer
-	b.area.Min.X = 0
-	b.area.Min.Y = 0
-	b.area.Max.X = b.Width
-	b.area.Max.Y = b.Height
-
-	// float
-	b.area = AlignArea(TermRect(), b.area, b.Float)
-	b.area = MoveArea(b.area, b.X, b.Y)
-
-	// inner
-	b.innerArea.Min.X = b.area.Min.X + b.PaddingLeft
-	b.innerArea.Min.Y = b.area.Min.Y + b.PaddingTop
-	b.innerArea.Max.X = b.area.Max.X - b.PaddingRight
-	b.innerArea.Max.Y = b.area.Max.Y - b.PaddingBottom
-
-	if b.Border {
-		if b.BorderLeft {
-			b.innerArea.Min.X++
-		}
-		if b.BorderRight {
-			b.innerArea.Max.X--
-		}
-		if b.BorderTop {
-			b.innerArea.Min.Y++
-		}
-		if b.BorderBottom {
-			b.innerArea.Max.Y--
-		}
-	}
-}
-
-// InnerBounds returns the internal bounds of the block after aligning and
-// calculating the padding and border, if any.
-func (b *Block) InnerBounds() image.Rectangle {
-	b.Align()
-	return b.innerArea
-}
-
-// Buffer implements Bufferer interface.
-// Draw background and border (if any).
-func (b *Block) Buffer() Buffer {
-	b.Align()
-
-	buf := NewBuffer()
-	buf.SetArea(b.area)
-	buf.Fill(' ', ColorDefault, b.Bg)
-
-	b.drawBorder(buf)
-	b.drawBorderLabel(buf)
-
-	return buf
-}
-
-// GetHeight implements GridBufferer.
-// It returns current height of the block.
-func (b Block) GetHeight() int {
-	return b.Height
-}
-
-// SetX implements GridBufferer interface, which sets block's x position.
-func (b *Block) SetX(x int) {
-	b.X = x
-}
-
-// SetY implements GridBufferer interface, it sets y position for block.
-func (b *Block) SetY(y int) {
-	b.Y = y
-}
-
-// SetWidth implements GridBuffer interface, it sets block's width.
-func (b *Block) SetWidth(w int) {
-	b.Width = w
-}
-
-func (b Block) InnerWidth() int {
-	return b.innerArea.Dx()
-}
-
-func (b Block) InnerHeight() int {
-	return b.innerArea.Dy()
-}
-
-func (b Block) InnerX() int {
-	return b.innerArea.Min.X
-}
-
-func (b Block) InnerY() int { return b.innerArea.Min.Y }

Godeps/_workspace/src/github.com/gizak/termui/buffer.go

@@ -1,106 +0,0 @@
-// Copyright 2016 Zack Guo <gizak@icloud.com>. All rights reserved.
-// Use of this source code is governed by a MIT license that can
-// be found in the LICENSE file.
-
-package termui
-
-import "image"
-
-// Cell is a rune with assigned Fg and Bg
-type Cell struct {
-	Ch rune
-	Fg Attribute
-	Bg Attribute
-}
-
-// Buffer is a renderable rectangle cell data container.
-type Buffer struct {
-	Area    image.Rectangle // selected drawing area
-	CellMap map[image.Point]Cell
-}
-
-// At returns the cell at (x,y).
-func (b Buffer) At(x, y int) Cell {
-	return b.CellMap[image.Pt(x, y)]
-}
-
-// Set assigns a char to (x,y)
-func (b Buffer) Set(x, y int, c Cell) {
-	b.CellMap[image.Pt(x, y)] = c
-}
-
-// Bounds returns the domain for which At can return non-zero color.
-func (b Buffer) Bounds() image.Rectangle {
-	x0, y0, x1, y1 := 0, 0, 0, 0
-	for p := range b.CellMap {
-		if p.X > x1 {
-			x1 = p.X
-		}
-		if p.X < x0 {
-			x0 = p.X
-		}
-		if p.Y > y1 {
-			y1 = p.Y
-		}
-		if p.Y < y0 {
-			y0 = p.Y
-		}
-	}
-	return image.Rect(x0, y0, x1, y1)
-}
-
-// SetArea assigns a new rect area to Buffer b.
-func (b *Buffer) SetArea(r image.Rectangle) {
-	b.Area.Max = r.Max
-	b.Area.Min = r.Min
-}
-
-// Sync sets drawing area to the buffer's bound
-func (b Buffer) Sync() {
-	b.SetArea(b.Bounds())
-}
-
-// NewCell returns a new cell
-func NewCell(ch rune, fg, bg Attribute) Cell {
-	return Cell{ch, fg, bg}
-}
-
-// Merge merges bs Buffers onto b
-func (b *Buffer) Merge(bs ...Buffer) {
-	for _, buf := range bs {
-		for p, v := range buf.CellMap {
-			b.Set(p.X, p.Y, v)
-		}
-		b.SetArea(b.Area.Union(buf.Area))
-	}
-}
-
-// NewBuffer returns a new Buffer
-func NewBuffer() Buffer {
-	return Buffer{
-		CellMap: make(map[image.Point]Cell),
-		Area:    image.Rectangle{}}
-}
-
-// Fill fills the Buffer b with ch,fg and bg.
-func (b Buffer) Fill(ch rune, fg, bg Attribute) {
-	for x := b.Area.Min.X; x < b.Area.Max.X; x++ {
-		for y := b.Area.Min.Y; y < b.Area.Max.Y; y++ {
-			b.Set(x, y, Cell{ch, fg, bg})
-		}
-	}
-}
-
-// NewFilledBuffer returns a new Buffer filled with ch, fb and bg.
-func NewFilledBuffer(x0, y0, x1, y1 int, ch rune, fg, bg Attribute) Buffer {
-	buf := NewBuffer()
-	buf.Area.Min = image.Pt(x0, y0)
-	buf.Area.Max = image.Pt(x1, y1)
-
-	for x := buf.Area.Min.X; x < buf.Area.Max.X; x++ {
-		for y := buf.Area.Min.Y; y < buf.Area.Max.Y; y++ {
-			buf.Set(x, y, Cell{ch, fg, bg})
-		}
-	}
-	return buf
-}

Godeps/_workspace/src/github.com/gizak/termui/config

@@ -1,26 +0,0 @@
-#!/usr/bin/env perl6
-
-use v6;
-
-my $copyright = '// Copyright 2016 Zack Guo <gizak@icloud.com>. All rights reserved.
-// Use of this source code is governed by a MIT license that can
-// be found in the LICENSE file.
-
-';
-
-sub MAIN('update-docstr', Str $srcp) {
-    if $srcp.IO.f {
-        $_ = $srcp.IO.slurp;
-        if m/^ \/\/\s Copyright .+? \n\n/ {
-            unless ~$/ eq $copyright {
-                s/^ \/\/\s Copyright .+? \n\n /$copyright/;
-                spurt $srcp, $_;
-                say "[updated] doc string for:"~$srcp;
-            }
-        } else {
-            say "[added] doc string for "~$srcp~" (no match found)";
-            $_ = $copyright ~ $_;
-            spurt $srcp, $_;
-        }
-    }
-}

Godeps/_workspace/src/github.com/gizak/termui/debug/debuger.go

@@ -1,117 +0,0 @@
-// Copyright 2016 Zack Guo <gizak@icloud.com>. All rights reserved.
-// Use of this source code is governed by a MIT license that can
-// be found in the LICENSE file.
-
-package debug
-
-import (
-	"fmt"
-	"net/http"
-
-	"golang.org/x/net/websocket"
-)
-
-type Server struct {
-	Port string
-	Addr string
-	Path string
-	Msg  chan string
-	chs  []chan string
-}
-
-type Client struct {
-	Port string
-	Addr string
-	Path string
-	ws   *websocket.Conn
-}
-
-var defaultPort = ":8080"
-
-func NewServer() *Server {
-	return &Server{
-		Port: defaultPort,
-		Addr: "localhost",
-		Path: "/echo",
-		Msg:  make(chan string),
-		chs:  make([]chan string, 0),
-	}
-}
-
-func NewClient() Client {
-	return Client{
-		Port: defaultPort,
-		Addr: "localhost",
-		Path: "/echo",
-	}
-}
-
-func (c Client) ConnectAndListen() error {
-	ws, err := websocket.Dial("ws://"+c.Addr+c.Port+c.Path, "", "http://"+c.Addr)
-	if err != nil {
-		return err
-	}
-	defer ws.Close()
-
-	var m string
-	for {
-		err := websocket.Message.Receive(ws, &m)
-		if err != nil {
-			fmt.Print(err)
-			return err
-		}
-		fmt.Print(m)
-	}
-}
-
-func (s *Server) ListenAndServe() error {
-	http.Handle(s.Path, websocket.Handler(func(ws *websocket.Conn) {
-		defer ws.Close()
-
-		mc := make(chan string)
-		s.chs = append(s.chs, mc)
-
-		for m := range mc {
-			websocket.Message.Send(ws, m)
-		}
-	}))
-
-	go func() {
-		for msg := range s.Msg {
-			for _, c := range s.chs {
-				go func(a chan string) {
-					a <- msg
-				}(c)
-			}
-		}
-	}()
-
-	return http.ListenAndServe(s.Port, nil)
-}
-
-func (s *Server) Log(msg string) {
-	go func() { s.Msg <- msg }()
-}
-
-func (s *Server) Logf(format string, a ...interface{}) {
-	s.Log(fmt.Sprintf(format, a...))
-}
-
-var DefaultServer = NewServer()
-var DefaultClient = NewClient()
-
-func ListenAndServe() error {
-	return DefaultServer.ListenAndServe()
-}
-
-func ConnectAndListen() error {
-	return DefaultClient.ConnectAndListen()
-}
-
-func Log(msg string) {
-	DefaultServer.Log(msg)
-}
-
-func Logf(format string, a ...interface{}) {
-	DefaultServer.Logf(format, a...)
-}

Godeps/_workspace/src/github.com/gizak/termui/doc.go

@@ -1,27 +0,0 @@
-// Copyright 2016 Zack Guo <gizak@icloud.com>. All rights reserved.
-// Use of this source code is governed by a MIT license that can
-// be found in the LICENSE file.
-
-/*
-Package termui is a library designed for creating command line UI. For more info, goto http://github.com/gizak/termui
-
-A simplest example:
-    package main
-
-    import ui "github.com/gizak/termui"
-
-    func main() {
-        if err:=ui.Init(); err != nil {
-            panic(err)
-        }
-        defer ui.Close()
-
-        g := ui.NewGauge()
-        g.Percent = 50
-        g.Width = 50
-        g.Border.Label = "Gauge"
-
-        ui.Render(g)
-    }
-*/
-package termui

Godeps/_workspace/src/github.com/gizak/termui/events.go

@@ -1,316 +0,0 @@
-// Copyright 2016 Zack Guo <gizak@icloud.com>. All rights reserved.
-// Use of this source code is governed by a MIT license that can
-// be found in the LICENSE file.
-
-package termui
-
-import (
-	"path"
-	"strconv"
-	"sync"
-	"time"
-
-	"github.com/nsf/termbox-go"
-)
-
-type Event struct {
-	Type string
-	Path string
-	From string
-	To   string
-	Data interface{}
-	Time int64
-}
-
-var sysEvtChs []chan Event
-
-type EvtKbd struct {
-	KeyStr string
-}
-
-func evtKbd(e termbox.Event) EvtKbd {
-	ek := EvtKbd{}
-
-	k := string(e.Ch)
-	pre := ""
-	mod := ""
-
-	if e.Mod == termbox.ModAlt {
-		mod = "M-"
-	}
-	if e.Ch == 0 {
-		if e.Key > 0xFFFF-12 {
-			k = "<f" + strconv.Itoa(0xFFFF-int(e.Key)+1) + ">"
-		} else if e.Key > 0xFFFF-25 {
-			ks := []string{"<insert>", "<delete>", "<home>", "<end>", "<previous>", "<next>", "<up>", "<down>", "<left>", "<right>"}
-			k = ks[0xFFFF-int(e.Key)-12]
-		}
-
-		if e.Key <= 0x7F {
-			pre = "C-"
-			k = string('a' - 1 + int(e.Key))
-			kmap := map[termbox.Key][2]string{
-				termbox.KeyCtrlSpace:     {"C-", "<space>"},
-				termbox.KeyBackspace:     {"", "<backspace>"},
-				termbox.KeyTab:           {"", "<tab>"},
-				termbox.KeyEnter:         {"", "<enter>"},
-				termbox.KeyEsc:           {"", "<escape>"},
-				termbox.KeyCtrlBackslash: {"C-", "\\"},
-				termbox.KeyCtrlSlash:     {"C-", "/"},
-				termbox.KeySpace:         {"", "<space>"},
-				termbox.KeyCtrl8:         {"C-", "8"},
-			}
-			if sk, ok := kmap[e.Key]; ok {
-				pre = sk[0]
-				k = sk[1]
-			}
-		}
-	}
-
-	ek.KeyStr = pre + mod + k
-	return ek
-}
-
-func crtTermboxEvt(e termbox.Event) Event {
-	systypemap := map[termbox.EventType]string{
-		termbox.EventKey:       "keyboard",
-		termbox.EventResize:    "window",
-		termbox.EventMouse:     "mouse",
-		termbox.EventError:     "error",
-		termbox.EventInterrupt: "interrupt",
-	}
-	ne := Event{From: "/sys", Time: time.Now().Unix()}
-	typ := e.Type
-	ne.Type = systypemap[typ]
-
-	switch typ {
-	case termbox.EventKey:
-		kbd := evtKbd(e)
-		ne.Path = "/sys/kbd/" + kbd.KeyStr
-		ne.Data = kbd
-	case termbox.EventResize:
-		wnd := EvtWnd{}
-		wnd.Width = e.Width
-		wnd.Height = e.Height
-		ne.Path = "/sys/wnd/resize"
-		ne.Data = wnd
-	case termbox.EventError:
-		err := EvtErr(e.Err)
-		ne.Path = "/sys/err"
-		ne.Data = err
-	case termbox.EventMouse:
-		m := EvtMouse{}
-		m.X = e.MouseX
-		m.Y = e.MouseY
-		ne.Path = "/sys/mouse"
-		ne.Data = m
-	}
-	return ne
-}
-
-type EvtWnd struct {
-	Width  int
-	Height int
-}
-
-type EvtMouse struct {
-	X     int
-	Y     int
-	Press string
-}
-
-type EvtErr error
-
-func hookTermboxEvt() {
-	for {
-		e := termbox.PollEvent()
-
-		for _, c := range sysEvtChs {
-			go func(ch chan Event) {
-				ch <- crtTermboxEvt(e)
-			}(c)
-		}
-	}
-}
-
-func NewSysEvtCh() chan Event {
-	ec := make(chan Event)
-	sysEvtChs = append(sysEvtChs, ec)
-	return ec
-}
-
-var DefaultEvtStream = NewEvtStream()
-
-type EvtStream struct {
-	sync.RWMutex
-	srcMap      map[string]chan Event
-	stream      chan Event
-	wg          sync.WaitGroup
-	sigStopLoop chan Event
-	Handlers    map[string]func(Event)
-	hook        func(Event)
-}
-
-func NewEvtStream() *EvtStream {
-	return &EvtStream{
-		srcMap:      make(map[string]chan Event),
-		stream:      make(chan Event),
-		Handlers:    make(map[string]func(Event)),
-		sigStopLoop: make(chan Event),
-	}
-}
-
-func (es *EvtStream) Init() {
-	es.Merge("internal", es.sigStopLoop)
-	go func() {
-		es.wg.Wait()
-		close(es.stream)
-	}()
-}
-
-func cleanPath(p string) string {
-	if p == "" {
-		return "/"
-	}
-	if p[0] != '/' {
-		p = "/" + p
-	}
-	return path.Clean(p)
-}
-
-func isPathMatch(pattern, path string) bool {
-	if len(pattern) == 0 {
-		return false
-	}
-	n := len(pattern)
-	return len(path) >= n && path[0:n] == pattern
-}
-
-func (es *EvtStream) Merge(name string, ec chan Event) {
-	es.Lock()
-	defer es.Unlock()
-
-	es.wg.Add(1)
-	es.srcMap[name] = ec
-
-	go func(a chan Event) {
-		for n := range a {
-			n.From = name
-			es.stream <- n
-		}
-		es.wg.Done()
-	}(ec)
-}
-
-func (es *EvtStream) Handle(path string, handler func(Event)) {
-	es.Handlers[cleanPath(path)] = handler
-}
-
-func findMatch(mux map[string]func(Event), path string) string {
-	n := -1
-	pattern := ""
-	for m := range mux {
-		if !isPathMatch(m, path) {
-			continue
-		}
-		if len(m) > n {
-			pattern = m
-			n = len(m)
-		}
-	}
-	return pattern
-
-}
-
-func (es *EvtStream) match(path string) string {
-	return findMatch(es.Handlers, path)
-}
-
-func (es *EvtStream) Hook(f func(Event)) {
-	es.hook = f
-}
-
-func (es *EvtStream) Loop() {
-	for e := range es.stream {
-		switch e.Path {
-		case "/sig/stoploop":
-			return
-		}
-		go func(a Event) {
-			es.RLock()
-			defer es.RUnlock()
-			if pattern := es.match(a.Path); pattern != "" {
-				es.Handlers[pattern](a)
-			}
-		}(e)
-		if es.hook != nil {
-			es.hook(e)
-		}
-	}
-}
-
-func (es *EvtStream) StopLoop() {
-	go func() {
-		e := Event{
-			Path: "/sig/stoploop",
-		}
-		es.sigStopLoop <- e
-	}()
-}
-
-func Merge(name string, ec chan Event) {
-	DefaultEvtStream.Merge(name, ec)
-}
-
-func Handle(path string, handler func(Event)) {
-	DefaultEvtStream.Handle(path, handler)
-}
-
-func Loop() {
-	DefaultEvtStream.Loop()
-}
-
-func StopLoop() {
-	DefaultEvtStream.StopLoop()
-}
-
-type EvtTimer struct {
-	Duration time.Duration
-	Count    uint64
-}
-
-func NewTimerCh(du time.Duration) chan Event {
-	t := make(chan Event)
-
-	go func(a chan Event) {
-		n := uint64(0)
-		for {
-			n++
-			time.Sleep(du)
-			e := Event{}
-			e.Type = "timer"
-			e.Path = "/timer/" + du.String()
-			e.Time = time.Now().Unix()
-			e.Data = EvtTimer{
-				Duration: du,
-				Count:    n,
-			}
-			t <- e
-
-		}
-	}(t)
-	return t
-}
-
-var DefualtHandler = func(e Event) {
-}
-
-var usrEvtCh = make(chan Event)
-
-func SendCustomEvt(path string, data interface{}) {
-	e := Event{}
-	e.Path = path
-	e.Data = data
-	e.Time = time.Now().Unix()
-	usrEvtCh <- e
-}

Godeps/_workspace/src/github.com/gizak/termui/gauge.go

@@ -1,109 +0,0 @@
-// Copyright 2016 Zack Guo <gizak@icloud.com>. All rights reserved.
-// Use of this source code is governed by a MIT license that can
-// be found in the LICENSE file.
-
-package termui
-
-import (
-	"strconv"
-	"strings"
-)
-
-// Gauge is a progress bar like widget.
-// A simple example:
-/*
-  g := termui.NewGauge()
-  g.Percent = 40
-  g.Width = 50
-  g.Height = 3
-  g.Border.Label = "Slim Gauge"
-  g.BarColor = termui.ColorRed
-  g.PercentColor = termui.ColorBlue
-*/
-
-const ColorUndef Attribute = Attribute(^uint16(0))
-
-type Gauge struct {
-	Block
-	Percent                 int
-	BarColor                Attribute
-	PercentColor            Attribute
-	PercentColorHighlighted Attribute
-	Label                   string
-	LabelAlign              Align
-}
-
-// NewGauge return a new gauge with current theme.
-func NewGauge() *Gauge {
-	g := &Gauge{
-		Block:                   *NewBlock(),
-		PercentColor:            ThemeAttr("gauge.percent.fg"),
-		BarColor:                ThemeAttr("gauge.bar.bg"),
-		Label:                   "{{percent}}%",
-		LabelAlign:              AlignCenter,
-		PercentColorHighlighted: ColorUndef,
-	}
-
-	g.Width = 12
-	g.Height = 5
-	return g
-}
-
-// Buffer implements Bufferer interface.
-func (g *Gauge) Buffer() Buffer {
-	buf := g.Block.Buffer()
-
-	// plot bar
-	w := g.Percent * g.innerArea.Dx() / 100
-	for i := 0; i < g.innerArea.Dy(); i++ {
-		for j := 0; j < w; j++ {
-			c := Cell{}
-			c.Ch = ' '
-			c.Bg = g.BarColor
-			if c.Bg == ColorDefault {
-				c.Bg |= AttrReverse
-			}
-			buf.Set(g.innerArea.Min.X+j, g.innerArea.Min.Y+i, c)
-		}
-	}
-
-	// plot percentage
-	s := strings.Replace(g.Label, "{{percent}}", strconv.Itoa(g.Percent), -1)
-	pry := g.innerArea.Min.Y + g.innerArea.Dy()/2
-	rs := str2runes(s)
-	var pos int
-	switch g.LabelAlign {
-	case AlignLeft:
-		pos = 0
-
-	case AlignCenter:
-		pos = (g.innerArea.Dx() - strWidth(s)) / 2
-
-	case AlignRight:
-		pos = g.innerArea.Dx() - strWidth(s) - 1
-	}
-	pos += g.innerArea.Min.X
-
-	for i, v := range rs {
-		c := Cell{
-			Ch: v,
-			Fg: g.PercentColor,
-		}
-
-		if w+g.innerArea.Min.X > pos+i {
-			c.Bg = g.BarColor
-			if c.Bg == ColorDefault {
-				c.Bg |= AttrReverse
-			}
-
-			if g.PercentColorHighlighted != ColorUndef {
-				c.Fg = g.PercentColorHighlighted
-			}
-		} else {
-			c.Bg = g.Block.Bg
-		}
-
-		buf.Set(1+pos+i, pry, c)
-	}
-	return buf
-}

Godeps/_workspace/src/github.com/gizak/termui/linechart_others.go

@@ -1,11 +0,0 @@
-// Copyright 2016 Zack Guo <gizak@icloud.com>. All rights reserved.
-// Use of this source code is governed by a MIT license that can
-// be found in the LICENSE file.
-
-// +build !windows
-
-package termui
-
-const VDASH = '┊'
-const HDASH = '┈'
-const ORIGIN = '└'

Godeps/_workspace/src/github.com/gizak/termui/linechart_windows.go

@@ -1,11 +0,0 @@
-// Copyright 2016 Zack Guo <gizak@icloud.com>. All rights reserved.
-// Use of this source code is governed by a MIT license that can
-// be found in the LICENSE file.
-
-// +build windows
-
-package termui
-
-const VDASH = '|'
-const HDASH = '-'
-const ORIGIN = '+'

Godeps/_workspace/src/github.com/gizak/termui/list.go

@@ -1,89 +0,0 @@
-// Copyright 2016 Zack Guo <gizak@icloud.com>. All rights reserved.
-// Use of this source code is governed by a MIT license that can
-// be found in the LICENSE file.
-
-package termui
-
-import "strings"
-
-// List displays []string as its items,
-// it has a Overflow option (default is "hidden"), when set to "hidden",
-// the item exceeding List's width is truncated, but when set to "wrap",
-// the overflowed text breaks into next line.
-/*
-  strs := []string{
-		"[0] github.com/gizak/termui",
-		"[1] editbox.go",
-		"[2] iterrupt.go",
-		"[3] keyboard.go",
-		"[4] output.go",
-		"[5] random_out.go",
-		"[6] dashboard.go",
-		"[7] nsf/termbox-go"}
-
-  ls := termui.NewList()
-  ls.Items = strs
-  ls.ItemFgColor = termui.ColorYellow
-  ls.Border.Label = "List"
-  ls.Height = 7
-  ls.Width = 25
-  ls.Y = 0
-*/
-type List struct {
-	Block
-	Items       []string
-	Overflow    string
-	ItemFgColor Attribute
-	ItemBgColor Attribute
-}
-
-// NewList returns a new *List with current theme.
-func NewList() *List {
-	l := &List{Block: *NewBlock()}
-	l.Overflow = "hidden"
-	l.ItemFgColor = ThemeAttr("list.item.fg")
-	l.ItemBgColor = ThemeAttr("list.item.bg")
-	return l
-}
-
-// Buffer implements Bufferer interface.
-func (l *List) Buffer() Buffer {
-	buf := l.Block.Buffer()
-
-	switch l.Overflow {
-	case "wrap":
-		cs := DefaultTxBuilder.Build(strings.Join(l.Items, "\n"), l.ItemFgColor, l.ItemBgColor)
-		i, j, k := 0, 0, 0
-		for i < l.innerArea.Dy() && k < len(cs) {
-			w := cs[k].Width()
-			if cs[k].Ch == '\n' || j+w > l.innerArea.Dx() {
-				i++
-				j = 0
-				if cs[k].Ch == '\n' {
-					k++
-				}
-				continue
-			}
-			buf.Set(l.innerArea.Min.X+j, l.innerArea.Min.Y+i, cs[k])
-
-			k++
-			j++
-		}
-
-	case "hidden":
-		trimItems := l.Items
-		if len(trimItems) > l.innerArea.Dy() {
-			trimItems = trimItems[:l.innerArea.Dy()]
-		}
-		for i, v := range trimItems {
-			cs := DTrimTxCls(DefaultTxBuilder.Build(v, l.ItemFgColor, l.ItemBgColor), l.innerArea.Dx())
-			j := 0
-			for _, vv := range cs {
-				w := vv.Width()
-				buf.Set(l.innerArea.Min.X+j, l.innerArea.Min.Y+i, vv)
-				j += w
-			}
-		}
-	}
-	return buf
-}

Godeps/_workspace/src/github.com/gizak/termui/render.go

@@ -1,135 +0,0 @@
-// Copyright 2016 Zack Guo <gizak@icloud.com>. All rights reserved.
-// Use of this source code is governed by a MIT license that can
-// be found in the LICENSE file.
-
-package termui
-
-import (
-	"image"
-	"sync"
-	"time"
-
-	tm "github.com/nsf/termbox-go"
-)
-
-// Bufferer should be implemented by all renderable components.
-type Bufferer interface {
-	Buffer() Buffer
-}
-
-// Init initializes termui library. This function should be called before any others.
-// After initialization, the library must be finalized by 'Close' function.
-func Init() error {
-	if err := tm.Init(); err != nil {
-		return err
-	}
-
-	sysEvtChs = make([]chan Event, 0)
-	go hookTermboxEvt()
-
-	renderJobs = make(chan []Bufferer)
-	//renderLock = new(sync.RWMutex)
-
-	Body = NewGrid()
-	Body.X = 0
-	Body.Y = 0
-	Body.BgColor = ThemeAttr("bg")
-	Body.Width = TermWidth()
-
-	DefaultEvtStream.Init()
-	DefaultEvtStream.Merge("termbox", NewSysEvtCh())
-	DefaultEvtStream.Merge("timer", NewTimerCh(time.Second))
-	DefaultEvtStream.Merge("custom", usrEvtCh)
-
-	DefaultEvtStream.Handle("/", DefualtHandler)
-	DefaultEvtStream.Handle("/sys/wnd/resize", func(e Event) {
-		w := e.Data.(EvtWnd)
-		Body.Width = w.Width
-	})
-
-	DefaultWgtMgr = NewWgtMgr()
-	DefaultEvtStream.Hook(DefaultWgtMgr.WgtHandlersHook())
-
-	go func() {
-		for bs := range renderJobs {
-			render(bs...)
-		}
-	}()
-
-	return nil
-}
-
-// Close finalizes termui library,
-// should be called after successful initialization when termui's functionality isn't required anymore.
-func Close() {
-	tm.Close()
-}
-
-var renderLock sync.Mutex
-
-func termSync() {
-	renderLock.Lock()
-	tm.Sync()
-	termWidth, termHeight = tm.Size()
-	renderLock.Unlock()
-}
-
-// TermWidth returns the current terminal's width.
-func TermWidth() int {
-	termSync()
-	return termWidth
-}
-
-// TermHeight returns the current terminal's height.
-func TermHeight() int {
-	termSync()
-	return termHeight
-}
-
-// Render renders all Bufferer in the given order from left to right,
-// right could overlap on left ones.
-func render(bs ...Bufferer) {
-
-	for _, b := range bs {
-
-		buf := b.Buffer()
-		// set cels in buf
-		for p, c := range buf.CellMap {
-			if p.In(buf.Area) {
-
-				tm.SetCell(p.X, p.Y, c.Ch, toTmAttr(c.Fg), toTmAttr(c.Bg))
-
-			}
-		}
-
-	}
-
-	renderLock.Lock()
-	// render
-	tm.Flush()
-	renderLock.Unlock()
-}
-
-func Clear() {
-	tm.Clear(tm.ColorDefault, toTmAttr(ThemeAttr("bg")))
-}
-
-func clearArea(r image.Rectangle, bg Attribute) {
-	for i := r.Min.X; i < r.Max.X; i++ {
-		for j := r.Min.Y; j < r.Max.Y; j++ {
-			tm.SetCell(i, j, ' ', tm.ColorDefault, toTmAttr(bg))
-		}
-	}
-}
-
-func ClearArea(r image.Rectangle, bg Attribute) {
-	clearArea(r, bg)
-	tm.Flush()
-}
-
-var renderJobs chan []Bufferer
-
-func Render(bs ...Bufferer) {
-	//go func() { renderJobs <- bs }()
-	renderJobs <- bs
-}

Godeps/_workspace/src/github.com/gizak/termui/test/runtest.go

@@ -1,66 +0,0 @@
-// Copyright 2016 Zack Guo <gizak@icloud.com>. All rights reserved.
-// Use of this source code is governed by a MIT license that can
-// be found in the LICENSE file.
-
-package main
-
-import (
-	"fmt"
-	"os"
-
-	"github.com/gizak/termui"
-	"github.com/gizak/termui/debug"
-)
-
-func main() {
-	// run as client
-	if len(os.Args) > 1 {
-		fmt.Print(debug.ConnectAndListen())
-		return
-	}
-
-	// run as server
-	go func() { panic(debug.ListenAndServe()) }()
-
-	if err := termui.Init(); err != nil {
-		panic(err)
-	}
-	defer termui.Close()
-
-	//termui.UseTheme("helloworld")
-	b := termui.NewBlock()
-	b.Width = 20
-	b.Height = 20
-	b.Float = termui.AlignCenter
-	b.BorderLabel = "[HELLO](fg-red,bg-white) [WORLD](fg-blue,bg-green)"
-
-	termui.Render(b)
-
-	termui.Handle("/sys", func(e termui.Event) {
-		k, ok := e.Data.(termui.EvtKbd)
-		debug.Logf("->%v\n", e)
-		if ok && k.KeyStr == "q" {
-			termui.StopLoop()
-		}
-	})
-
-	termui.Handle(("/usr"), func(e termui.Event) {
-		debug.Logf("->%v\n", e)
-	})
-
-	termui.Handle("/timer/1s", func(e termui.Event) {
-		t := e.Data.(termui.EvtTimer)
-		termui.SendCustomEvt("/usr/t", t.Count)
-
-		if t.Count%2 == 0 {
-			b.BorderLabel = "[HELLO](fg-red,bg-green) [WORLD](fg-blue,bg-white)"
-		} else {
-			b.BorderLabel = "[HELLO](fg-blue,bg-white) [WORLD](fg-red,bg-green)"
-		}
-
-		termui.Render(b)
-
-	})
-
-	termui.Loop()
-}

Godeps/_workspace/src/github.com/gizak/termui/textbuilder.go

@@ -1,215 +0,0 @@
-// Copyright 2016 Zack Guo <gizak@icloud.com>. All rights reserved.
-// Use of this source code is governed by a MIT license that can
-// be found in the LICENSE file.
-
-package termui
-
-import (
-	"regexp"
-	"strings"
-)
-
-// TextBuilder is a minial interface to produce text []Cell using sepcific syntax (markdown).
-type TextBuilder interface {
-	Build(s string, fg, bg Attribute) []Cell
-}
-
-// DefaultTxBuilder is set to be MarkdownTxBuilder.
-var DefaultTxBuilder = NewMarkdownTxBuilder()
-
-// MarkdownTxBuilder implements TextBuilder interface, using markdown syntax.
-type MarkdownTxBuilder struct {
-	baseFg  Attribute
-	baseBg  Attribute
-	plainTx []rune
-	markers []marker
-}
-
-type marker struct {
-	st int
-	ed int
-	fg Attribute
-	bg Attribute
-}
-
-var colorMap = map[string]Attribute{
-	"red":     ColorRed,
-	"blue":    ColorBlue,
-	"black":   ColorBlack,
-	"cyan":    ColorCyan,
-	"yellow":  ColorYellow,
-	"white":   ColorWhite,
-	"default": ColorDefault,
-	"green":   ColorGreen,
-	"magenta": ColorMagenta,
-}
-
-var attrMap = map[string]Attribute{
-	"bold":      AttrBold,
-	"underline": AttrUnderline,
-	"reverse":   AttrReverse,
-}
-
-func rmSpc(s string) string {
-	reg := regexp.MustCompile(`\s+`)
-	return reg.ReplaceAllString(s, "")
-}
-
-// readAttr translates strings like `fg-red,fg-bold,bg-white` to fg and bg Attribute
-func (mtb MarkdownTxBuilder) readAttr(s string) (Attribute, Attribute) {
-	fg := mtb.baseFg
-	bg := mtb.baseBg
-
-	updateAttr := func(a Attribute, attrs []string) Attribute {
-		for _, s := range attrs {
-			// replace the color
-			if c, ok := colorMap[s]; ok {
-				a &= 0xFF00 // erase clr 0 ~ 8 bits
-				a |= c      // set clr
-			}
-			// add attrs
-			if c, ok := attrMap[s]; ok {
-				a |= c
-			}
-		}
-		return a
-	}
-
-	ss := strings.Split(s, ",")
-	fgs := []string{}
-	bgs := []string{}
-	for _, v := range ss {
-		subs := strings.Split(v, "-")
-		if len(subs) > 1 {
-			if subs[0] == "fg" {
-				fgs = append(fgs, subs[1])
-			}
-			if subs[0] == "bg" {
-				bgs = append(bgs, subs[1])
-			}
-		}
-	}
-
-	fg = updateAttr(fg, fgs)
-	bg = updateAttr(bg, bgs)
-	return fg, bg
-}
-
-func (mtb *MarkdownTxBuilder) reset() {
-	mtb.plainTx = []rune{}
-	mtb.markers = []marker{}
-}
-
-// parse streams and parses text into normalized text and render sequence.
-func (mtb *MarkdownTxBuilder) parse(str string) {
-	rs := str2runes(str)
-	normTx := []rune{}
-	square := []rune{}
-	brackt := []rune{}
-	accSquare := false
-	accBrackt := false
-	cntSquare := 0
-
-	reset := func() {
-		square = []rune{}
-		brackt = []rune{}
-		accSquare = false
-		accBrackt = false
-		cntSquare = 0
-	}
-	// pipe stacks into normTx and clear
-	rollback := func() {
-		normTx = append(normTx, square...)
-		normTx = append(normTx, brackt...)
-		reset()
-	}
-	// chop first and last
-	chop := func(s []rune) []rune {
-		return s[1 : len(s)-1]
-	}
-
-	for i, r := range rs {
-		switch {
-		// stacking brackt
-		case accBrackt:
-			brackt = append(brackt, r)
-			if ')' == r {
-				fg, bg := mtb.readAttr(string(chop(brackt)))
-				st := len(normTx)
-				ed := len(normTx) + len(square) - 2
-				mtb.markers = append(mtb.markers, marker{st, ed, fg, bg})
-				normTx = append(normTx, chop(square)...)
-				reset()
-			} else if i+1 == len(rs) {
-				rollback()
-			}
-		// stacking square
-		case accSquare:
-			switch {
-			// squares closed and followed by a '('
-			case cntSquare == 0 && '(' == r:
-				accBrackt = true
-				brackt = append(brackt, '(')
-			// squares closed but not followed by a '('
-			case cntSquare == 0:
-				rollback()
-				if '[' == r {
-					accSquare = true
-					cntSquare = 1
-					brackt = append(brackt, '[')
-				} else {
-					normTx = append(normTx, r)
-				}
-			// hit the end
-			case i+1 == len(rs):
-				square = append(square, r)
-				rollback()
-			case '[' == r:
-				cntSquare++
-				square = append(square, '[')
-			case ']' == r:
-				cntSquare--
-				square = append(square, ']')
-			// normal char
-			default:
-				square = append(square, r)
-			}
-		// stacking normTx
-		default:
-			if '[' == r {
-				accSquare = true
-				cntSquare = 1
-				square = append(square, '[')
-			} else {
-				normTx = append(normTx, r)
-			}
-		}
-	}
-
-	mtb.plainTx = normTx
-}
-
-// Build implements TextBuilder interface.
-func (mtb MarkdownTxBuilder) Build(s string, fg, bg Attribute) []Cell {
-	mtb.baseFg = fg
-	mtb.baseBg = bg
-	mtb.reset()
-	mtb.parse(s)
-	cs := make([]Cell, len(mtb.plainTx))
-	for i := range cs {
-		cs[i] = Cell{Ch: mtb.plainTx[i], Fg: fg, Bg: bg}
-	}
-	for _, mrk := range mtb.markers {
-		for i := mrk.st; i < mrk.ed; i++ {
-			cs[i].Fg = mrk.fg
-			cs[i].Bg = mrk.bg
-		}
-	}
-
-	return cs
-}
-
-// NewMarkdownTxBuilder returns a TextBuilder employing markdown syntax.
-func NewMarkdownTxBuilder() TextBuilder {
-	return MarkdownTxBuilder{}
-}

Godeps/_workspace/src/github.com/golang/snappy/README

@@ -1,7 +0,0 @@
-The Snappy compression format in the Go programming language.
-
-To download and install from source:
-$ go get github.com/golang/snappy
-
-Unless otherwise noted, the Snappy-Go source files are distributed
-under the BSD-style license found in the LICENSE file.

Godeps/_workspace/src/github.com/golang/snappy/decode.go

@@ -1,294 +0,0 @@
-// Copyright 2011 The Snappy-Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package snappy
-
-import (
-	"encoding/binary"
-	"errors"
-	"io"
-)
-
-var (
-	// ErrCorrupt reports that the input is invalid.
-	ErrCorrupt = errors.New("snappy: corrupt input")
-	// ErrTooLarge reports that the uncompressed length is too large.
-	ErrTooLarge = errors.New("snappy: decoded block is too large")
-	// ErrUnsupported reports that the input isn't supported.
-	ErrUnsupported = errors.New("snappy: unsupported input")
-)
-
-// DecodedLen returns the length of the decoded block.
-func DecodedLen(src []byte) (int, error) {
-	v, _, err := decodedLen(src)
-	return v, err
-}
-
-// decodedLen returns the length of the decoded block and the number of bytes
-// that the length header occupied.
-func decodedLen(src []byte) (blockLen, headerLen int, err error) {
-	v, n := binary.Uvarint(src)
-	if n <= 0 || v > 0xffffffff {
-		return 0, 0, ErrCorrupt
-	}
-
-	const wordSize = 32 << (^uint(0) >> 32 & 1)
-	if wordSize == 32 && v > 0x7fffffff {
-		return 0, 0, ErrTooLarge
-	}
-	return int(v), n, nil
-}
-
-// Decode returns the decoded form of src. The returned slice may be a sub-
-// slice of dst if dst was large enough to hold the entire decoded block.
-// Otherwise, a newly allocated slice will be returned.
-// It is valid to pass a nil dst.
-func Decode(dst, src []byte) ([]byte, error) {
-	dLen, s, err := decodedLen(src)
-	if err != nil {
-		return nil, err
-	}
-	if len(dst) < dLen {
-		dst = make([]byte, dLen)
-	}
-
-	var d, offset, length int
-	for s < len(src) {
-		switch src[s] & 0x03 {
-		case tagLiteral:
-			x := uint(src[s] >> 2)
-			switch {
-			case x < 60:
-				s++
-			case x == 60:
-				s += 2
-				if s > len(src) {
-					return nil, ErrCorrupt
-				}
-				x = uint(src[s-1])
-			case x == 61:
-				s += 3
-				if s > len(src) {
-					return nil, ErrCorrupt
-				}
-				x = uint(src[s-2]) | uint(src[s-1])<<8
-			case x == 62:
-				s += 4
-				if s > len(src) {
-					return nil, ErrCorrupt
-				}
-				x = uint(src[s-3]) | uint(src[s-2])<<8 | uint(src[s-1])<<16
-			case x == 63:
-				s += 5
-				if s > len(src) {
-					return nil, ErrCorrupt
-				}
-				x = uint(src[s-4]) | uint(src[s-3])<<8 | uint(src[s-2])<<16 | uint(src[s-1])<<24
-			}
-			length = int(x + 1)
-			if length <= 0 {
-				return nil, errors.New("snappy: unsupported literal length")
-			}
-			if length > len(dst)-d || length > len(src)-s {
-				return nil, ErrCorrupt
-			}
-			copy(dst[d:], src[s:s+length])
-			d += length
-			s += length
-			continue
-
-		case tagCopy1:
-			s += 2
-			if s > len(src) {
-				return nil, ErrCorrupt
-			}
-			length = 4 + int(src[s-2])>>2&0x7
-			offset = int(src[s-2])&0xe0<<3 | int(src[s-1])
-
-		case tagCopy2:
-			s += 3
-			if s > len(src) {
-				return nil, ErrCorrupt
-			}
-			length = 1 + int(src[s-3])>>2
-			offset = int(src[s-2]) | int(src[s-1])<<8
-
-		case tagCopy4:
-			return nil, errors.New("snappy: unsupported COPY_4 tag")
-		}
-
-		end := d + length
-		if offset > d || end > len(dst) {
-			return nil, ErrCorrupt
-		}
-		for ; d < end; d++ {
-			dst[d] = dst[d-offset]
-		}
-	}
-	if d != dLen {
-		return nil, ErrCorrupt
-	}
-	return dst[:d], nil
-}
-
-// NewReader returns a new Reader that decompresses from r, using the framing
-// format described at
-// https://github.com/google/snappy/blob/master/framing_format.txt
-func NewReader(r io.Reader) *Reader {
-	return &Reader{
-		r:       r,
-		decoded: make([]byte, maxUncompressedChunkLen),
-		buf:     make([]byte, MaxEncodedLen(maxUncompressedChunkLen)+checksumSize),
-	}
-}
-
-// Reader is an io.Reader that can read Snappy-compressed bytes.
-type Reader struct {
-	r       io.Reader
-	err     error
-	decoded []byte
-	buf     []byte
-	// decoded[i:j] contains decoded bytes that have not yet been passed on.
-	i, j       int
-	readHeader bool
-}
-
-// Reset discards any buffered data, resets all state, and switches the Snappy
-// reader to read from r. This permits reusing a Reader rather than allocating
-// a new one.
-func (r *Reader) Reset(reader io.Reader) {
-	r.r = reader
-	r.err = nil
-	r.i = 0
-	r.j = 0
-	r.readHeader = false
-}
-
-func (r *Reader) readFull(p []byte) (ok bool) {
-	if _, r.err = io.ReadFull(r.r, p); r.err != nil {
-		if r.err == io.ErrUnexpectedEOF {
-			r.err = ErrCorrupt
-		}
-		return false
-	}
-	return true
-}
-
-// Read satisfies the io.Reader interface.
-func (r *Reader) Read(p []byte) (int, error) {
-	if r.err != nil {
-		return 0, r.err
-	}
-	for {
-		if r.i < r.j {
-			n := copy(p, r.decoded[r.i:r.j])
-			r.i += n
-			return n, nil
-		}
-		if !r.readFull(r.buf[:4]) {
-			return 0, r.err
-		}
-		chunkType := r.buf[0]
-		if !r.readHeader {
-			if chunkType != chunkTypeStreamIdentifier {
-				r.err = ErrCorrupt
-				return 0, r.err
-			}
-			r.readHeader = true
-		}
-		chunkLen := int(r.buf[1]) | int(r.buf[2])<<8 | int(r.buf[3])<<16
-		if chunkLen > len(r.buf) {
-			r.err = ErrUnsupported
-			return 0, r.err
-		}
-
-		// The chunk types are specified at
-		// https://github.com/google/snappy/blob/master/framing_format.txt
-		switch chunkType {
-		case chunkTypeCompressedData:
-			// Section 4.2. Compressed data (chunk type 0x00).
-			if chunkLen < checksumSize {
-				r.err = ErrCorrupt
-				return 0, r.err
-			}
-			buf := r.buf[:chunkLen]
-			if !r.readFull(buf) {
-				return 0, r.err
-			}
-			checksum := uint32(buf[0]) | uint32(buf[1])<<8 | uint32(buf[2])<<16 | uint32(buf[3])<<24
-			buf = buf[checksumSize:]
-
-			n, err := DecodedLen(buf)
-			if err != nil {
-				r.err = err
-				return 0, r.err
-			}
-			if n > len(r.decoded) {
-				r.err = ErrCorrupt
-				return 0, r.err
-			}
-			if _, err := Decode(r.decoded, buf); err != nil {
-				r.err = err
-				return 0, r.err
-			}
-			if crc(r.decoded[:n]) != checksum {
-				r.err = ErrCorrupt
-				return 0, r.err
-			}
-			r.i, r.j = 0, n
-			continue
-
-		case chunkTypeUncompressedData:
-			// Section 4.3. Uncompressed data (chunk type 0x01).
-			if chunkLen < checksumSize {
-				r.err = ErrCorrupt
-				return 0, r.err
-			}
-			buf := r.buf[:checksumSize]
-			if !r.readFull(buf) {
-				return 0, r.err
-			}
-			checksum := uint32(buf[0]) | uint32(buf[1])<<8 | uint32(buf[2])<<16 | uint32(buf[3])<<24
-			// Read directly into r.decoded instead of via r.buf.
-			n := chunkLen - checksumSize
-			if !r.readFull(r.decoded[:n]) {
-				return 0, r.err
-			}
-			if crc(r.decoded[:n]) != checksum {
-				r.err = ErrCorrupt
-				return 0, r.err
-			}
-			r.i, r.j = 0, n
-			continue
-
-		case chunkTypeStreamIdentifier:
-			// Section 4.1. Stream identifier (chunk type 0xff).
-			if chunkLen != len(magicBody) {
-				r.err = ErrCorrupt
-				return 0, r.err
-			}
-			if !r.readFull(r.buf[:len(magicBody)]) {
-				return 0, r.err
-			}
-			for i := 0; i < len(magicBody); i++ {
-				if r.buf[i] != magicBody[i] {
-					r.err = ErrCorrupt
-					return 0, r.err
-				}
-			}
-			continue
-		}
-
-		if chunkType <= 0x7f {
-			// Section 4.5. Reserved unskippable chunks (chunk types 0x02-0x7f).
-			r.err = ErrUnsupported
-			return 0, r.err
-		}
-		// Section 4.4 Padding (chunk type 0xfe).
-		// Section 4.6. Reserved skippable chunks (chunk types 0x80-0xfd).
-		if !r.readFull(r.buf[:chunkLen]) {
-			return 0, r.err
-		}
-	}
-}

Godeps/_workspace/src/github.com/golang/snappy/encode.go

@@ -1,356 +0,0 @@
-// Copyright 2011 The Snappy-Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package snappy
-
-import (
-	"encoding/binary"
-	"errors"
-	"io"
-)
-
-// We limit how far copy back-references can go, the same as the C++ code.
-const maxOffset = 1 << 15
-
-// emitLiteral writes a literal chunk and returns the number of bytes written.
-func emitLiteral(dst, lit []byte) int {
-	i, n := 0, uint(len(lit)-1)
-	switch {
-	case n < 60:
-		dst[0] = uint8(n)<<2 | tagLiteral
-		i = 1
-	case n < 1<<8:
-		dst[0] = 60<<2 | tagLiteral
-		dst[1] = uint8(n)
-		i = 2
-	case n < 1<<16:
-		dst[0] = 61<<2 | tagLiteral
-		dst[1] = uint8(n)
-		dst[2] = uint8(n >> 8)
-		i = 3
-	case n < 1<<24:
-		dst[0] = 62<<2 | tagLiteral
-		dst[1] = uint8(n)
-		dst[2] = uint8(n >> 8)
-		dst[3] = uint8(n >> 16)
-		i = 4
-	case int64(n) < 1<<32:
-		dst[0] = 63<<2 | tagLiteral
-		dst[1] = uint8(n)
-		dst[2] = uint8(n >> 8)
-		dst[3] = uint8(n >> 16)
-		dst[4] = uint8(n >> 24)
-		i = 5
-	default:
-		panic("snappy: source buffer is too long")
-	}
-	if copy(dst[i:], lit) != len(lit) {
-		panic("snappy: destination buffer is too short")
-	}
-	return i + len(lit)
-}
-
-// emitCopy writes a copy chunk and returns the number of bytes written.
-func emitCopy(dst []byte, offset, length int) int {
-	i := 0
-	for length > 0 {
-		x := length - 4
-		if 0 <= x && x < 1<<3 && offset < 1<<11 {
-			dst[i+0] = uint8(offset>>8)&0x07<<5 | uint8(x)<<2 | tagCopy1
-			dst[i+1] = uint8(offset)
-			i += 2
-			break
-		}
-
-		x = length
-		if x > 1<<6 {
-			x = 1 << 6
-		}
-		dst[i+0] = uint8(x-1)<<2 | tagCopy2
-		dst[i+1] = uint8(offset)
-		dst[i+2] = uint8(offset >> 8)
-		i += 3
-		length -= x
-	}
-	return i
-}
-
-// Encode returns the encoded form of src. The returned slice may be a sub-
-// slice of dst if dst was large enough to hold the entire encoded block.
-// Otherwise, a newly allocated slice will be returned.
-// It is valid to pass a nil dst.
-func Encode(dst, src []byte) []byte {
-	if n := MaxEncodedLen(len(src)); len(dst) < n {
-		dst = make([]byte, n)
-	}
-
-	// The block starts with the varint-encoded length of the decompressed bytes.
-	d := binary.PutUvarint(dst, uint64(len(src)))
-
-	// Return early if src is short.
-	if len(src) <= 4 {
-		if len(src) != 0 {
-			d += emitLiteral(dst[d:], src)
-		}
-		return dst[:d]
-	}
-
-	// Initialize the hash table. Its size ranges from 1<<8 to 1<<14 inclusive.
-	const maxTableSize = 1 << 14
-	shift, tableSize := uint(32-8), 1<<8
-	for tableSize < maxTableSize && tableSize < len(src) {
-		shift--
-		tableSize *= 2
-	}
-	var table [maxTableSize]int
-
-	// Iterate over the source bytes.
-	var (
-		s   int // The iterator position.
-		t   int // The last position with the same hash as s.
-		lit int // The start position of any pending literal bytes.
-	)
-	for s+3 < len(src) {
-		// Update the hash table.
-		b0, b1, b2, b3 := src[s], src[s+1], src[s+2], src[s+3]
-		h := uint32(b0) | uint32(b1)<<8 | uint32(b2)<<16 | uint32(b3)<<24
-		p := &table[(h*0x1e35a7bd)>>shift]
-		// We need to to store values in [-1, inf) in table. To save
-		// some initialization time, (re)use the table's zero value
-		// and shift the values against this zero: add 1 on writes,
-		// subtract 1 on reads.
-		t, *p = *p-1, s+1
-		// If t is invalid or src[s:s+4] differs from src[t:t+4], accumulate a literal byte.
-		if t < 0 || s-t >= maxOffset || b0 != src[t] || b1 != src[t+1] || b2 != src[t+2] || b3 != src[t+3] {
-			// Skip multiple bytes if the last match was >= 32 bytes prior.
-			s += 1 + (s-lit)>>5
-			continue
-		}
-		// Otherwise, we have a match. First, emit any pending literal bytes.
-		if lit != s {
-			d += emitLiteral(dst[d:], src[lit:s])
-		}
-		// Extend the match to be as long as possible.
-		s0 := s
-		s, t = s+4, t+4
-		for s < len(src) && src[s] == src[t] {
-			s++
-			t++
-		}
-		// Emit the copied bytes.
-		d += emitCopy(dst[d:], s-t, s-s0)
-		lit = s
-	}
-
-	// Emit any final pending literal bytes and return.
-	if lit != len(src) {
-		d += emitLiteral(dst[d:], src[lit:])
-	}
-	return dst[:d]
-}
-
-// MaxEncodedLen returns the maximum length of a snappy block, given its
-// uncompressed length.
-func MaxEncodedLen(srcLen int) int {
-	// Compressed data can be defined as:
-	//    compressed := item* literal*
-	//    item       := literal* copy
-	//
-	// The trailing literal sequence has a space blowup of at most 62/60
-	// since a literal of length 60 needs one tag byte + one extra byte
-	// for length information.
-	//
-	// Item blowup is trickier to measure. Suppose the "copy" op copies
-	// 4 bytes of data. Because of a special check in the encoding code,
-	// we produce a 4-byte copy only if the offset is < 65536. Therefore
-	// the copy op takes 3 bytes to encode, and this type of item leads
-	// to at most the 62/60 blowup for representing literals.
-	//
-	// Suppose the "copy" op copies 5 bytes of data. If the offset is big
-	// enough, it will take 5 bytes to encode the copy op. Therefore the
-	// worst case here is a one-byte literal followed by a five-byte copy.
-	// That is, 6 bytes of input turn into 7 bytes of "compressed" data.
-	//
-	// This last factor dominates the blowup, so the final estimate is:
-	return 32 + srcLen + srcLen/6
-}
-
-var errClosed = errors.New("snappy: Writer is closed")
-
-// NewWriter returns a new Writer that compresses to w.
-//
-// The Writer returned does not buffer writes. There is no need to Flush or
-// Close such a Writer.
-//
-// Deprecated: the Writer returned is not suitable for many small writes, only
-// for few large writes. Use NewBufferedWriter instead, which is efficient
-// regardless of the frequency and shape of the writes, and remember to Close
-// that Writer when done.
-func NewWriter(w io.Writer) *Writer {
-	return &Writer{
-		w:    w,
-		obuf: make([]byte, obufLen),
-	}
-}
-
-// NewBufferedWriter returns a new Writer that compresses to w, using the
-// framing format described at
-// https://github.com/google/snappy/blob/master/framing_format.txt
-//
-// The Writer returned buffers writes. Users must call Close to guarantee all
-// data has been forwarded to the underlying io.Writer. They may also call
-// Flush zero or more times before calling Close.
-func NewBufferedWriter(w io.Writer) *Writer {
-	return &Writer{
-		w:    w,
-		ibuf: make([]byte, 0, maxUncompressedChunkLen),
-		obuf: make([]byte, obufLen),
-	}
-}
-
-// Writer is an io.Writer than can write Snappy-compressed bytes.
-type Writer struct {
-	w   io.Writer
-	err error
-
-	// ibuf is a buffer for the incoming (uncompressed) bytes.
-	//
-	// Its use is optional. For backwards compatibility, Writers created by the
-	// NewWriter function have ibuf == nil, do not buffer incoming bytes, and
-	// therefore do not need to be Flush'ed or Close'd.
-	ibuf []byte
-
-	// obuf is a buffer for the outgoing (compressed) bytes.
-	obuf []byte
-
-	// wroteStreamHeader is whether we have written the stream header.
-	wroteStreamHeader bool
-}
-
-// Reset discards the writer's state and switches the Snappy writer to write to
-// w. This permits reusing a Writer rather than allocating a new one.
-func (w *Writer) Reset(writer io.Writer) {
-	w.w = writer
-	w.err = nil
-	if w.ibuf != nil {
-		w.ibuf = w.ibuf[:0]
-	}
-	w.wroteStreamHeader = false
-}
-
-// Write satisfies the io.Writer interface.
-func (w *Writer) Write(p []byte) (nRet int, errRet error) {
-	if w.ibuf == nil {
-		// Do not buffer incoming bytes. This does not perform or compress well
-		// if the caller of Writer.Write writes many small slices. This
-		// behavior is therefore deprecated, but still supported for backwards
-		// compatibility with code that doesn't explicitly Flush or Close.
-		return w.write(p)
-	}
-
-	// The remainder of this method is based on bufio.Writer.Write from the
-	// standard library.
-
-	for len(p) > (cap(w.ibuf)-len(w.ibuf)) && w.err == nil {
-		var n int
-		if len(w.ibuf) == 0 {
-			// Large write, empty buffer.
-			// Write directly from p to avoid copy.
-			n, _ = w.write(p)
-		} else {
-			n = copy(w.ibuf[len(w.ibuf):cap(w.ibuf)], p)
-			w.ibuf = w.ibuf[:len(w.ibuf)+n]
-			w.Flush()
-		}
-		nRet += n
-		p = p[n:]
-	}
-	if w.err != nil {
-		return nRet, w.err
-	}
-	n := copy(w.ibuf[len(w.ibuf):cap(w.ibuf)], p)
-	w.ibuf = w.ibuf[:len(w.ibuf)+n]
-	nRet += n
-	return nRet, nil
-}
-
-func (w *Writer) write(p []byte) (nRet int, errRet error) {
-	if w.err != nil {
-		return 0, w.err
-	}
-	for len(p) > 0 {
-		obufStart := len(magicChunk)
-		if !w.wroteStreamHeader {
-			w.wroteStreamHeader = true
-			copy(w.obuf, magicChunk)
-			obufStart = 0
-		}
-
-		var uncompressed []byte
-		if len(p) > maxUncompressedChunkLen {
-			uncompressed, p = p[:maxUncompressedChunkLen], p[maxUncompressedChunkLen:]
-		} else {
-			uncompressed, p = p, nil
-		}
-		checksum := crc(uncompressed)
-
-		// Compress the buffer, discarding the result if the improvement
-		// isn't at least 12.5%.
-		compressed := Encode(w.obuf[obufHeaderLen:], uncompressed)
-		chunkType := uint8(chunkTypeCompressedData)
-		chunkLen := 4 + len(compressed)
-		obufEnd := obufHeaderLen + len(compressed)
-		if len(compressed) >= len(uncompressed)-len(uncompressed)/8 {
-			chunkType = chunkTypeUncompressedData
-			chunkLen = 4 + len(uncompressed)
-			obufEnd = obufHeaderLen
-		}
-
-		// Fill in the per-chunk header that comes before the body.
-		w.obuf[len(magicChunk)+0] = chunkType
-		w.obuf[len(magicChunk)+1] = uint8(chunkLen >> 0)
-		w.obuf[len(magicChunk)+2] = uint8(chunkLen >> 8)
-		w.obuf[len(magicChunk)+3] = uint8(chunkLen >> 16)
-		w.obuf[len(magicChunk)+4] = uint8(checksum >> 0)
-		w.obuf[len(magicChunk)+5] = uint8(checksum >> 8)
-		w.obuf[len(magicChunk)+6] = uint8(checksum >> 16)
-		w.obuf[len(magicChunk)+7] = uint8(checksum >> 24)
-
-		if _, err := w.w.Write(w.obuf[obufStart:obufEnd]); err != nil {
-			w.err = err
-			return nRet, err
-		}
-		if chunkType == chunkTypeUncompressedData {
-			if _, err := w.w.Write(uncompressed); err != nil {
-				w.err = err
-				return nRet, err
-			}
-		}
-		nRet += len(uncompressed)
-	}
-	return nRet, nil
-}
-
-// Flush flushes the Writer to its underlying io.Writer.
-func (w *Writer) Flush() error {
-	if w.err != nil {
-		return w.err
-	}
-	if len(w.ibuf) == 0 {
-		return nil
-	}
-	w.write(w.ibuf)
-	w.ibuf = w.ibuf[:0]
-	return w.err
-}
-
-// Close calls Flush and then closes the Writer.
-func (w *Writer) Close() error {
-	w.Flush()
-	ret := w.err
-	if w.err == nil {
-		w.err = errClosed
-	}
-	return ret
-}

Godeps/_workspace/src/github.com/golang/snappy/snappy.go

@@ -1,77 +0,0 @@
-// Copyright 2011 The Snappy-Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package snappy implements the snappy block-based compression format.
-// It aims for very high speeds and reasonable compression.
-//
-// The C++ snappy implementation is at https://github.com/google/snappy
-package snappy
-
-import (
-	"hash/crc32"
-)
-
-/*
-Each encoded block begins with the varint-encoded length of the decoded data,
-followed by a sequence of chunks. Chunks begin and end on byte boundaries. The
-first byte of each chunk is broken into its 2 least and 6 most significant bits
-called l and m: l ranges in [0, 4) and m ranges in [0, 64). l is the chunk tag.
-Zero means a literal tag. All other values mean a copy tag.
-
-For literal tags:
-  - If m < 60, the next 1 + m bytes are literal bytes.
-  - Otherwise, let n be the little-endian unsigned integer denoted by the next
-    m - 59 bytes. The next 1 + n bytes after that are literal bytes.
-
-For copy tags, length bytes are copied from offset bytes ago, in the style of
-Lempel-Ziv compression algorithms. In particular:
-  - For l == 1, the offset ranges in [0, 1<<11) and the length in [4, 12).
-    The length is 4 + the low 3 bits of m. The high 3 bits of m form bits 8-10
-    of the offset. The next byte is bits 0-7 of the offset.
-  - For l == 2, the offset ranges in [0, 1<<16) and the length in [1, 65).
-    The length is 1 + m. The offset is the little-endian unsigned integer
-    denoted by the next 2 bytes.
-  - For l == 3, this tag is a legacy format that is no longer supported.
-*/
-const (
-	tagLiteral = 0x00
-	tagCopy1   = 0x01
-	tagCopy2   = 0x02
-	tagCopy4   = 0x03
-)
-
-const (
-	checksumSize    = 4
-	chunkHeaderSize = 4
-	magicChunk      = "\xff\x06\x00\x00" + magicBody
-	magicBody       = "sNaPpY"
-	// https://github.com/google/snappy/blob/master/framing_format.txt says
-	// that "the uncompressed data in a chunk must be no longer than 65536 bytes".
-	maxUncompressedChunkLen = 65536
-
-	// maxEncodedLenOfMaxUncompressedChunkLen equals
-	// MaxEncodedLen(maxUncompressedChunkLen), but is hard coded to be a const
-	// instead of a variable, so that obufLen can also be a const. Their
-	// equivalence is confirmed by TestMaxEncodedLenOfMaxUncompressedChunkLen.
-	maxEncodedLenOfMaxUncompressedChunkLen = 76490
-
-	obufHeaderLen = len(magicChunk) + checksumSize + chunkHeaderSize
-	obufLen       = obufHeaderLen + maxEncodedLenOfMaxUncompressedChunkLen
-)
-
-const (
-	chunkTypeCompressedData   = 0x00
-	chunkTypeUncompressedData = 0x01
-	chunkTypePadding          = 0xfe
-	chunkTypeStreamIdentifier = 0xff
-)
-
-var crcTable = crc32.MakeTable(crc32.Castagnoli)
-
-// crc implements the checksum specified in section 3 of
-// https://github.com/google/snappy/blob/master/framing_format.txt
-func crc(b []byte) uint32 {
-	c := crc32.Update(0, crcTable, b)
-	return uint32(c>>15|c<<17) + 0xa282ead8
-}

Godeps/_workspace/src/github.com/hashicorp/golang-lru/.gitignore

@@ -1,23 +0,0 @@
-# Compiled Object files, Static and Dynamic libs (Shared Objects)
-*.o
-*.a
-*.so
-
-# Folders
-_obj
-_test
-
-# Architecture specific extensions/prefixes
-*.[568vq]
-[568vq].out
-
-*.cgo1.go
-*.cgo2.c
-_cgo_defun.c
-_cgo_gotypes.go
-_cgo_export.*
-
-_testmain.go
-
-*.exe
-*.test

Godeps/_workspace/src/github.com/huin/goupnp/.gitignore

@@ -1 +0,0 @@
-/gotasks/specs

Godeps/_workspace/src/github.com/huin/goupnp/README.md

@@ -1,44 +0,0 @@
-goupnp is a UPnP client library for Go
-
-Installation
-------------
-
-Run `go get -u github.com/huin/goupnp`.
-
-Documentation
--------------
-
-All doc links below are for ![GoDoc](https://godoc.org/github.com/huin/goupnp?status.svg).
-
-Supported DCPs (you probably want to start with one of these):
-* [av1](https://godoc.org/github.com/huin/goupnp/dcps/av1) - Client for UPnP Device Control Protocol MediaServer v1 and MediaRenderer v1.
-* [internetgateway1](https://godoc.org/github.com/huin/goupnp/dcps/internetgateway1) - Client for UPnP Device Control Protocol Internet Gateway Device v1.
-* [internetgateway2](https://godoc.org/github.com/huin/goupnp/dcps/internetgateway2) - Client for UPnP Device Control Protocol Internet Gateway Device v2.
-
-Core components:
-* [(goupnp)](https://godoc.org/github.com/huin/goupnp) core library - contains datastructures and utilities typically used by the implemented DCPs.
-* [httpu](https://godoc.org/github.com/huin/goupnp/httpu) HTTPU implementation, underlies SSDP.
-* [ssdp](https://godoc.org/github.com/huin/goupnp/ssdp) SSDP client implementation (simple service discovery protocol) - used to discover UPnP services on a network.
-* [soap](https://godoc.org/github.com/huin/goupnp/soap) SOAP client implementation (simple object access protocol) - used to communicate with discovered services.
-
-
-Regenerating dcps generated source code:
-----------------------------------------
-
-1. Install gotasks: `go get -u github.com/jingweno/gotask`
-2. Change to the gotasks directory: `cd gotasks`
-3. Run specgen task: `gotask specgen`
-
-Supporting additional UPnP devices and services:
-------------------------------------------------
-
-Supporting additional services is, in the trivial case, simply a matter of
-adding the service to the `dcpMetadata` whitelist in `gotasks/specgen_task.go`,
-regenerating the source code (see above), and committing that source code.
-
-However, it would be helpful if anyone needing such a service could test the
-service against the service they have, and then reporting any trouble
-encountered as an [issue on this
-project](https://github.com/huin/goupnp/issues/new). If it just works, then
-please report at least minimal working functionality as an issue, and
-optionally contribute the metadata upstream.

Godeps/_workspace/src/github.com/huin/goupnp/cmd/example_httpu_serving/example_httpu_serving.go

@@ -1,20 +0,0 @@
-package main
-
-import (
-	"log"
-	"net/http"
-
-	"github.com/huin/goupnp/httpu"
-)
-
-func main() {
-	srv := httpu.Server{
-		Addr:      "239.255.255.250:1900",
-		Multicast: true,
-		Handler: httpu.HandlerFunc(func(r *http.Request) {
-			log.Printf("Got %s %s message from %v: %v", r.Method, r.URL.Path, r.RemoteAddr, r.Header)
-		}),
-	}
-	err := srv.ListenAndServe()
-	log.Printf("Serving failed with error: %v", err)
-}

Godeps/_workspace/src/github.com/huin/goupnp/cmd/example_internetgateway1/example_internetgateway1.go

@@ -1,67 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"log"
-
-	"github.com/huin/goupnp/dcps/internetgateway1"
-)
-
-func main() {
-	clients, errors, err := internetgateway1.NewWANPPPConnection1Clients()
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	fmt.Printf("Got %d errors finding servers and %d successfully discovered.\n",
-		len(errors), len(clients))
-	for i, e := range errors {
-		fmt.Printf("Error finding server #%d: %v\n", i+1, e)
-	}
-
-	for _, c := range clients {
-		dev := &c.ServiceClient.RootDevice.Device
-		srv := c.ServiceClient.Service
-		fmt.Println(dev.FriendlyName, " :: ", srv.String())
-		scpd, err := srv.RequestSCDP()
-		if err != nil {
-			fmt.Printf("  Error requesting service SCPD: %v\n", err)
-		} else {
-			fmt.Println("  Available actions:")
-			for _, action := range scpd.Actions {
-				fmt.Printf("  * %s\n", action.Name)
-				for _, arg := range action.Arguments {
-					var varDesc string
-					if stateVar := scpd.GetStateVariable(arg.RelatedStateVariable); stateVar != nil {
-						varDesc = fmt.Sprintf(" (%s)", stateVar.DataType.Name)
-					}
-					fmt.Printf("    * [%s] %s%s\n", arg.Direction, arg.Name, varDesc)
-				}
-			}
-		}
-
-		if scpd == nil || scpd.GetAction("GetExternalIPAddress") != nil {
-			ip, err := c.GetExternalIPAddress()
-			fmt.Println("GetExternalIPAddress: ", ip, err)
-		}
-
-		if scpd == nil || scpd.GetAction("GetStatusInfo") != nil {
-			status, lastErr, uptime, err := c.GetStatusInfo()
-			fmt.Println("GetStatusInfo: ", status, lastErr, uptime, err)
-		}
-
-		if scpd == nil || scpd.GetAction("GetIdleDisconnectTime") != nil {
-			idleTime, err := c.GetIdleDisconnectTime()
-			fmt.Println("GetIdleDisconnectTime: ", idleTime, err)
-		}
-
-		if scpd == nil || scpd.GetAction("AddPortMapping") != nil {
-			err := c.AddPortMapping("", 5000, "TCP", 5001, "192.168.1.2", true, "Test port mapping", 0)
-			fmt.Println("AddPortMapping: ", err)
-		}
-		if scpd == nil || scpd.GetAction("DeletePortMapping") != nil {
-			err := c.DeletePortMapping("", 5000, "TCP")
-			fmt.Println("DeletePortMapping: ", err)
-		}
-	}
-}

Godeps/_workspace/src/github.com/huin/goupnp/cmd/example_ssdp_registry/example_ssdp_registry.go

@@ -1,27 +0,0 @@
-package main
-
-import (
-	"log"
-
-	"github.com/huin/goupnp/ssdp"
-)
-
-func main() {
-	c := make(chan ssdp.Update)
-	srv, reg := ssdp.NewServerAndRegistry()
-	reg.AddListener(c)
-	go listener(c)
-	if err := srv.ListenAndServe(); err != nil {
-		log.Print("ListenAndServe failed: ", err)
-	}
-}
-
-func listener(c <-chan ssdp.Update) {
-	for u := range c {
-		if u.Entry != nil {
-			log.Printf("Event: %v USN: %s Entry: %#v", u.EventType, u.USN, *u.Entry)
-		} else {
-			log.Printf("Event: %v USN: %s Entry: <nil>", u.EventType, u.USN)
-		}
-	}
-}

Godeps/_workspace/src/github.com/huin/goupnp/example/example.go

@@ -1,6 +0,0 @@
-// Serves as examples of using the goupnp library.
-//
-// To run examples and see the output for your local network, run the following
-// command (specifically including the -v flag):
-//     go test -v github.com/huin/goupnp/example
-package example

Godeps/_workspace/src/github.com/huin/goupnp/gotasks/specgen_task.go

@@ -1,603 +0,0 @@
-// +build gotask
-
-package gotasks
-
-import (
-	"archive/zip"
-	"encoding/xml"
-	"fmt"
-	"io"
-	"log"
-	"net/http"
-	"os"
-	"path"
-	"path/filepath"
-	"regexp"
-	"strings"
-	"text/template"
-
-	"github.com/huin/goupnp"
-	"github.com/huin/goupnp/scpd"
-	"github.com/huin/goutil/codegen"
-	"github.com/jingweno/gotask/tasking"
-)
-
-var (
-	deviceURNPrefix  = "urn:schemas-upnp-org:device:"
-	serviceURNPrefix = "urn:schemas-upnp-org:service:"
-)
-
-// DCP contains extra metadata to use when generating DCP source files.
-type DCPMetadata struct {
-	Name         string // What to name the Go DCP package.
-	OfficialName string // Official name for the DCP.
-	DocURL       string // Optional - URL for futher documentation about the DCP.
-	XMLSpecURL   string // Where to download the XML spec from.
-	// Any special-case functions to run against the DCP before writing it out.
-	Hacks []DCPHackFn
-}
-
-var dcpMetadata = []DCPMetadata{
-	{
-		Name:         "internetgateway1",
-		OfficialName: "Internet Gateway Device v1",
-		DocURL:       "http://upnp.org/specs/gw/UPnP-gw-InternetGatewayDevice-v1-Device.pdf",
-		XMLSpecURL:   "http://upnp.org/specs/gw/UPnP-gw-IGD-TestFiles-20010921.zip",
-	},
-	{
-		Name:         "internetgateway2",
-		OfficialName: "Internet Gateway Device v2",
-		DocURL:       "http://upnp.org/specs/gw/UPnP-gw-InternetGatewayDevice-v2-Device.pdf",
-		XMLSpecURL:   "http://upnp.org/specs/gw/UPnP-gw-IGD-Testfiles-20110224.zip",
-		Hacks: []DCPHackFn{
-			func(dcp *DCP) error {
-				missingURN := "urn:schemas-upnp-org:service:WANIPv6FirewallControl:1"
-				if _, ok := dcp.ServiceTypes[missingURN]; ok {
-					return nil
-				}
-				urnParts, err := extractURNParts(missingURN, serviceURNPrefix)
-				if err != nil {
-					return err
-				}
-				dcp.ServiceTypes[missingURN] = urnParts
-				return nil
-			},
-		},
-	},
-	{
-		Name:         "av1",
-		OfficialName: "MediaServer v1 and MediaRenderer v1",
-		DocURL:       "http://upnp.org/specs/av/av1/",
-		XMLSpecURL:   "http://upnp.org/specs/av/UPnP-av-TestFiles-20070927.zip",
-	},
-}
-
-type DCPHackFn func(*DCP) error
-
-// NAME
-//   specgen - generates Go code from the UPnP specification files.
-//
-// DESCRIPTION
-//   The specification is available for download from:
-//
-// OPTIONS
-//   -s, --specs_dir=<spec directory>
-//     Path to the specification storage directory. This is used to find (and download if not present) the specification ZIP files. Defaults to 'specs'
-//   -o, --out_dir=<output directory>
-//     Path to the output directory. This is is where the DCP source files will be placed. Should normally correspond to the directory for github.com/huin/goupnp/dcps. Defaults to '../dcps'
-//   --nogofmt
-//     Disable passing the output through gofmt. Do this if debugging code output problems and needing to see the generated code prior to being passed through gofmt.
-func TaskSpecgen(t *tasking.T) {
-	specsDir := fallbackStrValue("specs", t.Flags.String("specs_dir"), t.Flags.String("s"))
-	if err := os.MkdirAll(specsDir, os.ModePerm); err != nil {
-		t.Fatalf("Could not create specs-dir %q: %v\n", specsDir, err)
-	}
-	outDir := fallbackStrValue("../dcps", t.Flags.String("out_dir"), t.Flags.String("o"))
-	useGofmt := !t.Flags.Bool("nogofmt")
-
-NEXT_DCP:
-	for _, d := range dcpMetadata {
-		specFilename := filepath.Join(specsDir, d.Name+".zip")
-		err := acquireFile(specFilename, d.XMLSpecURL)
-		if err != nil {
-			t.Logf("Could not acquire spec for %s, skipping: %v\n", d.Name, err)
-			continue NEXT_DCP
-		}
-		dcp := newDCP(d)
-		if err := dcp.processZipFile(specFilename); err != nil {
-			log.Printf("Error processing spec for %s in file %q: %v", d.Name, specFilename, err)
-			continue NEXT_DCP
-		}
-		for i, hack := range d.Hacks {
-			if err := hack(dcp); err != nil {
-				log.Printf("Error with Hack[%d] for %s: %v", i, d.Name, err)
-				continue NEXT_DCP
-			}
-		}
-		dcp.writePackage(outDir, useGofmt)
-		if err := dcp.writePackage(outDir, useGofmt); err != nil {
-			log.Printf("Error writing package %q: %v", dcp.Metadata.Name, err)
-			continue NEXT_DCP
-		}
-	}
-}
-
-func fallbackStrValue(defaultValue string, values ...string) string {
-	for _, v := range values {
-		if v != "" {
-			return v
-		}
-	}
-	return defaultValue
-}
-
-func acquireFile(specFilename string, xmlSpecURL string) error {
-	if f, err := os.Open(specFilename); err != nil {
-		if !os.IsNotExist(err) {
-			return err
-		}
-	} else {
-		f.Close()
-		return nil
-	}
-
-	resp, err := http.Get(xmlSpecURL)
-	if err != nil {
-		return err
-	}
-	defer resp.Body.Close()
-
-	if resp.StatusCode != http.StatusOK {
-		return fmt.Errorf("could not download spec %q from %q: ",
-			specFilename, xmlSpecURL, resp.Status)
-	}
-
-	tmpFilename := specFilename + ".download"
-	w, err := os.Create(tmpFilename)
-	if err != nil {
-		return err
-	}
-	defer w.Close()
-
-	_, err = io.Copy(w, resp.Body)
-	if err != nil {
-		return err
-	}
-
-	return os.Rename(tmpFilename, specFilename)
-}
-
-// DCP collects together information about a UPnP Device Control Protocol.
-type DCP struct {
-	Metadata     DCPMetadata
-	DeviceTypes  map[string]*URNParts
-	ServiceTypes map[string]*URNParts
-	Services     []SCPDWithURN
-}
-
-func newDCP(metadata DCPMetadata) *DCP {
-	return &DCP{
-		Metadata:     metadata,
-		DeviceTypes:  make(map[string]*URNParts),
-		ServiceTypes: make(map[string]*URNParts),
-	}
-}
-
-func (dcp *DCP) processZipFile(filename string) error {
-	archive, err := zip.OpenReader(filename)
-	if err != nil {
-		return fmt.Errorf("error reading zip file %q: %v", filename, err)
-	}
-	defer archive.Close()
-	for _, deviceFile := range globFiles("*/device/*.xml", archive) {
-		if err := dcp.processDeviceFile(deviceFile); err != nil {
-			return err
-		}
-	}
-	for _, scpdFile := range globFiles("*/service/*.xml", archive) {
-		if err := dcp.processSCPDFile(scpdFile); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func (dcp *DCP) processDeviceFile(file *zip.File) error {
-	var device goupnp.Device
-	if err := unmarshalXmlFile(file, &device); err != nil {
-		return fmt.Errorf("error decoding device XML from file %q: %v", file.Name, err)
-	}
-	var mainErr error
-	device.VisitDevices(func(d *goupnp.Device) {
-		t := strings.TrimSpace(d.DeviceType)
-		if t != "" {
-			u, err := extractURNParts(t, deviceURNPrefix)
-			if err != nil {
-				mainErr = err
-			}
-			dcp.DeviceTypes[t] = u
-		}
-	})
-	device.VisitServices(func(s *goupnp.Service) {
-		u, err := extractURNParts(s.ServiceType, serviceURNPrefix)
-		if err != nil {
-			mainErr = err
-		}
-		dcp.ServiceTypes[s.ServiceType] = u
-	})
-	return mainErr
-}
-
-func (dcp *DCP) writePackage(outDir string, useGofmt bool) error {
-	packageDirname := filepath.Join(outDir, dcp.Metadata.Name)
-	err := os.MkdirAll(packageDirname, os.ModePerm)
-	if err != nil && !os.IsExist(err) {
-		return err
-	}
-	packageFilename := filepath.Join(packageDirname, dcp.Metadata.Name+".go")
-	packageFile, err := os.Create(packageFilename)
-	if err != nil {
-		return err
-	}
-	var output io.WriteCloser = packageFile
-	if useGofmt {
-		if output, err = codegen.NewGofmtWriteCloser(output); err != nil {
-			packageFile.Close()
-			return err
-		}
-	}
-	if err = packageTmpl.Execute(output, dcp); err != nil {
-		output.Close()
-		return err
-	}
-	return output.Close()
-}
-
-func (dcp *DCP) processSCPDFile(file *zip.File) error {
-	scpd := new(scpd.SCPD)
-	if err := unmarshalXmlFile(file, scpd); err != nil {
-		return fmt.Errorf("error decoding SCPD XML from file %q: %v", file.Name, err)
-	}
-	scpd.Clean()
-	urnParts, err := urnPartsFromSCPDFilename(file.Name)
-	if err != nil {
-		return fmt.Errorf("could not recognize SCPD filename %q: %v", file.Name, err)
-	}
-	dcp.Services = append(dcp.Services, SCPDWithURN{
-		URNParts: urnParts,
-		SCPD:     scpd,
-	})
-	return nil
-}
-
-type SCPDWithURN struct {
-	*URNParts
-	SCPD *scpd.SCPD
-}
-
-func (s *SCPDWithURN) WrapArguments(args []*scpd.Argument) (argumentWrapperList, error) {
-	wrappedArgs := make(argumentWrapperList, len(args))
-	for i, arg := range args {
-		wa, err := s.wrapArgument(arg)
-		if err != nil {
-			return nil, err
-		}
-		wrappedArgs[i] = wa
-	}
-	return wrappedArgs, nil
-}
-
-func (s *SCPDWithURN) wrapArgument(arg *scpd.Argument) (*argumentWrapper, error) {
-	relVar := s.SCPD.GetStateVariable(arg.RelatedStateVariable)
-	if relVar == nil {
-		return nil, fmt.Errorf("no such state variable: %q, for argument %q", arg.RelatedStateVariable, arg.Name)
-	}
-	cnv, ok := typeConvs[relVar.DataType.Name]
-	if !ok {
-		return nil, fmt.Errorf("unknown data type: %q, for state variable %q, for argument %q", relVar.DataType.Type, arg.RelatedStateVariable, arg.Name)
-	}
-	return &argumentWrapper{
-		Argument: *arg,
-		relVar:   relVar,
-		conv:     cnv,
-	}, nil
-}
-
-type argumentWrapper struct {
-	scpd.Argument
-	relVar *scpd.StateVariable
-	conv   conv
-}
-
-func (arg *argumentWrapper) AsParameter() string {
-	return fmt.Sprintf("%s %s", arg.Name, arg.conv.ExtType)
-}
-
-func (arg *argumentWrapper) HasDoc() bool {
-	rng := arg.relVar.AllowedValueRange
-	return ((rng != nil && (rng.Minimum != "" || rng.Maximum != "" || rng.Step != "")) ||
-		len(arg.relVar.AllowedValues) > 0)
-}
-
-func (arg *argumentWrapper) Document() string {
-	relVar := arg.relVar
-	if rng := relVar.AllowedValueRange; rng != nil {
-		var parts []string
-		if rng.Minimum != "" {
-			parts = append(parts, fmt.Sprintf("minimum=%s", rng.Minimum))
-		}
-		if rng.Maximum != "" {
-			parts = append(parts, fmt.Sprintf("maximum=%s", rng.Maximum))
-		}
-		if rng.Step != "" {
-			parts = append(parts, fmt.Sprintf("step=%s", rng.Step))
-		}
-		return "allowed value range: " + strings.Join(parts, ", ")
-	}
-	if len(relVar.AllowedValues) != 0 {
-		return "allowed values: " + strings.Join(relVar.AllowedValues, ", ")
-	}
-	return ""
-}
-
-func (arg *argumentWrapper) Marshal() string {
-	return fmt.Sprintf("soap.Marshal%s(%s)", arg.conv.FuncSuffix, arg.Name)
-}
-
-func (arg *argumentWrapper) Unmarshal(objVar string) string {
-	return fmt.Sprintf("soap.Unmarshal%s(%s.%s)", arg.conv.FuncSuffix, objVar, arg.Name)
-}
-
-type argumentWrapperList []*argumentWrapper
-
-func (args argumentWrapperList) HasDoc() bool {
-	for _, arg := range args {
-		if arg.HasDoc() {
-			return true
-		}
-	}
-	return false
-}
-
-type conv struct {
-	FuncSuffix string
-	ExtType    string
-}
-
-// typeConvs maps from a SOAP type (e.g "fixed.14.4") to the function name
-// suffix inside the soap module (e.g "Fixed14_4") and the Go type.
-var typeConvs = map[string]conv{
-	"ui1":         conv{"Ui1", "uint8"},
-	"ui2":         conv{"Ui2", "uint16"},
-	"ui4":         conv{"Ui4", "uint32"},
-	"i1":          conv{"I1", "int8"},
-	"i2":          conv{"I2", "int16"},
-	"i4":          conv{"I4", "int32"},
-	"int":         conv{"Int", "int64"},
-	"r4":          conv{"R4", "float32"},
-	"r8":          conv{"R8", "float64"},
-	"number":      conv{"R8", "float64"}, // Alias for r8.
-	"fixed.14.4":  conv{"Fixed14_4", "float64"},
-	"float":       conv{"R8", "float64"},
-	"char":        conv{"Char", "rune"},
-	"string":      conv{"String", "string"},
-	"date":        conv{"Date", "time.Time"},
-	"dateTime":    conv{"DateTime", "time.Time"},
-	"dateTime.tz": conv{"DateTimeTz", "time.Time"},
-	"time":        conv{"TimeOfDay", "soap.TimeOfDay"},
-	"time.tz":     conv{"TimeOfDayTz", "soap.TimeOfDay"},
-	"boolean":     conv{"Boolean", "bool"},
-	"bin.base64":  conv{"BinBase64", "[]byte"},
-	"bin.hex":     conv{"BinHex", "[]byte"},
-	"uri":         conv{"URI", "*url.URL"},
-}
-
-func globFiles(pattern string, archive *zip.ReadCloser) []*zip.File {
-	var files []*zip.File
-	for _, f := range archive.File {
-		if matched, err := path.Match(pattern, f.Name); err != nil {
-			// This shouldn't happen - all patterns are hard-coded, errors in them
-			// are a programming error.
-			panic(err)
-		} else if matched {
-			files = append(files, f)
-		}
-	}
-	return files
-}
-
-func unmarshalXmlFile(file *zip.File, data interface{}) error {
-	r, err := file.Open()
-	if err != nil {
-		return err
-	}
-	decoder := xml.NewDecoder(r)
-	r.Close()
-	return decoder.Decode(data)
-}
-
-type URNParts struct {
-	URN     string
-	Name    string
-	Version string
-}
-
-func (u *URNParts) Const() string {
-	return fmt.Sprintf("URN_%s_%s", u.Name, u.Version)
-}
-
-// extractURNParts extracts the name and version from a URN string.
-func extractURNParts(urn, expectedPrefix string) (*URNParts, error) {
-	if !strings.HasPrefix(urn, expectedPrefix) {
-		return nil, fmt.Errorf("%q does not have expected prefix %q", urn, expectedPrefix)
-	}
-	parts := strings.SplitN(strings.TrimPrefix(urn, expectedPrefix), ":", 2)
-	if len(parts) != 2 {
-		return nil, fmt.Errorf("%q does not have a name and version", urn)
-	}
-	name, version := parts[0], parts[1]
-	return &URNParts{urn, name, version}, nil
-}
-
-var scpdFilenameRe = regexp.MustCompile(
-	`.*/([a-zA-Z0-9]+)([0-9]+)\.xml`)
-
-func urnPartsFromSCPDFilename(filename string) (*URNParts, error) {
-	parts := scpdFilenameRe.FindStringSubmatch(filename)
-	if len(parts) != 3 {
-		return nil, fmt.Errorf("SCPD filename %q does not have expected number of parts", filename)
-	}
-	name, version := parts[1], parts[2]
-	return &URNParts{
-		URN:     serviceURNPrefix + name + ":" + version,
-		Name:    name,
-		Version: version,
-	}, nil
-}
-
-var packageTmpl = template.Must(template.New("package").Parse(`{{$name := .Metadata.Name}}
-// Client for UPnP Device Control Protocol {{.Metadata.OfficialName}}.
-// {{if .Metadata.DocURL}}
-// This DCP is documented in detail at: {{.Metadata.DocURL}}{{end}}
-//
-// Typically, use one of the New* functions to create clients for services.
-package {{$name}}
-
-// Generated file - do not edit by hand. See README.md
-
-
-import (
-	"net/url"
-	"time"
-
-	"github.com/huin/goupnp"
-	"github.com/huin/goupnp/soap"
-)
-
-// Hack to avoid Go complaining if time isn't used.
-var _ time.Time
-
-// Device URNs:
-const ({{range .DeviceTypes}}
-	{{.Const}} = "{{.URN}}"{{end}}
-)
-
-// Service URNs:
-const ({{range .ServiceTypes}}
-	{{.Const}} = "{{.URN}}"{{end}}
-)
-
-{{range .Services}}
-{{$srv := .}}
-{{$srvIdent := printf "%s%s" .Name .Version}}
-
-// {{$srvIdent}} is a client for UPnP SOAP service with URN "{{.URN}}". See
-// goupnp.ServiceClient, which contains RootDevice and Service attributes which
-// are provided for informational value.
-type {{$srvIdent}} struct {
-	goupnp.ServiceClient
-}
-
-// New{{$srvIdent}}Clients discovers instances of the service on the network,
-// and returns clients to any that are found. errors will contain an error for
-// any devices that replied but which could not be queried, and err will be set
-// if the discovery process failed outright.
-//
-// This is a typical entry calling point into this package.
-func New{{$srvIdent}}Clients() (clients []*{{$srvIdent}}, errors []error, err error) {
-	var genericClients []goupnp.ServiceClient
-	if genericClients, errors, err = goupnp.NewServiceClients({{$srv.Const}}); err != nil {
-		return
-	}
-	clients = new{{$srvIdent}}ClientsFromGenericClients(genericClients)
-	return
-}
-
-// New{{$srvIdent}}ClientsByURL discovers instances of the service at the given
-// URL, and returns clients to any that are found. An error is returned if
-// there was an error probing the service.
-//
-// This is a typical entry calling point into this package when reusing an
-// previously discovered service URL.
-func New{{$srvIdent}}ClientsByURL(loc *url.URL) ([]*{{$srvIdent}}, error) {
-	genericClients, err := goupnp.NewServiceClientsByURL(loc, {{$srv.Const}})
-	if err != nil {
-		return nil, err
-	}
-	return new{{$srvIdent}}ClientsFromGenericClients(genericClients), nil
-}
-
-// New{{$srvIdent}}ClientsFromRootDevice discovers instances of the service in
-// a given root device, and returns clients to any that are found. An error is
-// returned if there was not at least one instance of the service within the
-// device. The location parameter is simply assigned to the Location attribute
-// of the wrapped ServiceClient(s).
-//
-// This is a typical entry calling point into this package when reusing an
-// previously discovered root device.
-func New{{$srvIdent}}ClientsFromRootDevice(rootDevice *goupnp.RootDevice, loc *url.URL) ([]*{{$srvIdent}}, error) {
-	genericClients, err := goupnp.NewServiceClientsFromRootDevice(rootDevice, loc, {{$srv.Const}})
-	if err != nil {
-		return nil, err
-	}
-	return new{{$srvIdent}}ClientsFromGenericClients(genericClients), nil
-}
-
-func new{{$srvIdent}}ClientsFromGenericClients(genericClients []goupnp.ServiceClient) []*{{$srvIdent}} {
-	clients := make([]*{{$srvIdent}}, len(genericClients))
-	for i := range genericClients {
-		clients[i] = &{{$srvIdent}}{genericClients[i]}
-	}
-	return clients
-}
-
-{{range .SCPD.Actions}}{{/* loops over *SCPDWithURN values */}}
-
-{{$winargs := $srv.WrapArguments .InputArguments}}
-{{$woutargs := $srv.WrapArguments .OutputArguments}}
-{{if $winargs.HasDoc}}
-//
-// Arguments:{{range $winargs}}{{if .HasDoc}}
-//
-// * {{.Name}}: {{.Document}}{{end}}{{end}}{{end}}
-{{if $woutargs.HasDoc}}
-//
-// Return values:{{range $woutargs}}{{if .HasDoc}}
-//
-// * {{.Name}}: {{.Document}}{{end}}{{end}}{{end}}
-func (client *{{$srvIdent}}) {{.Name}}({{range $winargs}}{{/*
-*/}}{{.AsParameter}}, {{end}}{{/*
-*/}}) ({{range $woutargs}}{{/*
-*/}}{{.AsParameter}}, {{end}} err error) {
-	// Request structure.
-	request := {{if $winargs}}&{{template "argstruct" $winargs}}{{"{}"}}{{else}}{{"interface{}(nil)"}}{{end}}
-	// BEGIN Marshal arguments into request.
-{{range $winargs}}
-	if request.{{.Name}}, err = {{.Marshal}}; err != nil {
-		return
-	}{{end}}
-	// END Marshal arguments into request.
-
-	// Response structure.
-	response := {{if $woutargs}}&{{template "argstruct" $woutargs}}{{"{}"}}{{else}}{{"interface{}(nil)"}}{{end}}
-
-	// Perform the SOAP call.
-	if err = client.SOAPClient.PerformAction({{$srv.URNParts.Const}}, "{{.Name}}", request, response); err != nil {
-		return
-	}
-
-	// BEGIN Unmarshal arguments from response.
-{{range $woutargs}}
-	if {{.Name}}, err = {{.Unmarshal "response"}}; err != nil {
-		return
-	}{{end}}
-	// END Unmarshal arguments from response.
-	return
-}
-{{end}}{{/* range .SCPD.Actions */}}
-{{end}}{{/* range .Services */}}
-
-{{define "argstruct"}}struct {{"{"}}{{range .}}
-{{.Name}} string
-{{end}}{{"}"}}{{end}}
-`))

Godeps/_workspace/src/github.com/huin/goupnp/ssdp/registry.go

@@ -1,312 +0,0 @@
-package ssdp
-
-import (
-	"fmt"
-	"log"
-	"net/http"
-	"net/url"
-	"regexp"
-	"strconv"
-	"sync"
-	"time"
-
-	"github.com/huin/goupnp/httpu"
-)
-
-const (
-	maxExpiryTimeSeconds = 24 * 60 * 60
-)
-
-var (
-	maxAgeRx = regexp.MustCompile("max-age=([0-9]+)")
-)
-
-const (
-	EventAlive = EventType(iota)
-	EventUpdate
-	EventByeBye
-)
-
-type EventType int8
-
-func (et EventType) String() string {
-	switch et {
-	case EventAlive:
-		return "EventAlive"
-	case EventUpdate:
-		return "EventUpdate"
-	case EventByeBye:
-		return "EventByeBye"
-	default:
-		return fmt.Sprintf("EventUnknown(%d)", int8(et))
-	}
-}
-
-type Update struct {
-	// The USN of the service.
-	USN string
-	// What happened.
-	EventType EventType
-	// The entry, which is nil if the service was not known and
-	// EventType==EventByeBye. The contents of this must not be modified as it is
-	// shared with the registry and other listeners. Once created, the Registry
-	// does not modify the Entry value - any updates are replaced with a new
-	// Entry value.
-	Entry *Entry
-}
-
-type Entry struct {
-	// The address that the entry data was actually received from.
-	RemoteAddr string
-	// Unique Service Name. Identifies a unique instance of a device or service.
-	USN string
-	// Notfication Type. The type of device or service being announced.
-	NT string
-	// Server's self-identifying string.
-	Server string
-	Host   string
-	// Location of the UPnP root device description.
-	Location url.URL
-
-	// Despite BOOTID,CONFIGID being required fields, apparently they are not
-	// always set by devices. Set to -1 if not present.
-
-	BootID   int32
-	ConfigID int32
-
-	SearchPort uint16
-
-	// When the last update was received for this entry identified by this USN.
-	LastUpdate time.Time
-	// When the last update's cached values are advised to expire.
-	CacheExpiry time.Time
-}
-
-func newEntryFromRequest(r *http.Request) (*Entry, error) {
-	now := time.Now()
-	expiryDuration, err := parseCacheControlMaxAge(r.Header.Get("CACHE-CONTROL"))
-	if err != nil {
-		return nil, fmt.Errorf("ssdp: error parsing CACHE-CONTROL max age: %v", err)
-	}
-
-	loc, err := url.Parse(r.Header.Get("LOCATION"))
-	if err != nil {
-		return nil, fmt.Errorf("ssdp: error parsing entry Location URL: %v", err)
-	}
-
-	bootID, err := parseUpnpIntHeader(r.Header, "BOOTID.UPNP.ORG", -1)
-	if err != nil {
-		return nil, err
-	}
-	configID, err := parseUpnpIntHeader(r.Header, "CONFIGID.UPNP.ORG", -1)
-	if err != nil {
-		return nil, err
-	}
-	searchPort, err := parseUpnpIntHeader(r.Header, "SEARCHPORT.UPNP.ORG", ssdpSearchPort)
-	if err != nil {
-		return nil, err
-	}
-
-	if searchPort < 1 || searchPort > 65535 {
-		return nil, fmt.Errorf("ssdp: search port %d is out of range", searchPort)
-	}
-
-	return &Entry{
-		RemoteAddr:  r.RemoteAddr,
-		USN:         r.Header.Get("USN"),
-		NT:          r.Header.Get("NT"),
-		Server:      r.Header.Get("SERVER"),
-		Host:        r.Header.Get("HOST"),
-		Location:    *loc,
-		BootID:      bootID,
-		ConfigID:    configID,
-		SearchPort:  uint16(searchPort),
-		LastUpdate:  now,
-		CacheExpiry: now.Add(expiryDuration),
-	}, nil
-}
-
-func parseCacheControlMaxAge(cc string) (time.Duration, error) {
-	matches := maxAgeRx.FindStringSubmatch(cc)
-	if len(matches) != 2 {
-		return 0, fmt.Errorf("did not find exactly one max-age in cache control header: %q", cc)
-	}
-	expirySeconds, err := strconv.ParseInt(matches[1], 10, 16)
-	if err != nil {
-		return 0, err
-	}
-	if expirySeconds < 1 || expirySeconds > maxExpiryTimeSeconds {
-		return 0, fmt.Errorf("rejecting bad expiry time of %d seconds", expirySeconds)
-	}
-	return time.Duration(expirySeconds) * time.Second, nil
-}
-
-// parseUpnpIntHeader is intended to parse the
-// {BOOT,CONFIGID,SEARCHPORT}.UPNP.ORG header fields. It returns the def if
-// the head is empty or missing.
-func parseUpnpIntHeader(headers http.Header, headerName string, def int32) (int32, error) {
-	s := headers.Get(headerName)
-	if s == "" {
-		return def, nil
-	}
-	v, err := strconv.ParseInt(s, 10, 32)
-	if err != nil {
-		return 0, fmt.Errorf("ssdp: could not parse header %s: %v", headerName, err)
-	}
-	return int32(v), nil
-}
-
-var _ httpu.Handler = new(Registry)
-
-// Registry maintains knowledge of discovered devices and services.
-//
-// NOTE: the interface for this is experimental and may change, or go away
-// entirely.
-type Registry struct {
-	lock  sync.Mutex
-	byUSN map[string]*Entry
-
-	listenersLock sync.RWMutex
-	listeners     map[chan<- Update]struct{}
-}
-
-func NewRegistry() *Registry {
-	return &Registry{
-		byUSN:     make(map[string]*Entry),
-		listeners: make(map[chan<- Update]struct{}),
-	}
-}
-
-// NewServerAndRegistry is a convenience function to create a registry, and an
-// httpu server to pass it messages. Call ListenAndServe on the server for
-// messages to be processed.
-func NewServerAndRegistry() (*httpu.Server, *Registry) {
-	reg := NewRegistry()
-	srv := &httpu.Server{
-		Addr:      ssdpUDP4Addr,
-		Multicast: true,
-		Handler:   reg,
-	}
-	return srv, reg
-}
-
-func (reg *Registry) AddListener(c chan<- Update) {
-	reg.listenersLock.Lock()
-	defer reg.listenersLock.Unlock()
-	reg.listeners[c] = struct{}{}
-}
-
-func (reg *Registry) RemoveListener(c chan<- Update) {
-	reg.listenersLock.Lock()
-	defer reg.listenersLock.Unlock()
-	delete(reg.listeners, c)
-}
-
-func (reg *Registry) sendUpdate(u Update) {
-	reg.listenersLock.RLock()
-	defer reg.listenersLock.RUnlock()
-	for c := range reg.listeners {
-		c <- u
-	}
-}
-
-// GetService returns known service (or device) entries for the given service
-// URN.
-func (reg *Registry) GetService(serviceURN string) []*Entry {
-	// Currently assumes that the map is small, so we do a linear search rather
-	// than indexed to avoid maintaining two maps.
-	var results []*Entry
-	reg.lock.Lock()
-	defer reg.lock.Unlock()
-	for _, entry := range reg.byUSN {
-		if entry.NT == serviceURN {
-			results = append(results, entry)
-		}
-	}
-	return results
-}
-
-// ServeMessage implements httpu.Handler, and uses SSDP NOTIFY requests to
-// maintain the registry of devices and services.
-func (reg *Registry) ServeMessage(r *http.Request) {
-	if r.Method != methodNotify {
-		return
-	}
-
-	nts := r.Header.Get("nts")
-
-	var err error
-	switch nts {
-	case ntsAlive:
-		err = reg.handleNTSAlive(r)
-	case ntsUpdate:
-		err = reg.handleNTSUpdate(r)
-	case ntsByebye:
-		err = reg.handleNTSByebye(r)
-	default:
-		err = fmt.Errorf("unknown NTS value: %q", nts)
-	}
-	if err != nil {
-		log.Printf("goupnp/ssdp: failed to handle %s message from %s: %v", nts, r.RemoteAddr, err)
-	}
-}
-
-func (reg *Registry) handleNTSAlive(r *http.Request) error {
-	entry, err := newEntryFromRequest(r)
-	if err != nil {
-		return err
-	}
-
-	reg.lock.Lock()
-	reg.byUSN[entry.USN] = entry
-	reg.lock.Unlock()
-
-	reg.sendUpdate(Update{
-		USN:       entry.USN,
-		EventType: EventAlive,
-		Entry:     entry,
-	})
-
-	return nil
-}
-
-func (reg *Registry) handleNTSUpdate(r *http.Request) error {
-	entry, err := newEntryFromRequest(r)
-	if err != nil {
-		return err
-	}
-	nextBootID, err := parseUpnpIntHeader(r.Header, "NEXTBOOTID.UPNP.ORG", -1)
-	if err != nil {
-		return err
-	}
-	entry.BootID = nextBootID
-
-	reg.lock.Lock()
-	reg.byUSN[entry.USN] = entry
-	reg.lock.Unlock()
-
-	reg.sendUpdate(Update{
-		USN:       entry.USN,
-		EventType: EventUpdate,
-		Entry:     entry,
-	})
-
-	return nil
-}
-
-func (reg *Registry) handleNTSByebye(r *http.Request) error {
-	usn := r.Header.Get("USN")
-
-	reg.lock.Lock()
-	entry := reg.byUSN[usn]
-	delete(reg.byUSN, usn)
-	reg.lock.Unlock()
-
-	reg.sendUpdate(Update{
-		USN:       usn,
-		EventType: EventByeBye,
-		Entry:     entry,
-	})
-
-	return nil
-}

Godeps/_workspace/src/github.com/jackpal/gateway/LICENSE

@@ -1,27 +0,0 @@
-// Copyright (c) 2010 Jack Palevich. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//    * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//    * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//    * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

Godeps/_workspace/src/github.com/jackpal/gateway/README.md

@@ -1,7 +0,0 @@
-# gateway
-
-A very simple library for discovering the IP address of the local LAN gateway.
-
-Provides implementations for Linux, OS X (Darwin) and Windows.
-
-Pull requests for other OSs happily considered!

Godeps/_workspace/src/github.com/jackpal/gateway/gateway_darwin.go

@@ -1,40 +0,0 @@
-package gateway
-
-import (
-	"bytes"
-	"io/ioutil"
-	"net"
-	"os/exec"
-)
-
-func DiscoverGateway() (ip net.IP, err error) {
-	routeCmd := exec.Command("route", "-n", "get", "0.0.0.0")
-	stdOut, err := routeCmd.StdoutPipe()
-	if err != nil {
-		return
-	}
-	if err = routeCmd.Start(); err != nil {
-		return
-	}
-	output, err := ioutil.ReadAll(stdOut)
-	if err != nil {
-		return
-	}
-
-	// Darwin route out format is always like this:
-	//    route to: default
-	// destination: default
-	//        mask: default
-	//     gateway: 192.168.1.1
-	outputLines := bytes.Split(output, []byte("\n"))
-	for _, line := range outputLines {
-		if bytes.Contains(line, []byte("gateway:")) {
-			gatewayFields := bytes.Fields(line)
-			ip = net.ParseIP(string(gatewayFields[1]))
-			break
-		}
-	}
-
-	err = routeCmd.Wait()
-	return
-}

Godeps/_workspace/src/github.com/jackpal/gateway/gateway_linux.go

@@ -1,75 +0,0 @@
-package gateway
-
-import (
-	"bytes"
-	"io/ioutil"
-	"net"
-	"os/exec"
-)
-
-func discoverGatewayUsingIp() (ip net.IP, err error) {
-	routeCmd := exec.Command("ip", "route", "show")
-	stdOut, err := routeCmd.StdoutPipe()
-	if err != nil {
-		return
-	}
-	if err = routeCmd.Start(); err != nil {
-		return
-	}
-	output, err := ioutil.ReadAll(stdOut)
-	if err != nil {
-		return
-	}
-
-	// Linux 'ip route show' format looks like this:
-	// default via 192.168.178.1 dev wlp3s0  metric 303
-	// 192.168.178.0/24 dev wlp3s0  proto kernel  scope link  src 192.168.178.76  metric 303
-	outputLines := bytes.Split(output, []byte("\n"))
-	for _, line := range outputLines {
-		if bytes.Contains(line, []byte("default")) {
-			ipFields := bytes.Fields(line)
-			ip = net.ParseIP(string(ipFields[2]))
-			break
-		}
-	}
-	err = routeCmd.Wait()
-	return
-}
-
-func discoverGatewayUsingRoute() (ip net.IP, err error) {
-	routeCmd := exec.Command("route", "-n")
-	stdOut, err := routeCmd.StdoutPipe()
-	if err != nil {
-		return
-	}
-	if err = routeCmd.Start(); err != nil {
-		return
-	}
-	output, err := ioutil.ReadAll(stdOut)
-	if err != nil {
-		return
-	}
-
-	// Linux route out format is always like this:
-	// Kernel IP routing table
-	// Destination     Gateway         Genmask         Flags Metric Ref    Use Iface
-	// 0.0.0.0         192.168.1.1     0.0.0.0         UG    0      0        0 eth0
-	outputLines := bytes.Split(output, []byte("\n"))
-	for _, line := range outputLines {
-		if bytes.Contains(line, []byte("0.0.0.0")) {
-			ipFields := bytes.Fields(line)
-			ip = net.ParseIP(string(ipFields[1]))
-			break
-		}
-	}
-	err = routeCmd.Wait()
-	return
-}
-
-func DiscoverGateway() (ip net.IP, err error) {
-	ip, err = discoverGatewayUsingRoute()
-	if err != nil {
-		ip, err = discoverGatewayUsingIp()
-	}
-	return
-}

Godeps/_workspace/src/github.com/jackpal/gateway/gateway_unimplemented.go

@@ -1,14 +0,0 @@
-// +build !darwin,!linux,!windows
-
-package gateway
-
-import (
-	"fmt"
-	"net"
-	"runtime"
-)
-
-func DiscoverGateway() (ip net.IP, err error) {
-	err = fmt.Errorf("DiscoverGateway not implemented for OS %s", runtime.GOOS)
-	return
-}

Godeps/_workspace/src/github.com/jackpal/gateway/gateway_windows.go

@@ -1,43 +0,0 @@
-package gateway
-
-import (
-	"bytes"
-	"io/ioutil"
-	"net"
-	"os/exec"
-)
-
-func DiscoverGateway() (ip net.IP, err error) {
-	routeCmd := exec.Command("route", "print", "0.0.0.0")
-	stdOut, err := routeCmd.StdoutPipe()
-	if err != nil {
-		return
-	}
-	if err = routeCmd.Start(); err != nil {
-		return
-	}
-	output, err := ioutil.ReadAll(stdOut)
-	if err != nil {
-		return
-	}
-
-	// Windows route output format is always like this:
-	// ===========================================================================
-	// Active Routes:
-	// Network Destination        Netmask          Gateway       Interface  Metric
-	//           0.0.0.0          0.0.0.0      192.168.1.1    192.168.1.100     20
-	// ===========================================================================
-	// I'm trying to pick the active route,
-	// then jump 2 lines and pick the third IP
-	// Not using regex because output is quite standard from Windows XP to 8 (NEEDS TESTING)
-	outputLines := bytes.Split(output, []byte("\n"))
-	for idx, line := range outputLines {
-		if bytes.Contains(line, []byte("Active Routes:")) {
-			ipFields := bytes.Fields(outputLines[idx+2])
-			ip = net.ParseIP(string(ipFields[2]))
-			break
-		}
-	}
-	err = routeCmd.Wait()
-	return
-}

Godeps/_workspace/src/github.com/jackpal/go-nat-pmp/README.md

@@ -1,48 +0,0 @@
-go-nat-pmp
-==========
-
-A Go language client for the NAT-PMP internet protocol for port mapping and discovering the external
-IP address of a firewall.
-
-NAT-PMP is supported by Apple brand routers and open source routers like Tomato and DD-WRT.
-
-See http://tools.ietf.org/html/draft-cheshire-nat-pmp-03
-
-Get the package
----------------
-
-    go get -u github.com/jackpal/go-nat-pmp
-
-Usage
------
-
-    import natpmp "github.com/jackpal/go-nat-pmp"
-
-    client := natpmp.NewClient(gatewayIP)
-    response, err := client.GetExternalAddress()
-    if err != nil {
-        return
-    }
-    print("External IP address:", response.ExternalIPAddress)
-
-Notes
------
-
-There doesn't seem to be an easy way to programmatically determine the address of the default gateway.
-(Linux and OSX have a "routes" kernel API that can be examined to get this information, but there is
-no Go package for getting this information.)
-
-Clients
--------
-
-This library is used in the Taipei Torrent BitTorrent client http://github.com/jackpal/Taipei-Torrent
-
-Complete documentation
-----------------------
-
-    http://godoc.org/github.com/jackpal/go-nat-pmp
-
-License
--------
-
-This project is licensed under the Apache License 2.0.

Godeps/_workspace/src/github.com/jackpal/go-nat-pmp/natpmp.go

@@ -1,196 +0,0 @@
-package natpmp
-
-import (
-	"fmt"
-	"github.com/jackpal/gateway"
-	"log"
-	"net"
-	"time"
-)
-
-// Implement the NAT-PMP protocol, typically supported by Apple routers and open source
-// routers such as DD-WRT and Tomato.
-//
-// See http://tools.ietf.org/html/draft-cheshire-nat-pmp-03
-//
-// Usage:
-//
-//    client := natpmp.NewClient(gatewayIP)
-//    response, err := client.GetExternalAddress()
-
-const nAT_PMP_PORT = 5351
-
-const nAT_TRIES = 9
-
-const nAT_INITIAL_MS = 250
-
-// The recommended mapping lifetime for AddPortMapping
-const RECOMMENDED_MAPPING_LIFETIME_SECONDS = 3600
-
-// Client is a NAT-PMP protocol client.
-type Client struct {
-	gateway net.IP
-}
-
-// Create a NAT-PMP client for the NAT-PMP server at the gateway.
-func NewClient(gateway net.IP) (nat *Client) {
-	return &Client{gateway}
-}
-
-// Create a NAT-PMP client for the NAT-PMP server at the default gateway.
-func NewClientForDefaultGateway() (nat *Client, err error) {
-	var g net.IP
-	g, err = gateway.DiscoverGateway()
-	if err != nil {
-		return
-	}
-	nat = NewClient(g)
-	return
-}
-
-// Results of the NAT-PMP GetExternalAddress operation
-type GetExternalAddressResult struct {
-	SecondsSinceStartOfEpoc uint32
-	ExternalIPAddress       [4]byte
-}
-
-// Get the external address of the router.
-func (n *Client) GetExternalAddress() (result *GetExternalAddressResult, err error) {
-	msg := make([]byte, 2)
-	msg[0] = 0 // Version 0
-	msg[1] = 0 // OP Code 0
-	response, err := n.rpc(msg, 12)
-	if err != nil {
-		return
-	}
-	result = &GetExternalAddressResult{}
-	result.SecondsSinceStartOfEpoc = readNetworkOrderUint32(response[4:8])
-	copy(result.ExternalIPAddress[:], response[8:12])
-	return
-}
-
-// Results of the NAT-PMP AddPortMapping operation
-type AddPortMappingResult struct {
-	SecondsSinceStartOfEpoc      uint32
-	InternalPort                 uint16
-	MappedExternalPort           uint16
-	PortMappingLifetimeInSeconds uint32
-}
-
-// Add (or delete) a port mapping. To delete a mapping, set the requestedExternalPort and lifetime to 0
-func (n *Client) AddPortMapping(protocol string, internalPort, requestedExternalPort int, lifetime int) (result *AddPortMappingResult, err error) {
-	var opcode byte
-	if protocol == "udp" {
-		opcode = 1
-	} else if protocol == "tcp" {
-		opcode = 2
-	} else {
-		err = fmt.Errorf("unknown protocol %v", protocol)
-		return
-	}
-	msg := make([]byte, 12)
-	msg[0] = 0 // Version 0
-	msg[1] = opcode
-	writeNetworkOrderUint16(msg[4:6], uint16(internalPort))
-	writeNetworkOrderUint16(msg[6:8], uint16(requestedExternalPort))
-	writeNetworkOrderUint32(msg[8:12], uint32(lifetime))
-	response, err := n.rpc(msg, 16)
-	if err != nil {
-		return
-	}
-	result = &AddPortMappingResult{}
-	result.SecondsSinceStartOfEpoc = readNetworkOrderUint32(response[4:8])
-	result.InternalPort = readNetworkOrderUint16(response[8:10])
-	result.MappedExternalPort = readNetworkOrderUint16(response[10:12])
-	result.PortMappingLifetimeInSeconds = readNetworkOrderUint32(response[12:16])
-	return
-}
-
-func (n *Client) rpc(msg []byte, resultSize int) (result []byte, err error) {
-	var server net.UDPAddr
-	server.IP = n.gateway
-	server.Port = nAT_PMP_PORT
-	conn, err := net.DialUDP("udp", nil, &server)
-	if err != nil {
-		return
-	}
-	defer conn.Close()
-
-	result = make([]byte, resultSize)
-
-	needNewDeadline := true
-
-	var tries uint
-	for tries = 0; tries < nAT_TRIES; {
-		if needNewDeadline {
-			err = conn.SetDeadline(time.Now().Add((nAT_INITIAL_MS << tries) * time.Millisecond))
-			if err != nil {
-				return
-			}
-			needNewDeadline = false
-		}
-		_, err = conn.Write(msg)
-		if err != nil {
-			return
-		}
-		var bytesRead int
-		var remoteAddr *net.UDPAddr
-		bytesRead, remoteAddr, err = conn.ReadFromUDP(result)
-		if err != nil {
-			if err.(net.Error).Timeout() {
-				tries++
-				needNewDeadline = true
-				continue
-			}
-			return
-		}
-		if !remoteAddr.IP.Equal(n.gateway) {
-			log.Printf("Ignoring packet because IPs differ:", remoteAddr, n.gateway)
-			// Ignore this packet.
-			// Continue without increasing retransmission timeout or deadline.
-			continue
-		}
-		if bytesRead != resultSize {
-			err = fmt.Errorf("unexpected result size %d, expected %d", bytesRead, resultSize)
-			return
-		}
-		if result[0] != 0 {
-			err = fmt.Errorf("unknown protocol version %d", result[0])
-			return
-		}
-		expectedOp := msg[1] | 0x80
-		if result[1] != expectedOp {
-			err = fmt.Errorf("Unexpected opcode %d. Expected %d", result[1], expectedOp)
-			return
-		}
-		resultCode := readNetworkOrderUint16(result[2:4])
-		if resultCode != 0 {
-			err = fmt.Errorf("Non-zero result code %d", resultCode)
-			return
-		}
-		// If we got here the RPC is good.
-		return
-	}
-	err = fmt.Errorf("Timed out trying to contact gateway")
-	return
-}
-
-func writeNetworkOrderUint16(buf []byte, d uint16) {
-	buf[0] = byte(d >> 8)
-	buf[1] = byte(d)
-}
-
-func writeNetworkOrderUint32(buf []byte, d uint32) {
-	buf[0] = byte(d >> 24)
-	buf[1] = byte(d >> 16)
-	buf[2] = byte(d >> 8)
-	buf[3] = byte(d)
-}
-
-func readNetworkOrderUint16(buf []byte) uint16 {
-	return (uint16(buf[0]) << 8) | uint16(buf[1])
-}
-
-func readNetworkOrderUint32(buf []byte) uint32 {
-	return (uint32(buf[0]) << 24) | (uint32(buf[1]) << 16) | (uint32(buf[2]) << 8) | uint32(buf[3])
-}

Godeps/_workspace/src/github.com/mattn/go-colorable/colorable_others.go

@@ -1,16 +0,0 @@
-// +build !windows
-
-package colorable
-
-import (
-	"io"
-	"os"
-)
-
-func NewColorableStdout() io.Writer {
-	return os.Stdout
-}
-
-func NewColorableStderr() io.Writer {
-	return os.Stderr
-}

Godeps/_workspace/src/github.com/mattn/go-isatty/README.md

@@ -1,37 +0,0 @@
-# go-isatty
-
-isatty for golang
-
-## Usage
-
-```go
-package main
-
-import (
-	"fmt"
-	"github.com/mattn/go-isatty"
-	"os"
-)
-
-func main() {
-	if isatty.IsTerminal(os.Stdout.Fd()) {
-		fmt.Println("Is Terminal")
-	} else {
-		fmt.Println("Is Not Terminal")
-	}
-}
-```
-
-## Installation
-
-```
-$ go get github.com/mattn/go-isatty
-```
-
-# License
-
-MIT
-
-# Author
-
-Yasuhiro Matsumoto (a.k.a mattn)

Godeps/_workspace/src/github.com/mattn/go-isatty/isatty_windows.go

@@ -1,19 +0,0 @@
-// +build windows
-// +build !appengine
-
-package isatty
-
-import (
-	"syscall"
-	"unsafe"
-)
-
-var kernel32 = syscall.NewLazyDLL("kernel32.dll")
-var procGetConsoleMode = kernel32.NewProc("GetConsoleMode")
-
-// IsTerminal return true if the file descriptor is terminal.
-func IsTerminal(fd uintptr) bool {
-	var st uint32
-	r, _, e := syscall.Syscall(procGetConsoleMode.Addr(), 2, fd, uintptr(unsafe.Pointer(&st)), 0)
-	return r != 0 && e == 0
-}

Godeps/_workspace/src/github.com/mattn/go-runewidth/.travis.yml

@@ -1,9 +0,0 @@
-language: go
-go:
-  - tip
-before_install:
-  - go get github.com/axw/gocov/gocov
-  - go get github.com/mattn/goveralls
-  - go get golang.org/x/tools/cmd/cover
-script:
-    - $HOME/gopath/bin/goveralls -repotoken lAKAWPzcGsD3A8yBX3BGGtRUdJ6CaGERL

Godeps/_workspace/src/github.com/mattn/go-runewidth/README.mkd

@@ -1,25 +0,0 @@
-go-runewidth
-============
-
-[![Build Status](https://travis-ci.org/mattn/go-runewidth.png?branch=master)](https://travis-ci.org/mattn/go-runewidth)
-[![Coverage Status](https://coveralls.io/repos/mattn/go-runewidth/badge.png?branch=HEAD)](https://coveralls.io/r/mattn/go-runewidth?branch=HEAD)
-
-Provides functions to get fixed width of the character or string.
-
-Usage
------
-
-```go
-runewidth.StringWidth("つのだ☆HIRO") == 12
-```
-
-
-Author
-------
-
-Yasuhiro Matsumoto
-
-License
--------
-
-under the MIT License: http://mattn.mit-license.org/2013