{"id":944,"date":"2018-06-10T11:12:24","date_gmt":"2018-06-10T05:42:24","guid":{"rendered":"http:\/\/www.rangakrish.com\/?p=944"},"modified":"2018-06-10T13:17:31","modified_gmt":"2018-06-10T07:47:31","slug":"calling-lisp-functions-from-go-language","status":"publish","type":"post","link":"https:\/\/www.rangakrish.com\/index.php\/2018\/06\/10\/calling-lisp-functions-from-go-language\/","title":{"rendered":"Calling Lisp Functions from Go Language"},"content":{"rendered":"

In the previous post<\/a>, we saw how to invoke a Go<\/strong><\/em> function from Lisp<\/strong><\/em>. In today’s post, I would like to explain how to go in the other direction, namely, how to call Lisp<\/strong><\/em> functins from Go<\/strong><\/em>.<\/p>\n

There are two ways to do this. The first approach is to load the Lisp<\/strong><\/em> DLL (like any other DLL) in Go<\/strong><\/em> and make calls to functions in that DLL. The other, preferred approach, is to use a LIB (“.o”<\/strong><\/em>) file to statically bind to the DLL functions. Let me show both the approaches.<\/p>\n

Building the Lisp DLL<\/b><\/h2>\n

Let us start with the Lisp side. As in the previous article, I am using LispWorks Lisp<\/strong><\/em><\/a> (Windows – 64 bit) for the demo.\u00a0<\/span><\/p>\n

Here is a simple function that adds two 64-bit integers and returns the corresponding value:<\/p>\n

(fli:define-foreign-callable (“addIntLisp” :language :ansi-c :result-type :int64 :calling-convention :cdecl)<\/span><\/p>\n

\u00a0 \u00a0 <\/span>( (arg1 :int64) (arg2 :int64) )\u00a0 \u00a0<\/span><\/span><\/p>\n

\u00a0 <\/span>(+ arg1 arg2))<\/span><\/p>\n

define-foreign-callable<\/strong><\/em> enables a Lisp function to be called from a foreign language, in this case, Go<\/strong><\/em>. Let us suppose that this function is defined in the file Exported Functions.lisp<\/strong><\/em>. Now we have to compile this function (plus the necessary Lisp runtime) into a DLL.<\/p>\n

We create another file called Generate DLL.lisp<\/strong><\/em> with the following code:<\/p>\n

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

(load-all-patches)<\/span><\/p>\n

(compile-file “Exported Functions.lisp”)<\/span><\/p>\n

(load “Exported Functions”)<\/span><\/p>\n

(defun dummy ())<\/span><\/p>\n

(compile ‘dummy)<\/span><\/p>\n

(deliver #’dummy\u00a0“Lisp-functions”\u00a01\u00a0:startup-bitmap-file nil\u00a0:keep-eval t\u00a0:keep-load-function t\u00a0:dll-exports ‘(“addIntLisp”))<\/span><\/span><\/p>\n

\u00a0<\/span>(quit)<\/span><\/p>\n

I urge you to lookup the documentation of deliver<\/strong><\/em> function to understand the different parameters.\u00a0<\/span><\/p>\n

We are now ready to generate the DLL. Open a Command prompt<\/strong><\/em> and switch to the directory where these two files are located. Then run:<\/p>\n

>\u00a0 <\/span>“C:\\Program Files\\LispWorks7.1\\lispworks-7-1-0-x64-windows.exe” -build “Generate DLL.lisp”<\/span><\/p>\n

This will result in a file called Lisp-functions.Dll<\/strong><\/em> in the current directory. We need this file to use with our Go program.<\/p>\n

Using the DLL in Go<\/b><\/h2>\n

Approach-1a (Using the DLL directly):<\/span><\/p>\n

Here we use syscall.LoadLibrary()<\/strong><\/em> function in Go<\/strong><\/em> to load our DLL, followed by a call to syscall.GetProcAddress()<\/strong><\/em> to get the address of the desired function within the DLL. Finally, we use syscall.Syscall()<\/strong><\/em> to call into the loaded function and get the result. See the image below:<\/p>\n

\"Direct<\/a>
Direct DLL Call<\/strong><\/figcaption><\/figure>\n

You can see a deferred<\/strong><\/em> call to a function named QuitLispWorks<\/strong><\/em>. This is the recommended way to terminate the LispWorks Lisp runtime as part of unloading the DLL. To run the Go program, do this:<\/p>\n

\u00a0> go run LispCall.go<\/span><\/p>\n

Approach-1b (Using the DLL directly):<\/span><\/p>\n

There is a simpler way to load the DLL and call its functions. This is shown below:<\/p>\n

\"Direct<\/a>
Direct DLL Call 2<\/strong><\/figcaption><\/figure>\n

I wanted to show both approaches for the sake of documentation, but I guess most developers would prefer the simpler variant.\u00a0To run the Go program, do this:<\/p>\n

\u00a0> go run LispCall2.go<\/span><\/p>\n

Approach-2 (Using “.o”<\/strong> file):<\/span><\/p>\n

If you have the LIB file corresponding to the DLL, along with the C header for the exported functions, then calling Lisp functions via the DLL becomes much easier.<\/p>\n

Since LispWorks does not create the LIB file as part of DLL generation, I looked around for some utility to generate the LIB from the DLL. Fortunately, I remembered that Embarcadero’s RAD Studio comes with implib<\/strong><\/em> utility, so I used it thus:<\/p>\n

> implib Lisp-functions.o Lisp-functions.dll<\/span><\/p>\n

Note that the LIB file is named “.o”<\/strong><\/em> for compatibility with Go<\/strong><\/em> build system.<\/p>\n

I then created the Header file manually:<\/p>\n

#ifndef __LISP_FUNCTIONS_H__<\/span><\/p>\n

#define __LISP_FUNCTIONS_H__<\/span><\/p>\n

long addIntLisp(long arg1, long arg2);<\/span><\/p>\n

int __stdcall QuitLispWorks(int Force , int MilliTimeOut);<\/span><\/p>\n

#endif<\/span><\/p>\n

Here is the Go program (LispCall3.go<\/strong><\/em>) that calls the Lisp function:<\/p>\n

\"Lisp<\/a>
Lisp Call via LIB<\/strong><\/figcaption><\/figure>\n

Take note of the comments before import “C”<\/strong><\/em>. These are required.<\/p>\n

For the second approach, we have the following files:<\/p>\n

– Lisp-functions.dll<\/span><\/p>\n

– Lisp-functions.o<\/span><\/p>\n

– Lisp-functions.h<\/span><\/p>\n

– LispCall3.go<\/span><\/p>\n

To build the Go<\/strong><\/em> executable from these files, run:<\/p>\n

> go build LispCall3.go<\/span><\/p>\n

This creates LispCall3.exe<\/strong><\/em>. We have to distribute our DLL along with the executable if we are planning to run the program elsewhere. To run the program, enter:<\/p>\n

\u00a0> LispCall3<\/span><\/p>\n

Lisp addInt: 300<\/span><\/p>\n

Good, the program works as expected! That completes today’s discussion on how to call LispWorks Lisp<\/strong><\/em> functions from Go<\/strong><\/em>. You can download the relevant files here<\/a>.<\/p>\n

Although I have not tried, I think the procedure should be similar for other Lisp environments on Windows.<\/p>\n

Hope you found today’s post useful.<\/p>\n","protected":false},"excerpt":{"rendered":"

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 the Lisp DLL (like any […]<\/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":[142,19,99],"class_list":["post-944","post","type-post","status-publish","format-standard","hentry","category-golang","category-lisp","category-programming","tag-go-language","tag-lisp","tag-lispworks"],"jetpack_publicize_connections":[],"jetpack_featured_media_url":"","jetpack_sharing_enabled":true,"jetpack_shortlink":"https:\/\/wp.me\/p9OLnF-fe","jetpack-related-posts":[{"id":2645,"url":"https:\/\/www.rangakrish.com\/index.php\/2021\/12\/25\/calling-lisp-functions-from-d-language\/","url_meta":{"origin":944,"position":0},"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":3017,"url":"https:\/\/www.rangakrish.com\/index.php\/2023\/02\/16\/calling-external-dll-functions-from-julia\/","url_meta":{"origin":944,"position":1},"title":"Calling External DLL Functions from Julia","author":"admin","date":"February 16, 2023","format":false,"excerpt":"Julia supports calling external functions, especially those written in \u201cC\u201d language. As Julia documentation says, such calls do not involve any \u201cboilerplate\u201d code and hence are efficient. In today\u2019s article, I am going to show how to call functions defined in a DLL (Windows 64 bit). Instead of using direct\u2026","rel":"","context":"In "Julia"","block_context":{"text":"Julia","link":"https:\/\/www.rangakrish.com\/index.php\/category\/julia\/"},"img":{"alt_text":"The \"lispEval\" Function","src":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2023\/02\/code-300x117.jpg?resize=350%2C200&ssl=1","width":350,"height":200,"srcset":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2023\/02\/code-300x117.jpg?resize=350%2C200&ssl=1 1x, https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2023\/02\/code-300x117.jpg?resize=525%2C300&ssl=1 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":944,"position":2},"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":928,"url":"https:\/\/www.rangakrish.com\/index.php\/2018\/05\/27\/calling-go-functions-from-lisp\/","url_meta":{"origin":944,"position":3},"title":"Calling Go Functions from Lisp","author":"admin","date":"May 27, 2018","format":false,"excerpt":"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\u2026","rel":"","context":"In "Golang"","block_context":{"text":"Golang","link":"https:\/\/www.rangakrish.com\/index.php\/category\/golang\/"},"img":{"alt_text":"Part of Header File","src":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2018\/05\/Header-file.png?resize=350%2C200","width":350,"height":200,"srcset":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2018\/05\/Header-file.png?resize=350%2C200 1x, https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2018\/05\/Header-file.png?resize=525%2C300 1.5x"},"classes":[]},{"id":2057,"url":"https:\/\/www.rangakrish.com\/index.php\/2020\/07\/19\/calling-lisp-functions-from-elixir\/","url_meta":{"origin":944,"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":944,"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\/944","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=944"}],"version-history":[{"count":0,"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/posts\/944\/revisions"}],"wp:attachment":[{"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/media?parent=944"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/categories?post=944"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/tags?post=944"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}