{"id":928,"date":"2018-05-27T07:19:53","date_gmt":"2018-05-27T01:49:53","guid":{"rendered":"http:\/\/www.rangakrish.com\/?p=928"},"modified":"2018-06-06T14:00:38","modified_gmt":"2018-06-06T08:30:38","slug":"calling-go-functions-from-lisp","status":"publish","type":"post","link":"https:\/\/www.rangakrish.com\/index.php\/2018\/05\/27\/calling-go-functions-from-lisp\/","title":{"rendered":"Calling Go Functions from Lisp"},"content":{"rendered":"

For the past few weeks I was travelling in the USA and had the pleasure of meeting several friends, some of whom are senior developers and architects. It was interesting to learn that many of them were either using Go<\/strong><\/em> language<\/a> in their daily work, or were passionately endorsing the language! Due to lack of time, I had not looked at the language so far, but having returned to Chennai, I decided to devote some time to learning the language. After going through the basic language features, which definitely impress me for their simplicity and uniformity, I wanted to see how I could interface Go<\/strong><\/em> with my other favourite language, Lisp<\/strong><\/em>. That is the focus of today’s post. Please note that I am not going to discuss the language in any detail; there are several good books and tutorials for that.<\/p>\n

There are two parts to interfacing Go<\/strong><\/em> with Lisp<\/strong><\/em> – calling Go<\/strong><\/em> from Lisp<\/strong><\/em> and vice versa. Today, I will describe calling Go<\/strong><\/em> from Lisp<\/strong><\/em>. The other direction, namely from Go<\/strong><\/em> to Lisp<\/strong><\/em>,\u00a0 <\/span>will be part of a future article.<\/p>\n

What makes mixing Go<\/strong><\/em> with other languages possible is that there is a well-defined procedure for interfacing Go<\/strong><\/em> with C<\/strong><\/em>. So any language that can interoperate with C<\/strong><\/em>, can technically interact with Go<\/strong><\/em> as well.<\/p>\n

I found this article<\/a>\u00a0to be a good starting point.<\/p>\n

A brief description about my dev environment is in order here. I am using Windows 10<\/strong><\/em> and my Lisp is LispWorks (64 bit) Enterprise Edition<\/strong><\/em><\/a>. There are several IDEs for Go<\/strong><\/em> but I chose Atom<\/strong><\/em><\/a> with two plug-ins: go-plus<\/strong><\/em> (Go<\/strong><\/em> package) and platformio-ide-terminal<\/strong><\/em> (Terminal<\/strong><\/em> package). The latter facilitates building and running Go<\/strong><\/em> from the IDE. As part of installing Go<\/strong><\/em> system on my Windows<\/strong><\/em>, I configured the GOPATH<\/strong><\/em> environment variable to point to my Go<\/strong><\/em> workspace directory. Finally, although I use Microsoft Visual Studio<\/strong><\/em> for my C++<\/strong><\/em> development, I stuck with GCC<\/strong><\/em> (as part of MinGW<\/strong><\/em>) for the purpose of this project.<\/p>\n

I decided to keep the code very minimal because the focus is not on the language itself. So here is the Go<\/strong><\/em> program that exports<\/strong><\/em> a function called addInt<\/strong><\/em> to be called by another language, in this case, Lisp<\/strong><\/em>.<\/p>\n

package main<\/span><\/div>\n
<\/div>\n
<\/div>\n
import “C”<\/span><\/div>\n
<\/div>\n
<\/div>\n
\/\/export addInt<\/span><\/div>\n
func addInt(a, b int64) int64 {<\/span><\/div>\n
return a + b<\/span><\/div>\n
}<\/span><\/div>\n
<\/div>\n
<\/div>\n
func main() {<\/span><\/div>\n
}<\/span><\/div>\n

Two things are quite important here:<\/p>\n

1) You have to include import “C”<\/strong><\/em> (C<\/strong><\/em> is called a pseudo package)<\/p>\n

2) The functions that need to be exported should have \/\/export <function name><\/strong><\/em> annotation before their definition. Note also that there is no space after “<\/strong>\/\/”<\/strong><\/em>.<\/p>\n

I explicitly used int64<\/strong><\/em> as the argument and return type to make sure the code works correctly across the language boundaries (my Lisp is also 64 bit). Other than this, there is nothing else to explain in the code. The source file is Example.go<\/strong><\/em> and is saved under “..\\Go Projects\\src\\C-export\\”<\/strong><\/em> directory (“Go Projects”<\/strong><\/em> is my workspace directory, pointed to by GOPATH<\/strong><\/em> environment variable).<\/p>\n

The next step is to compile this file. Run the following command from a separate command prompt or from the IDE terminal:<\/p>\n

> go build -o Example.lib -buildmode=c-shared Example.go<\/span><\/p>\n

This will generate Example.lib<\/strong><\/em> and Example.h<\/strong><\/em>. The header file contains several Go<\/strong><\/em> to C<\/strong><\/em> type mappings, and the exported function signature. The following figure shows a part of the emitted file:<\/p>\n

\"Part<\/a>
Part of Header File<\/strong><\/figcaption><\/figure>\n

What next? If we want to call this function from a C<\/strong><\/em> program, it is enough to link Example.lib<\/strong><\/em> with the rest of the C<\/strong><\/em> code. However, we want to call this function from Lisp<\/strong><\/em>. LispWorks<\/strong><\/em> (on Windows) supports calling foreign language functions, as long as they are bundled as a DLL<\/strong><\/em>. Since there is no way (that I know of) to compile the Go<\/strong><\/em> module into a DLL<\/strong><\/em>, we need another layer. We define a C<\/strong><\/em> file that acts as a stub\/wrapper for the actual Go<\/strong><\/em> function, and compile this file into a DLL<\/strong><\/em>. Note this introduces an additional function call overhead, but that seems unavoidable.<\/p>\n

Here is the stub file Example-wrapper.c<\/strong><\/em>:<\/p>\n

#include “Example.h”<\/span><\/p>\n

__declspec(dllexport) GoInt64 addIntWrapper(GoInt64 a, GoInt64 b){<\/span>
\n\u00a0 \u00a0 \u00a0 \u00a0return addInt(a, b);<\/span>
\n}<\/span><\/p>\n

Note the __declspec(dllexport)<\/strong><\/em> decoration on the stub function. This is needed to export the function in our DLL<\/strong><\/em>. Also, as a good practice (even though it is not required for use with LispWorks<\/strong><\/em>), we declare the exported function in a separate header file Example-wrapper.h<\/strong><\/em>.<\/p>\n

Now we can compile this file into a DLL<\/strong><\/em>, linking it with Example.lib<\/strong><\/em>:<\/p>\n

\u00a0 \u00a0 <\/span>> gcc -c Example-wrapper.c<\/span><\/p>\n

\u00a0 \u00a0 <\/span>> gcc -shared -o Example-wrapper.dll Example-wrapper.o Example.lib<\/span><\/p>\n

It is a good idea to make sure the DLL<\/strong><\/em> contains our exported function. I used the tool dllexp-x64<\/strong><\/em><\/a> for this purpose. See the screen shot:<\/p>\n

\"DLL<\/a>
DLL Viewer<\/strong><\/figcaption><\/figure>\n

For use in another language environment, we have to distribute the files Example.lib<\/strong><\/em>, and Example-wrapper.dll<\/strong><\/em>. For use with a C\/C++<\/strong><\/em> program, we also need Example.h<\/strong><\/em> and Example-wrapper.h<\/strong><\/em>.<\/p>\n

Let us now come to the LispWorks<\/strong><\/em> part. Calling foreign functions (on Windows<\/strong><\/em> platform, defined in a DLL<\/strong><\/em> ) is fairly straightforward. Here is the code:<\/p>\n

(in-package “CL-USER”)<\/span><\/p>\n

(hcl:change-directory “G:\/LispWorks Projects\/Ranga\/Golang\/Interfacing with Go”)<\/span>
\n(fli:register-module “Example-wrapper.DLL”)<\/span><\/p>\n

(fli:define-foreign-function (add-int-wrapper “addIntWrapper” :source)<\/span>
\n\u00a0 \u00a0 ((x :int64)<\/span>
\n\u00a0 \u00a0 (y :int64))<\/span>
\n\u00a0 \u00a0 :result-type :int64<\/span>
\n\u00a0 \u00a0 :language :ansi-c)<\/span><\/p>\n

(defun test-go-function (arg1 arg2)<\/span>
\n\u00a0 \u00a0 (declare (int64 arg1) (int64 arg2))<\/span>
\n\u00a0 \u00a0 (format t “Sum of ~d and ~d is: ~d~%” arg1 arg2 (add-int-wrapper arg1 arg2)))<\/span><\/p>\n

Since we have copied Example.lib<\/strong><\/em> and Example-wrapper.dll<\/strong><\/em> to the current project directory, we switch to that directory (otherwise it is necessary to include the\u00a0DLL<\/strong><\/em> location in PATH<\/strong><\/em> environment variable). The function define-foreign-function<\/strong><\/em> allows us to declare the signature of the foreign function, in this case, the wrapper function available in the DLL<\/strong><\/em>. You can see that I have declared the parameters and return type as int64<\/strong><\/em> so that it is consistent with the Go<\/strong><\/em> function signature.<\/p>\n

The function test-go-functio<\/strong><\/em>n calls our wrapper function to compute the result. The wrapper, in turn, calls the actual Go<\/strong><\/em> function. That is it!<\/p>\n

We can evaluate this expression to see the result:<\/p>\n

CL-USER 1 > (test-go-function 250 350)<\/span><\/p>\n

Sum of 250 and 350 is: 600<\/span><\/p>\n

NIL<\/span><\/p>\n

Perfect! Works as expected.<\/p>\n

Hope I have explained in sufficient detail the process of calling Go<\/strong><\/em> function from LispWorks<\/strong><\/em>. There could be minor differences with respect to other Lisp environments, but it should not be hard to get things working.<\/p>\n

Please note that calls across language runtime boundaries are fairly expensive, so they should be used only if justified. For me, Go<\/strong><\/em> is a new language in my toolkit, and I really enjoyed learning it!<\/p>\n

Have fun!<\/p>\n","protected":false},"excerpt":{"rendered":"

For the past few weeks I was travelling in the USA and had the pleasure of meeting several friends, some of whom are senior developers and architects. It was interesting to learn that many of them were either using Go language in their daily work, or were passionately endorsing the language! Due to lack of […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"advanced_seo_description":"","jetpack_seo_html_title":"","jetpack_seo_noindex":false,"_jetpack_newsletter_access":"","_jetpack_dont_email_post_to_subs":false,"_jetpack_newsletter_tier_id":0,"_jetpack_memberships_contains_paywalled_content":false,"_jetpack_memberships_contains_paid_content":false,"footnotes":"","jetpack_publicize_message":"","jetpack_publicize_feature_enabled":true,"jetpack_social_post_already_shared":true,"jetpack_social_options":{"image_generator_settings":{"template":"highway","default_image_id":0,"font":"","enabled":false},"version":2},"jetpack_post_was_ever_published":false},"categories":[141,18,17],"tags":[143,142,19,99],"class_list":["post-928","post","type-post","status-publish","format-standard","hentry","category-golang","category-lisp","category-programming","tag-foreign-functions","tag-go-language","tag-lisp","tag-lispworks"],"jetpack_publicize_connections":[],"jetpack_featured_media_url":"","jetpack_sharing_enabled":true,"jetpack_shortlink":"https:\/\/wp.me\/p9OLnF-eY","jetpack-related-posts":[{"id":2927,"url":"https:\/\/www.rangakrish.com\/index.php\/2022\/10\/20\/why-learn-lisp\/","url_meta":{"origin":928,"position":0},"title":"Why Learn Lisp?","author":"admin","date":"October 20, 2022","format":false,"excerpt":"In the last article, I had shared my views on why programmers should learn Prolog, preferably as the first language. What language should one learn next? I strongly pitch for Lisp, to be precise, \u201cCommon Lisp\u201d. Lisp happens to be the second oldest (1958) programming language, only after Fortran (1957)!\u2026","rel":"","context":"In "LISP"","block_context":{"text":"LISP","link":"https:\/\/www.rangakrish.com\/index.php\/category\/lisp\/"},"img":{"alt_text":"","src":"","width":0,"height":0},"classes":[]},{"id":2645,"url":"https:\/\/www.rangakrish.com\/index.php\/2021\/12\/25\/calling-lisp-functions-from-d-language\/","url_meta":{"origin":928,"position":1},"title":"Calling Lisp Functions from D Language","author":"admin","date":"December 25, 2021","format":false,"excerpt":"After exploring \"newLisp\" in the past few posts, I would like to start looking at the \"D Programming Language\"\u00a0(DLang). DLang\u00a0has been around since 2001. It was originally created by Walter Bright and later Andrei Alexandrescu joined the team in 2007. The main inspiration for DLang was C++, although it uses\u2026","rel":"","context":"In "D Language"","block_context":{"text":"D Language","link":"https:\/\/www.rangakrish.com\/index.php\/category\/d-language\/"},"img":{"alt_text":"Lisp Function Called from D","src":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2021\/12\/Lisp-300x107.jpg?resize=350%2C200&ssl=1","width":350,"height":200,"srcset":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2021\/12\/Lisp-300x107.jpg?resize=350%2C200&ssl=1 1x, https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2021\/12\/Lisp-300x107.jpg?resize=525%2C300&ssl=1 1.5x"},"classes":[]},{"id":944,"url":"https:\/\/www.rangakrish.com\/index.php\/2018\/06\/10\/calling-lisp-functions-from-go-language\/","url_meta":{"origin":928,"position":2},"title":"Calling Lisp Functions from Go Language","author":"admin","date":"June 10, 2018","format":false,"excerpt":"In the previous post, we saw how to invoke a Go function from Lisp. In today's post, I would like to explain how to go in the other direction, namely, how to call Lisp functins from Go. There are two ways to do this. The first approach is to load\u2026","rel":"","context":"In "Golang"","block_context":{"text":"Golang","link":"https:\/\/www.rangakrish.com\/index.php\/category\/golang\/"},"img":{"alt_text":"Direct DLL Call","src":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2018\/06\/LispCall.png?resize=350%2C200","width":350,"height":200,"srcset":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2018\/06\/LispCall.png?resize=350%2C200 1x, https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2018\/06\/LispCall.png?resize=525%2C300 1.5x"},"classes":[]},{"id":963,"url":"https:\/\/www.rangakrish.com\/index.php\/2018\/06\/24\/calling-go-functions-from-lisp-part-2\/","url_meta":{"origin":928,"position":3},"title":"Calling Go Functions from Lisp – Part 2","author":"admin","date":"June 24, 2018","format":false,"excerpt":"In my earlier article Calling Go Functions from Lisp, I explained the steps for making calls to Go functions from another language, specifically LispWorks Lisp. Today, I want to give a slightly more\u00a0 interesting example showing the use of Go channels\u00a0through exported functions. Go is widely admired for its native\u2026","rel":"","context":"In "Golang"","block_context":{"text":"Golang","link":"https:\/\/www.rangakrish.com\/index.php\/category\/golang\/"},"img":{"alt_text":"Go Functions","src":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2018\/06\/Go-Functions.png?resize=350%2C200","width":350,"height":200},"classes":[]},{"id":2057,"url":"https:\/\/www.rangakrish.com\/index.php\/2020\/07\/19\/calling-lisp-functions-from-elixir\/","url_meta":{"origin":928,"position":4},"title":"Calling Lisp Functions from Elixir","author":"admin","date":"July 19, 2020","format":false,"excerpt":"In the last article\u00a0I showed how we can simulate the idea of Lisp's \"closure\" in Elixir. Today, I would like to demonstrate how we can call Lisp functions from Elixir using the NIF interface. What is the need to integrate Elixir with another language? I can think of two reasons:\u2026","rel":"","context":"In "Elixir"","block_context":{"text":"Elixir","link":"https:\/\/www.rangakrish.com\/index.php\/category\/elixir\/"},"img":{"alt_text":"Using the Lisp Functions","src":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2020\/07\/Session.jpg?resize=350%2C200&ssl=1","width":350,"height":200,"srcset":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2020\/07\/Session.jpg?resize=350%2C200&ssl=1 1x, https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2020\/07\/Session.jpg?resize=525%2C300&ssl=1 1.5x, https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2020\/07\/Session.jpg?resize=700%2C400&ssl=1 2x"},"classes":[]},{"id":3070,"url":"https:\/\/www.rangakrish.com\/index.php\/2023\/04\/02\/building-v-language-dll\/","url_meta":{"origin":928,"position":5},"title":"Building V Language DLL","author":"admin","date":"April 2, 2023","format":false,"excerpt":"The relatively new V Programming Language (Vlang) boasts of some interesting features such as \u201cfast compilation\u201d and runtime performance \u201cas fast as C\u201d, at the same time being a \u201csimple language\u201d. As I normally do with other languages that I learn and use, I decided to see how easy it\u2026","rel":"","context":"In "Programming"","block_context":{"text":"Programming","link":"https:\/\/www.rangakrish.com\/index.php\/category\/programming\/"},"img":{"alt_text":"V Program","src":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2023\/04\/V-source-267x300.jpg?resize=350%2C200&ssl=1","width":350,"height":200},"classes":[]}],"_links":{"self":[{"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/posts\/928","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/comments?post=928"}],"version-history":[{"count":0,"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/posts\/928\/revisions"}],"wp:attachment":[{"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/media?parent=928"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/categories?post=928"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/tags?post=928"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}