Lisp on The VikiD Truth

with-output-to-string

Sun, 09 Apr 2023 22:39:59 +0400

commonlisp | Functions | with-output-to-string

with-output-to-string

External Link: Macro WITH-OUTPUT-TO-STRING.

The macro WITH-OUTPUT-TO-STRING can be used to create a string output stream, and return the resulting string at the end.

with-output-to-string (var &optional string-form &key element-type)
declaration* form*

=> result*

element-type specifier is defaulted to character.
form* is implicit progn

with-output-to-string creates a character output stream and performs a series of operation that output to the result. automatically closed on exit side effect: the string is modified

Common Lisp Functions

Sun, 09 Apr 2023 22:28:42 +0400

Functions | with-output-to-string

Common Lisp Functions

The truth about functions in Common Lisp: a function is an object, and a name is just one of many ways to reach it. Once you separate “the function” from “the symbol that names it”, the strange-looking #' and funcall suddenly make perfect sense.

What it is, in plain words

A Common Lisp function is a first-class object that takes arguments and returns zero or more values. You create named ones with defun and anonymous ones with lambda:

Common Lisp

Tue, 23 Aug 2022 01:36:02 +0400

Common Lisp

Here is the truth that took me years to see: Common Lisp is not an old language that refused to die – it’s a living system that was finished early. It was standardised in 1994, and code written then still runs unchanged today on fast, native-code compilers. Few languages can say that.

Racket

Wed, 17 Aug 2022 01:06:30 +0400

Racket

Racket is an evolution of the Scheme Language. A Scheme with Batteries and more. Read R6RS Scheme Specs. It always helps.

Initial Grammar

 program ::= {expr | test | def}*
 def ::= (define <variable name> expr)
 test ::= (check-expect expr expr)
 expr ::= string
 ::= number
 ::= (<function> expr*)
 ::= <variable name>
 string ::= "<character>"
 number ::= positive
 ::= negative
 positive ::= mag
 negative ::= -mag
 mag ::= int
 ::= real
 ::= fraction
 int ::= digit*
 digit ::= 0|1|2|3|4|5|6|7|8|9
 real ::= digit*.digit*
 fraction ::= int/nonzero-int
non-zeroint::= <1|2|3|4|5|6|7|8|9>int

DrRacket

If using DrRacket as an IDE. You can get auto-complete while typing “ctrl-/”

Input / Output IO

Sat, 28 Aug 2021 07:09:06 +0400

Input / Output IO

Here is the truth about I/O in PicoLisp: everything is a stream or a list of characters, and the same functions that print to your terminal can print into a socket, a file or a string. Once you meet in, out and prin, the rest is composition.

new

Sat, 28 Aug 2021 06:47:27 +0400

new

(new ['flg|num] ['typ ['any ..]]) -> obj

Creates and returns a new object.

If flg is given and non-NIL, the new object will be an external symbol (created in database file 1 if T, or in the corresponding database file if num is given).

typ (typically a list of classes) is assigned to the VAL, and the initial T message is sent with the arguments any to the new object.

box

Sat, 28 Aug 2021 06:45:21 +0400

Computing | Picolisp | ASM | Pil Tutorials |

box

Here is the truth about box in PicoLisp: it is a tiny mutable cell – a cons whose purpose is to hold something that changes while the identity of the cell stays put. When you need a shared, updatable place without inventing a class, you reach for a box.

What it is, in plain words

(box Val) creates a new cell with Val as its value. Access and update with val and set (or related patterns). Because PicoLisp is dynamically typed and list-oriented, a box is often enough where another language would demand an object or an IORef.

The Vikid PicoLisp Tutorial

Thu, 26 Aug 2021 01:17:21 +0400

The Vikid PicoLisp Tutorial

Start picolisp

$ pil +

Set some values

(setq A '(This is the value)) # Set the value of 'A'

(put 'A 'key1 'val1) # Store property 'key1'

(put 'A 'key2 'val2) # and 'key2'

inspect them with ‘show’

(show 'A) # Now 'show' the symbol 'A'

(put 'B 'a 'A) # Put 'A' under the 'a'-property of 'B'

(setq Lst '(A B C)) # Create a list with 'B' as second argument

(show Lst 2 'a) # Show the property 'a of the 2nd element of 'Lst'

using vi and v.

vers.h

Thu, 29 Jun 2017 02:06:42 +0400

vers.h

Here is the truth about versioning shell helpers: a tiny wrapper that prints versions of the tools you actually use saves more time than it has any right to. When something breaks after an update, “what am I running?” should be a one-liner.

Picolisp Tutorials

Sat, 24 Jun 2017 03:42:32 +0400

Picolisp Tutorials

Here is the truth about learning PicoLisp: the language is small enough that tutorials can take you from zero to a working app without a 900-page book. The hard part is not syntax – it is trusting that lists, symbols and a handful of forms really are enough.

Find Boxes in Lists

Wed, 21 Jun 2017 13:31:50 +0400

Find Boxes in Lists

Here is the truth about finding boxes on a network: most “discovery” is just asking politely which doors are open, then writing down who answers. The skill is doing it thoroughly, quietly enough for the context, and only where you have permission.

What it is, in plain words

Finding boxes means enumerating live hosts and interesting services on a network – the first phase of any lab, inventory or authorised penetration test. Tools range from a single ping to full-fat scanners like nmap. On a home LAN it is how you remember which Pi has which IP; on an engagement it is how you build the map.

pmap

Sun, 04 Dec 2016 04:11:39 +0400

linuxtools

pmap

The truth about a running program’s memory is that it isn’t one big block – it’s a patchwork map of regions, each with its own purpose and permissions. pmap prints that map.

What it is, in plain words

pmap (from the procps-ng package, installed almost everywhere) reports the memory map of a process: every region of virtual address space it has, how big each is, what permissions it has (read, write, execute), and what backs it – a file like /usr/lib/libc.so.6, the heap, the stack, or anonymous memory.

Scheme

Wed, 30 Nov 2016 08:50:15 +0400

Scheme

I am partial to scheme, I always really appreciated it.

 (define (max-of-list lst)
 (foldr max (first lst) (rest lst)))

R6RS - Revision 6 Scheme Standard

Programming languages should be designed not by piling feature on top of feature, but by removing the weaknesses and restrictions that make additional features appear necessary. Scheme demonstrates that a very small number of rules for forming expressions, with no restrictions on how they are composed, suffice to form a practical and efficient programming language that is flexible enough to support most of the major … Read more.

Picolisp Databases

Wed, 30 Nov 2016 08:06:23 +0400

Picolisp Databases

Here is the truth about PicoLisp’s database: it is not a bolt-on library – it is the language’s own object system, made durable. Entities and relations are first-class, transactions are built in, and there is no ORM because you never leave Lisp.

Picolisp ASM

Sat, 26 Nov 2016 11:39:51 +0400

Picolisp ASM

 CPU Registers:

 +---+---+---+---+---+---+---+---+
 | A | B | \\ [A]ccumulator
 +---+---+---+---+---+---+---+---+ D [B]yte register
 | C | / [C]ount register
 +---+---+---+---+---+---+---+---+ [D]ouble register
 | E | [E]xpression register
 +---+---+---+---+---+---+---+---+

 +---+---+---+---+---+---+---+---+
 | X | [X] Index register
 +---+---+---+---+---+---+---+---+ [Y] Index register
 | Y | [Z] Index register
 +---+---+---+---+---+---+---+---+
 | Z |
 +---+---+---+---+---+---+---+---+

 +---+---+---+---+---+---+---+---+
 | L | [L]ink register
 +---+---+---+---+---+---+---+---+ [S]tack pointer
 | S |
 +---+---+---+---+---+---+---+---+

 +-------------------------------+
 | [z]ero [s]ign [x,b,c]arry | [F]lags
 +-------------------------------+

 Source Addressing Modes:
 ld A 1234 # Immediate
 ld A "(a+b-c)"
 ld A R # Register
 ld A Global # Direct
 ld A (R) # Indexed
 ld A (R 8) # Indexed with offset
 ld A (R OFFS)
 ld A (R Global)
 ld A (Global) # Indirect
 ld A (Global OFFS) # Indirect with offset
 ld A ((R)) # Indexed indirect
 ld A ((R 8)) # Indexed with offset indirect
 ld A ((R 8) OFFS)
 ld A ((R Global) OFFS)
 ld A ((R OFFS) Global)
 ...

 Destination Addressing Modes:
 ld R A # Register
 ld (R) A # Indexed
 ld (R 8) A # Indexed with offset
 ld (R OFFS) A
 ld (R Global) A
 ld (Global) A # Indirect
 ld (Global OFFS) A # Indirect with offset
 ld ((R)) A # Indexed indirect
 ld ((R 8)) A # Indexed with offset indirect
 ld ((R 8) OFFS) A
 ld ((R Global) OFFS) A
 ld ((R OFFS) Global) A
 ...

 Target Addressing Modes:
 jmp 1234 # Absolute
 jmp Label
 jmp (R) # Indexed
 jmp (R T) # Indexed SUBR
 jmp (Global) # Indirect

========================================================================

 Instruction set:
 nop # No operation

 Move Instructions:
 ld dst src # Load 'dst' from 'src' [---]
 ld2 src # Load 'A' from two bytes 'src' (unsigned) [---]
 ld4 src # Load 'A' from four bytes 'src' (unsigned) [---]
 ldz dst src # Load if Zero 'dst' from 'src' [---]
 ldnz dst src # Load if not Zero 'dst' from 'src' [---]
 lea dst src # Load 'dst' with effective address of 'src' [---]
 st2 dst # Store two bytes from 'A' into 'dst' [---]
 st4 dst # Store four bytes from 'A' into 'dst' [---]
 xchg dst dst # Exchange 'dst's [---]
 movn dst src cnt # Move 'cnt' bytes from 'src' to 'dst' (non-overlapping or src < dst)
 mset dst cnt # Set 'cnt' bytes of memory to B
 save src end dst # Save 'src'..'end' to 'dst' (aligned, non-overlapping or src < dst)
 load dst end src # Load 'dst'..'end' from 'src' (aligned, non-overlapping)

 Arithmetics:
 add dst src # Add 'src' to 'dst' [zsc]
 addc dst src # Add 'src' to 'dst' with Carry [zsc]
 sub dst src # Subtract 'src' from 'dst' [zsb]
 subb dst src # Subtract 'src' from 'dst' with Borrow [zsb]

 inc dst # Increment 'dst' [zs.]
 dec dst # Decrement 'dst' [zs.]
 not dst # One's complement negation of 'dst' [z..]
 neg dst # Two's complement negation of 'dst' [zs.]

 and dst src # Bitwise AND 'dst' with 'src' [zs.]
 or dst src # Bitwise OR 'dst' with 'src' [zs.]
 xor dst src # Bitwise XOR 'dst' with 'src' [zs.]
 off dst src # Clear 'src' bits in 'dst' [zs.]
 test dst src # Bit-test 'dst' with 'src' [zs.]

 shl dst src # Shift 'dst' left into x-bit by 'src' bits [zsx]
 shr dst src # Shift 'dst' right into x-bit by 'src' bits [zsx]
 rol dst src # Rotate 'dst' left by 'src' bits [...]
 ror dst src # Rotate 'dst' right by 'src' bits [...]
 rxl dst src # Rotate 'dst' with x-bit left by 'src' bits [zsx]
 rxr dst src # Rotate 'dst' with x-bit right by 'src' bits [zsx]

 mul src # Multiplication of 'A' and 'src' into 'D' [...]
 div src # Division of 'D' by 'src' into 'A', 'C' [...]

 zxt # Zero-extend 'B' to 'A' [...]
 eq # Set Zero and clear Borrow [z._]
 gt # Clear Zero and Borrow [_._]
 lt # Clear Zero and set Borrow [_.b]
 setx # Set x-bit [--x]
 clrx # Clear x-bit [--_]

 Comparisons:
 cmp dst src # Compare 'dst' with 'src' [zsc]
 cmpn dst src cnt # Compare 'cnt' bytes 'dst' with 'src' [z..]
 slen dst src # Set 'dst' to the string length of 'src' [...]
 memb src cnt # Find B in 'cnt' bytes of 'src' memory [z..]
 null src # Compare 'src' with 0 [zs_]
 nulp src # Check 'src' for null-pointer [z..]
 nul4 # Compare four bytes in 'A' with 0 [zs_]

 Byte addressing:
 set dst src # Set 'dst' byte to 'src' [---]
 nul src # Compare byte 'src' with 0 [z..]

 Types:
 cnt src # Non-'z' if small number [z..]
 big src # Non-'z' if bignum [z..]
 num src # Non-'z' if number [z..]
 sym src # Non-'z' if symbol [z..]
 atom src # Non-'z' if atom [z..]

 Floating point:
 ldd # Load double value pointed to by 'C'
 ldf # Load float value pointed to by 'C'
 fixnum # Convert double with scale 'E' to fixnum in 'E'
 float # Convert fixnum with scale 'A' pointed to by 'X'
 std # Store double value at address 'Z'
 stf # Store float value at address 'Z'

 Flow control:
 jmp adr # Jump to 'adr' [---]
 jz adr # Jump to 'adr' if Zero [---]
 jnz adr # Jump to 'adr' if not Zero [---]
 js adr # Jump to 'adr' if Sign [---]
 jns adr # Jump to 'adr' if not Sign [---]
 jc adr # Jump to 'adr' if Carry set [---]
 jnc adr # Jump to 'adr' if Carry not set [---]
 jb adr # Jump to 'adr' if Borrow set [---]
 jnb adr # Jump to 'adr' if Borrow not set [---]
 jx adr # Jump to 'adr' if x-bit set [---]
 jnx adr # Jump to 'adr' if x-bit not set [---]

 call adr # Call 'adr'
 cc adr(src ..) # C-Call to 'adr' with 'src' arguments
 cc adr reg # C-Call to 'adr' with top of stacked args in 'reg'

 ret # Return [---]
 catch # Prepare non-local jump [---]
 throw # Resolve non-local jump [---]
 func # Convert 'E' to function pointer
 begin # Called from foreign function
 return # Return to foreign function

 Stack Manipulations:
 push src # Push 'src' [---]
 pop dst # Pop 'dst' [---]
 tos dst # Get return entry [---]
 link # Setup frame [---]
 tuck src # Extend frame [---]
 drop # Drop frame [---]

 Evaluation:
 eval # Evaluate expression in 'E'
 eval+ # Evaluate expression in partial stack frame
 eval/ret # Evaluate expression and return
 exec reg # Execute lists in 'reg', ignore results
 prog reg # Evaluate expressions in 'reg', return last result

 System:
 initData # Init runtime data
 initCode # Init runtime code
 initMain # Command in X, arguments in Y, last pointer in Z
 initLib # Library function pointer in A
 stop # Stop (system-dependent)

========================================================================

 Naming conventions:

 Lisp level functions, which would be all of the form 'doXyzE_E', are written
 as 'doXyz' for brevity.

The Picolisp Machine

Fri, 25 Nov 2016 22:39:56 +0400

The Picolisp Machine

One of the key features of the picolisp language is that high-level constructs of the language directly map to the underlying machinery, making the whole system both understandable and predictable.

Also please note that there are still a number of possible errors in this Document, it is under active development

Data Types

These are the fundamental datatypes in Picolisp:

PicoLisp

Thu, 12 May 2016 01:09:25 +0400

PicoLisp

If you have always been interested in Lisp and its variant forms such as **Common Lisp, Scheme, Racket, newLISP and the like, I think that you are really going to love Picolisp.

The original 32 bit implementation is written in C, and supports 32bit programming. Over the years the language has grown and is now available in 64 bit. The really cool things is this time the language is implemented by a [assembler written in picolisp](http://software-lab.de/doc64/asm generic). The picolisp website has all the documentation that you need to get setup and running. It also has an extensive tutorial on the language. So you can get started there.