Lisp links thread

[gilesgoat]

Has anyone ever wrote an .ASM in LISP *hint* *hint*.

Yes.

Can you show me an example/LISP source of some project like that ?

I'd love to see "a practical example of stuff I suppose should come lovely in LISP".

[tufty]

http://common-lisp.net/cgi-bin/viewcvs. ... &view=auto

[gilesgoat]

http://common-lisp.net/cgi-bin/viewcvs.cgi/movitz/asm-x86.lisp?rev=1.39&root=movitz&view=auto

Now that is something interesting to study.

Still .. I mean looking at the complexity of the whole thing .. ( looked at all the other sources as well ) still it escapes me
"a little" .. well hum ..

HUM ..

[teamonkey]

"LISP" .. "Lists Processor" or such .. ok ..

Suppose, because I really would love to understand/see "how clever is LISP" and in theory I'd say "this is the kind of
stuff LISP should be done for" .. suppose I ask you to write a LISP program that does this :

1. Given a string of ASCII chars
2. Given a list, a set of strings of ascii chars, let's say N strings present (i.e. like ( "Apple","Cherry","Banana","Nut" ) )

The problem : "return a list of tokens in range 0 .. N-1 or '-1' if not found in the tokens list ".

This means :

1. Parse the string doing a "word count" skipping white spaces and such.
2. For each for check if the word is present in "List" and if so get the corresponding index
3. Output an "array" ? ( list ? ) with the numbers you found

The input is a string (a data stream) and an indexed array, and the output is an indexed array of array indices. Not linked lists! Strings and arrays (vectors) are secondary data types in scheme whereas in C they are fundamental. So this example doesn't really show off scheme's strengths, more it's weaknesses.

In reality you'd use a library function to parse the string. Also, as I've said before, Scheme's string handling sucks balls. Common Lisp and Clojure are lisps that have loads of useful string features. I'm going to cheat and assume that you've got the first 10 words in a list.

Code: Select all

#lang scheme

(define word-list '("Apple" "Cherry" "Banana" "Nut"))
(define input-words '("Banana" "Monkey" "Banana" "Apple" "Monkey" "Nut" "Cherry" "Monkey" "Banana" "Nut"))

; Return the index of val in list or -1 if not found - note that there's usually a library function for this too
(define (find-index lst val start-index)
  (if (pair? lst)    ; is it a list node? if not we've reached the end of the list
      (if (equal? (car lst) val)  ; (car lst) is the data that the list node lst contains
          start-index
          (find-index (cdr lst) val (+ 1 start-index))) ; recurse - (cdr lst) is the next list node
      -1))  ; not found

; Program proper
(map
 (lambda (word)
   (find-index word-list word 0))
 input-words)
;> (2 -1 2 0 -1 3 1 -1 2 3)

[tufty]

http://common-lisp.net/cgi-bin/viewcvs. ... &view=auto

Now that is something interesting to study.

Still .. I mean looking at the complexity of the whole thing .. ( looked at all the other sources as well ) still it escapes me
"a little" .. well hum ..

HUM ..

An "easier" example to understand might be the picolisp source. The 64 bit version is written in a 64-bit pseudo-assembler, which itself runs on picolisp. Turtles all the way down, baby*. That little mindfuck out of the way, though, the the assmbler instruction set is found here :

http://software-lab.de/doc64/asm

and the assembler itself can be found by uncompressing the source found here http://software-lab.de/picoLisp-3.0.4.tgz and looking at src64/lib/asm.l

Examples of the assembler syntax and so on can be found throughout the src64 directory,

*well, all the way down to the 64-bit platform native implementation of the gnu assembler, anyway.

[adam]

http://www.pugo.org:8080/

a postscript web server (nothing to do with lisp)

[tufty]

Ahhh, ps-httpd. The project that inspired me to write my postscript "make any given huge graphic self-tile on any paper size" wrapper.

I'm not sure I'd even understand it now, postscript may be turing complete but it makes for terrifyingly impenetrable code when you've walked away from it for a bit. Where "a bit" might be considered to be any span of time longer than it takes the kettle to boil.

[adam]

[adam]

implementing ruby in common lisp:
http://jng.imagine27.com/articles/2010- ... ation.html

[failrate]

LISP can be as nice or scary as the programmer writing it. I wrote a 2d shmup engine in Scheme, and it was easier than the equivalent C++ code for me. You can determine from the source if I am nice or scary http://www.shmup-dev.com/forum/index.php?topic=1193.0 http://failrate.com/b/voidSniper_source_release_1.zip

[tufty]

Nice work. I'd probably go for lispbuilder-sdl, these days. http://code.google.com/p/lispbuilder/.

[tufty]

Came across this a couple of days ago, it's a nice scripting language based on Lisp with a lot of the cruft cut away. If nothing else, it's worth looking at for its memory management technique, which I've not seen before, and which claims to be deterministic, with no pauses for gc.

http://www.newlisp.org/

[zip accident]

Came across this a couple of days ago,

http://www.newlisp.org/

Interesting, how are they funded?

[tufty]

Buggered if I know. The bloke that wrote it appears to be some sort of "consultant", which job title can be used to describe an awful lot of things, not all of which are profitable.

It's GPLed, with regular tarballs above and beyond any binary releases, but the source repo doesn't appear to be public. I posit that it's (currently) a more-or-less hobby project. That said, Ruby was a hobby project for Matz for the first few years, so that's not necessarily a bad thing.

[Dio]

Depending on who he consults for, the funding could easily be "A few months work at £1000/day then the rest of the year for my own projects."