id
int64 0
45.1k
| file_name
stringlengths 4
68
| file_path
stringlengths 14
193
| content
stringlengths 32
9.62M
| size
int64 32
9.62M
| language
stringclasses 1
value | extension
stringclasses 6
values | total_lines
int64 1
136k
| avg_line_length
float64 3
903k
| max_line_length
int64 3
4.51M
| alphanum_fraction
float64 0
1
| repo_name
stringclasses 779
values | repo_stars
int64 0
882
| repo_forks
int64 0
108
| repo_open_issues
int64 0
90
| repo_license
stringclasses 8
values | repo_extraction_date
stringclasses 146
values | sha
stringlengths 64
64
| __index_level_0__
int64 0
45.1k
| exdup_ids_cmlisp_stkv2
sequencelengths 1
47
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
18,652 | racollector | hbock_periscope/racollector | #!/bin/bash
# Periscope - Network auditing tool
# Copyright (C) 2009 Harry Bock <[email protected]>
# This file is part of Periscope.
# periscope is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
# periscope 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 General Public License for more details.
# You should have received a copy of the GNU General Public License
# along with periscope; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
# Simple script wrapping rabins/rasplit for use with Periscope.
# Syntax:
# racollector tinderbox.oshean.lan 1h "reports/hourly/h.%Y%m%d-%H"
#
# Called from Lisp using EXECUTE-COMMAND.
# To stop, simply raise SIGINT to this process.
rabins=$(which ${PREFIX}rabins)
rasplit=$(which ${PREFIX}rasplit)
error_message()
{
[ -n "$1" ] && echo $1 >&2
}
usage()
{
error_message "Usage: $0 argus-server time-period output-format"
exit 2
}
if [ ! -x $rabins ] && [ ! -x $rasplit ]; then
error_message "Error: rabins/rasplit not found. Please install argus-clients!"
exit 3
fi
# Check arguments - none can be empty.
if [ -z "$1" ] || [ -z "$2" ] || [ -z "$3" ]; then usage; fi
sighandler()
{
# Find all child processes of this script ($$)...
for pid in $(ps -ef | awk "\$3 == $$ { print \$2 }")
do
# ...and kill them dead. Gracefully, of course :)
kill -TERM $pid &> /dev/null
done
exit 0
}
# We only send SIGTERM from Periscope, but best be safe.
trap sighandler SIGINT SIGTERM SIGHUP
# Run rabins/rasplit pipe as a job - we need to do this so we will
# actually trap SIGTERM. If we don't, bash will wait until rabins/rasplit
# finish before invoking the trap handler.
$rabins -S $1 -M time $2 -B 20s -w - | $rasplit -M time $2 -w "$3" &
# Busy wait while rabins/rasplit run. Sleep momentarily to yield the processor.
# This is a hack, I know.
# The handler may not be called immediately - it will be called in-between invocations
# of 'sleep 0.5' below... bash must wait until running child processes complete before
# handling any pending signals. Which is why this hack is needed in the first place!
while [ 1 ]; do
sleep 0.5
# Check to see if the child processes exited; if so, abort with error code 4.
if ! ps -p ${!} &> /dev/null; then
exit 4;
fi
done
exit 0
| 2,654 | Common Lisp | .l | 67 | 37.522388 | 86 | 0.713175 | hbock/periscope | 3 | 0 | 0 | GPL-2.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 7023dfea55e3846fac1ae61aec8c0b21575ca24d04701ff2c63568db01770b0c | 18,652 | [
-1
] |
18,656 | Makefile | hbock_periscope/lisp/Makefile | # Find suitable lisp for building Periscope.
ifeq (${LISP},)
ifeq ($(strip $(shell which clbuild)),)
LISP = sbcl
else
LISP = clbuild lisp
endif
endif
all: periscope
# TODO: Make this portable across Lisp implementations.
periscope: *.lisp
${LISP} --load "build.lisp" --eval "(build-periscope)"
@echo "Build complete!"
clean:
rm -f *.fasl *~ periscope
| 371 | Common Lisp | .l | 15 | 22.4 | 55 | 0.708215 | hbock/periscope | 3 | 0 | 0 | GPL-2.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 7b15dc1807ec997015c4998efc93a84f8e405885c9f2b16e0fc99c067207da4d | 18,656 | [
-1
] |
18,688 | package.lisp | ex7763_oxalis/src/package.lisp | ;;;; package.lisp
(defpackage #:oxalis
(:use #:cl+qt #:alexandria)
(:export :main))
(in-package #:oxalis)
(defparameter *application-root* (asdf:system-source-directory :oxalis))
(defparameter *images-directory* (merge-pathnames #P"images/" *application-root*))
(defparameter *figure-images-directory* (merge-pathnames #P"figure/" *images-directory*))
(defparameter *config-file* (merge-pathnames ".oxalis" *application-root*))
;; 初始化亂數，每次產生不同的亂數
(setf *random-state* (make-random-state t))
| 529 | Common Lisp | .lisp | 11 | 43.636364 | 89 | 0.745868 | ex7763/oxalis | 3 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | cda695d524abcdcbc823a8b5f6d09b4ad60452fa0a3018cc453e120404e45116 | 18,688 | [
-1
] |
18,689 | oxalis.lisp | ex7763_oxalis/src/oxalis.lisp | ;;;; oxalis.lisp
(in-package #:oxalis)
(in-readtable :qtools)
(defvar *qmessagebox-yes* 16384) ;; (#_QMessageBox::Yes)
(defvar *qmessagebox-no* 65536) ;; (#_QMessageBox::No)
(defvar *window-height* 128)
(defvar *window-width* 128)
(defvar *window-flags* (logior
(enum-value (#_Qt::FramelessWindowHint))))
;; (enum-value (#_Qt::ToolTip))))
(defvar *window-icon* (namestring
(merge-pathnames "oxalis.png" *images-directory*)))
(defvar *figure-image* (namestring
(merge-pathnames "shime0.png" *figure-images-directory*)))
(defvar *figure-frame* 0)
(defvar *figure-mirrored* nil)
(defclass figure ()
((m-pressed :initform nil :accessor m-pressed)
(m-point-x :accessor m-point-x)
(m-point-y :accessor m-point-y)
(figure-animate-timer :accessor figure-animate-timer)
(auto-move-timer :accessor auto-move-timer)
(walkingp :initform nil :accessor walkingp)
(walking-point-x :accessor walking-point-x)
(walking-point-y :accessor walking-point-y)
(menu :accessor menu)
(act-about :accessor act-about)
(act-walking :accessor act-walking)
(act-quit :accessor act-quit)
(menu-config :initform (make-instance 'menu-config) :accessor menu-config)
(tray :accessor tray)
)
(:metaclass qt-class)
(:qt-superclass "QWidget")
(:slots
("figure_animate()" figure-animate)
("show_about_msg()" show-about-msg)
("auto_walking(bool)" auto-walking)
("auto_walking_move()" auto-walking-move))
(:override ("mousePressEvent" mouse-press-event)
("mouseMoveEvent" mouse-move-event)
("mouseReleaseEvent" mouse-release-event)
("contextMenuEvent" context-menu-event)
("paintEvent" paint-event)))
(defmethod initialize-instance :after ((instance figure) &key)
(new instance)
(let ((window-icon (#_new QIcon *window-icon*)))
(#_setWindowTitle instance "oxalis")
(#_setWindowIcon instance window-icon)
(#_resize instance *window-height* *window-width*)
;;; 使視窗無邊框、透明
(#_setWindowFlags instance (logior *window-flags*
(enum-value (#_Qt::WindowStaysOnTopHint))))
(#_setAttribute instance (enum-value (#_Qt::WA_TranslucentBackground)))
(#_setWindowOpacity instance 1.0)
;;; 初始化物件
;; Timer
(setf (figure-animate-timer instance) (#_new QTimer instance))
(setf (auto-move-timer instance) (#_new QTimer instance))
;; Menu
(setf (menu instance) (#_new QMenu instance))
(setf (act-about instance) (#_new QAction =about= (menu instance)))
(setf (act-walking instance) (#_new QAction =auto-walking= (menu instance)))
(setf (act-quit instance) (#_new QAction =quit= (menu instance)))
;; 設定是否可勾選
(#_setCheckable (act-walking instance) t)
(#_setChecked (act-walking instance) nil)
;; 加進 menu
(#_addAction (menu instance) (act-about instance))
(#_addAction (menu instance) (act-walking instance))
(#_addMenu (menu instance) (menu-config instance)) ; config-menu
(#_addAction (menu instance) (act-quit instance))
;; Tray
(setf (tray instance) (#_new QSystemTrayIcon instance))
(#_setIcon (tray instance) window-icon)
(#_setToolTip (tray instance) "oxalis")
(#_show (tray instance)) ; tray 不會主動顯示
(#_setContextMenu (tray instance) (menu instance))
(#_setParent (tray instance) instance)
; (#_delete (tray instance))
;;; 連接信號
;; Timer
(connect (figure-animate-timer instance) "timeout()" instance "figure_animate()")
(connect (auto-move-timer instance) "timeout()" instance "auto_walking_move()")
;; Menu
(connect (act-about instance) "triggered()" instance "show_about_msg()")
(connect (act-quit instance) "triggered()" instance "close()")
(connect (act-walking instance) "triggered(bool)" instance "auto_walking(bool)")
))
;; 移動的動畫，每次換不同的圖片
(defun figure-animate (instance)
(setf *figure-frame* (mod (1+ *figure-frame*) 3))
(setf *figure-image* (namestring
(merge-pathnames (format nil "shime~A.png" *figure-frame*)
*figure-images-directory*)))
(#_repaint instance))
;; 隨機移動
(defun auto-walking (instance bool)
(if bool
(progn
(#_showMessage (tray instance) "oxalis" =auto-walking-start= (#_QSystemTrayIcon::Information) 3000) ; 顯示訊息
(setf (walkingp instance) t)
;; 隨機走到一個點
(setf (walking-point-x instance)
(random (#_width (#_desktop *qapplication*))))
(setf (walking-point-y instance)
(random (#_height (#_desktop *qapplication*))))
;; 移動的影格 16/1000 = 0.016 ~= 60fps
(#_start (auto-move-timer instance) 16)
;; 開始走路的動畫
(#_start (figure-animate-timer instance) 300))
(progn
(#_showMessage (tray instance) "oxalis" =auto-walking-stop= (#_QSystemTrayIcon::Information) 3000) ; 顯示訊息
(#_stop (auto-move-timer instance))
(#_stop (figure-animate-timer instance)))))
(defun walking-arrow (num)
(if (> num 0)
-1
(if (< num 0)
1
0)))
(defun auto-walking-move (instance)
(let ((x (- (#_x (#_pos instance)) (walking-point-x instance)))
(y (- (#_y (#_pos instance)) (walking-point-y instance)))
)
;; (format t "~A ~A~%" x y) ; 顯示離目標位置差多遠
(when (= x y 0)
(setf (walkingp instance) nil)
)
(if (> (walking-arrow x) 0)
(setf *figure-mirrored* t)
(setf *figure-mirrored* nil))
(if (walkingp instance)
(progn
(#_move instance
(+ (#_x (#_pos instance))
(walking-arrow x))
(+ (#_y (#_pos instance))
(walking-arrow y)))
)
;; p=1/200，根據幾何分佈
;; 期望值為(16/1000)*(200)=3.2s 前往一個新的點，其他時間不動
(when (= (random 200) 0)
(setf (walkingp instance) t)
(setf (walking-point-x instance)
(random (#_width (#_desktop *qapplication*))))
(setf (walking-point-y instance)
(random (#_height (#_desktop *qapplication*))))))))
;; mouse-press-event, mouse-move-event, mouse-release-event 主要處理移動視窗的功能
(defmethod mouse-press-event ((instance figure) event)
(when (equalp (enum-value (#_button event)) (enum-value (#_Qt::LeftButton)))
(setf (m-pressed instance) t)
(setf (m-point-x instance) (#_x (#_pos event)))
(setf (m-point-y instance) (#_y (#_pos event)))))
(defmethod mouse-move-event ((instance figure) event)
(let ((event-y (#_y (#_pos event)))
(event-x (#_x (#_pos event)))
(instance-x (#_x (#_pos instance)))
(instance-y (#_y (#_pos instance))))
(when (m-pressed instance)
(#_move instance (+ event-x instance-x (- (m-point-x instance)))
(+ event-y instance-y (- (m-point-y instance)))))))
(defmethod mouse-release-event ((instance figure) event)
(setf (m-pressed instance) nil))
;; 右鍵的菜單
(defmethod context-menu-event ((instance figure) event)
;; 顯示位置
(#_move (menu instance) (#_pos (#_cursor instance)))
(#_show (menu instance)))
(defun show-about-msg (instance)
(let ((system (asdf:find-system :oxalis)))
(#_QMessageBox::about
instance
=about=
(format nil
"~a<br />
The source code is licensed under ~a.<br />
<br />
~a: <a href=\"~a~:*\">~a</a><br />
~a: ~a<br />
~a: ~a"
=description=
(asdf:system-license system)
=homepage=
(asdf:system-homepage system)
=author=
=author-name=
=version=
(asdf:component-version system)))))
;; 畫出人物圖片
(defmethod paint-event ((instance figure) event)
(let* ((painter (#_new QPainter))
(image (#_new QImage *figure-image*))
(pixel))
; (#_save image *figure-image* "PNG") ; 轉換成 Qt 接受的 png 格式
(when *figure-mirrored*
(setf image (#_mirrored image t nil)))
(setf pixel (#_QPixmap::fromImage image))
(#_begin painter instance)
(#_drawPixmap painter 0 0 pixel)
(#_end painter)
))
(defun main()
(make-qapplication)
(with-objects ((example (make-instance 'figure)))
(#_show example)
(#_exec *qapplication*)))
| 8,566 | Common Lisp | .lisp | 207 | 33.024155 | 114 | 0.609313 | ex7763/oxalis | 3 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 30ad8432366907d3a048a221fcfb71aede12c1ee4ebece36e193ca4c35263e5f | 18,689 | [
-1
] |
18,690 | lang.lisp | ex7763_oxalis/src/lang.lisp | (in-package #:oxalis)
;; Support list:
;; 繁體中文 :traditional-chinese
;; English :english
(defparameter ==language== :traditional-chinese)
;; config.lisp
(defvar =config=)
(defvar =all-config=)
;; oxalis.lisp
(defvar =about=)
(defvar =description=)
(defvar =homepage=)
(defvar =author=)
(defvar =author-name=)
(defvar =version=)
(defvar =auto-walking=)
(defvar =auto-walking-start=)
(defvar =auto-walking-stop=)
(defvar =quit=)
(alexandria:switch
(==language== :test 'equal)
(:traditional-chinese
;; config.lisp
(setf =config= "設定"
=all-config= "全部設定")
;; oxalis.lisp
(setf =about= "關於"
=description= "用 common lisp 跟 Qt4 做的桌面寵物"
=homepage= "主頁"
=author= "作者"
=author-name= "許博鈞"
=version= "版本"
=auto-walking= "自動走路"
=auto-walking-start= "開始自動走路"
=auto-walking-stop= "停止自動走路"
=quit= "離開"))
(:english
;; config.lisp
(setf =config= "Config"
=all-config= "All config")
;; oxalis.lisp
(setf =about= "About"
=description= "A Desktop pet is written in common lisp and Qt4."
=homepage= "Homepage"
=author= "Author"
=author-name= "Hsu, Po-Chun"
=version= "Version"
=auto-walking= "Auto walking"
=auto-walking-start= "Auto walking start"
=auto-walking-stop= "Auto walking stop"
=quit= "Quit")))
| 1,463 | Common Lisp | .lisp | 51 | 22.215686 | 72 | 0.625 | ex7763/oxalis | 3 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 7adc47b61349f3f018c24fccaef9163088f4841eb0a347ef898cc42edfa7e580 | 18,690 | [
-1
] |
18,691 | config.lisp | ex7763_oxalis/src/config.lisp | (in-package #:oxalis)
(in-readtable :qtools)
(defclass menu-config ()
((act-all :accessor act-all)
)
(:metaclass qt-class)
(:qt-superclass "QMenu")
(:slots
("menu_config_page()" menu-config-page)))
(defmethod initialize-instance :after ((instance menu-config) &key)
(new instance)
(#_setTitle instance =config=)
;; 初始化變數
(setf (act-all instance) (#_new QAction =all-config= instance))
;; 加進 menu
(#_addAction instance (act-all instance))
;; 連接訊號
(connect (act-all instance) "triggered()" instance "menu_config_page()")
)
(defun menu-config-page (instance)
(let* ((page (#_new QWidget instance))
(width 450)
(height 600)
(desktop (#_desktop *qapplication*))
(current-monitor (#_screenNumber desktop instance))
(desktop-size (#_screenGeometry desktop current-monitor))
(layout (#_new QGridLayout))
(box-language (#_new QComboBox)))
(#_setWindowFlags page (enum-value (#_Qt::Window)))
(#_setWindowTitle page "Config")
;(#_resize page width height)
;; (x, y) 是螢幕左上角，在多螢幕中的位置，width, height 是現在這個螢幕的大小
(#_move page
(- (+ (#_x desktop-size)
(floor (#_width desktop-size) 2))
(floor width 2))
(- (+ (#_y desktop-size)
(floor (#_height desktop-size) 2))
(floor height 2)))
(#_setLayout page layout)
(#_addWidget layout (#_new QLabel "<h1>All Configuration</h1>") 1 0 1 3)
(#_addWidget layout (#_new QLabel "Always on top") 2 0)
(#_addWidget layout (#_new QCheckBox) 2 1)
(#_addWidget layout (#_new QLabel "Language") 2 2)
(#_addWidget layout box-language 2 3)
(#_addItem box-language "Traditional Chinese")
(#_addItem box-language "English")
(#_show page)))
;; 直接取代原本的設定檔
(defun config-write-settings (ht &optional (file *config-file*))
(with-open-file (out file
:direction :output
:if-exists :supersede)
(maphash #'(lambda (key value)
(format out "'~A' : '~A';~%" key value))
ht)))
;; 目前沒有錯誤檢查功能，設定檔格式必須完全正確
(defun config-read-settings (&optional (file *config-file*))
(let ((str (read-file-into-string file)))
(config-parse-settings str)
))
;; 返回一個 hash-table ， key 是設定的項目， value 是設定的值
(defun config-parse-settings (str)
(let ((ht (make-hash-table :test 'equalp)))
(mapcar #'(lambda (parsed)
(setf (gethash (first parsed) ht) (second parsed)))
(mapcar #'(lambda (line)
(config-parse-line line))
(ppcre:all-matches-as-strings "'.*;" str)))
ht))
(defun config-parse-line (line)
(mapcar #'(lambda (token)
(subseq token 1 (1- (length token))))
(ppcre:all-matches-as-strings "'.*?'" line)))
| 3,010 | Common Lisp | .lisp | 74 | 31.148649 | 76 | 0.596427 | ex7763/oxalis | 3 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 2892ceb028a407a439497f2a67aed4ea1a08dfd22859533184a79ba4a43fa41c | 18,691 | [
-1
] |
18,692 | oxalis.asd | ex7763_oxalis/oxalis.asd | ;;;; oxalis.asd
(asdf:defsystem #:oxalis
:description "A Desktop pet is written in common lisp and Qt4."
:author "Hsu, Po-Chun"
:homepage "https://github.com/ex7763/oxalis"
:license "GPLv3"
:version "0.1.2"
:serial t
:defsystem-depends-on (:qtools)
:depends-on (:qtcore
:qtgui
:qtopengl
:uiop
:alexandria)
:components ((:module "src"
:components ((:file "package")
(:file "lang")
(:file "config")
(:file "oxalis"))))
:build-operation "qt-program-op"
:build-pathname "oxalis"
:entry-point "oxalis:main")
| 723 | Common Lisp | .asd | 22 | 21.909091 | 65 | 0.503566 | ex7763/oxalis | 3 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | d4466919cf4a66e9a51c24d53bdfcd8ef3770dbba5c5de49b450265530096b1a | 18,692 | [
-1
] |
18,695 | .travis.yml | ex7763_oxalis/.travis.yml | language: common-lisp
sudo: false
env:
global:
- PATH=~/.roswell/bin:$PATH
- ROSWELL_INSTALL_DIR=$HOME/.roswell
matrix:
- LISP=sbcl-bin
install:
- curl -L https://raw.githubusercontent.com/roswell/roswell/release/scripts/install-for-ci.sh | sh
cache:
directories:
- $HOME/.roswell
- $HOME/.config/common-lisp
script:
# X server
- export DISPLAY=:99.0
- sh -e /etc/init.d/xvfb start
# Build binary
- ros -s qtools -s oxalis -e '(asdf:make :oxalis :force T)'
notifications:
email:
- [email protected] | 549 | Common Lisp | .l | 23 | 20.73913 | 100 | 0.694818 | ex7763/oxalis | 3 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | f3088a8e35910f0002ad793a1410e63522f9b17b945dfecea4da7a87a4951623 | 18,695 | [
-1
] |
18,696 | makefile | ex7763_oxalis/makefile | LISP ?= sbcl
all:
$(LISP) --eval '(ql:quickload :oxalis)' \
--eval '(oxalis:main)' \
--eval '(quit)'
add:
git add -A
push:
git push -u origin master
clean:
rm -rf *~
| 180 | Common Lisp | .l | 11 | 14.090909 | 42 | 0.612121 | ex7763/oxalis | 3 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 4439cc1b8ad989f6e2267dd82a4903a37ae2f1baa8b2939f1cb9ed07bd8eb951 | 18,696 | [
-1
] |
18,697 | oxalis.svg | ex7763_oxalis/images/oxalis.svg | <?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!-- Created with Inkscape (http://www.inkscape.org/) -->
<svg
xmlns:dc="http://purl.org/dc/elements/1.1/"
xmlns:cc="http://creativecommons.org/ns#"
xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
xmlns:svg="http://www.w3.org/2000/svg"
xmlns="http://www.w3.org/2000/svg"
xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
width="256"
height="256"
viewBox="0 0 67.733332 67.733335"
version="1.1"
id="svg8"
sodipodi:docname="oxalis.svg"
inkscape:version="0.92.2 2405546, 2018-03-11">
<defs
id="defs2" />
<sodipodi:namedview
id="base"
pagecolor="#ffffff"
bordercolor="#666666"
borderopacity="1.0"
inkscape:pageopacity="0.0"
inkscape:pageshadow="2"
inkscape:zoom="2.8"
inkscape:cx="114.81465"
inkscape:cy="129.34954"
inkscape:document-units="mm"
inkscape:current-layer="layer1"
showgrid="false"
units="px"
inkscape:window-width="1920"
inkscape:window-height="1013"
inkscape:window-x="1366"
inkscape:window-y="0"
inkscape:window-maximized="1" />
<metadata
id="metadata5">
<rdf:RDF>
<cc:Work
rdf:about="">
<dc:format>image/svg+xml</dc:format>
<dc:type
rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
<dc:title></dc:title>
</cc:Work>
</rdf:RDF>
</metadata>
<g
inkscape:label="Layer 1"
inkscape:groupmode="layer"
id="layer1"
transform="translate(0,-229.26665)">
<path
style="fill:#008000;fill-rule:nonzero;stroke:none;stroke-width:0.1;stroke-miterlimit:4;stroke-dasharray:none"
d="m 15.122722,240.2708 c -3.859835,2.13236 -5.2603508,6.98991 -3.128204,10.84986 2.132214,3.86015 17.086919,12.72813 20.947047,10.59588 1.570034,-0.86791 -0.695478,1.65367 0,0 1.765725,0.29094 -1.567867,0.86268 0,0 3.860011,-2.13246 3.807199,-19.23243 1.674699,-23.09243 -2.132361,-3.85983 -6.989914,-5.26035 -10.849865,-3.1282 -1.569894,0.86768 -2.80189,2.23871 -3.49745,3.89207 -1.765874,-0.29077 -3.578225,0.0201 -5.146227,0.88282 z"
id="path815"
inkscape:connector-curvature="0"
sodipodi:nodetypes="ccccccccc" />
<path
style="fill:#008000;fill-rule:nonzero;stroke:none;stroke-width:0.1;stroke-miterlimit:4;stroke-dasharray:none"
d="m 56.350397,244.32461 c -2.13236,-3.85983 -6.989912,-5.26035 -10.849867,-3.12821 -3.860153,2.13222 -12.728129,17.08692 -10.595878,20.94706 0.86791,1.57003 -1.653665,-0.69548 0,0 -0.290935,1.76572 -0.862682,-1.56787 0,0 2.132457,3.86001 19.232434,3.8072 23.092428,1.67469 3.859834,-2.13236 5.260348,-6.98991 3.128198,-10.84986 -0.867676,-1.5699 -2.238702,-2.80189 -3.892071,-3.49745 0.290772,-1.76588 -0.02013,-3.57822 -0.88281,-5.14623 z"
id="path815-6"
inkscape:connector-curvature="0"
sodipodi:nodetypes="ccccccccc" />
<path
style="fill:#008000;fill-rule:nonzero;stroke:none;stroke-width:0.1;stroke-miterlimit:4;stroke-dasharray:none"
d="m 52.122492,285.43256 c 3.859829,-2.13237 5.260343,-6.98992 3.128202,-10.84988 -2.132216,-3.86015 -17.086919,-12.72813 -20.947053,-10.59588 -1.570028,0.86791 0.695478,-1.65366 0,0 -1.765725,-0.29093 1.567866,-0.86268 0,0 -3.860009,2.13246 -3.807199,19.23244 -1.674693,23.09243 2.13236,3.85984 6.989911,5.26035 10.849866,3.12821 1.569953,-0.86757 2.801887,-2.23871 3.497448,-3.89208 1.765875,0.29077 3.57822,-0.0201 5.14623,-0.8828 z"
id="path815-6-7"
inkscape:connector-curvature="0"
sodipodi:nodetypes="ccccccccc" />
<path
style="fill:#008000;fill-rule:nonzero;stroke:none;stroke-width:0.1;stroke-miterlimit:4;stroke-dasharray:none"
d="m 10.940494,281.46146 c 2.132368,3.85983 6.98992,5.26034 10.849876,3.1282 3.860152,-2.13222 12.728128,-17.08692 10.595877,-20.94705 -0.86791,-1.57003 1.653666,0.69547 0,0 0.290935,-1.76573 0.862683,1.56786 0,0 -2.132457,-3.86001 -19.232434,-3.8072 -23.0924264,-1.6747 -3.8598351,2.13236 -5.2603492,6.98991 -3.1282081,10.84987 0.8675711,1.56995 2.2387104,2.80189 3.8920795,3.49745 -0.2907721,1.76587 0.02013,3.57822 0.882802,5.14623 z"
id="path815-6-5"
inkscape:connector-curvature="0"
sodipodi:nodetypes="ccccccccc" />
<circle
style="fill:#00ff00;fill-rule:nonzero;stroke:none;stroke-width:0.1;stroke-miterlimit:4;stroke-dasharray:none"
id="path918"
cx="33.592636"
cy="262.74588"
r="1.1811756" />
</g>
</svg>
| 4,577 | Common Lisp | .l | 87 | 46.62069 | 448 | 0.676543 | ex7763/oxalis | 3 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 4c3d5717a11bc8990429122ab80feadfb1a1441fceae8d487b2173b348ad9176 | 18,697 | [
-1
] |
18,702 | oxalis.ros | ex7763_oxalis/roswell/oxalis.ros | #!/bin/sh
#|-*- mode:lisp -*-|#
#|
exec ros -Q -- $0 "$@"
|#
(progn ;;init forms
(ros:ensure-asdf)
#+quicklisp (ql:quickload '(:oxalis) :silent t)
)
(defpackage #:ros/script/oxalis
(:use :cl))
(in-package #:ros/script/oxalis)
(defun main (&rest argv)
(declare (ignorable argv))
(oxalis:main))
;;; vim: set ft=lisp lisp:
| 334 | Common Lisp | .l | 16 | 19 | 49 | 0.629747 | ex7763/oxalis | 3 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 2a5baa5cc7100791abba7bba6b640f7bbb542a731150c4f4676b9e6d853dd380 | 18,702 | [
-1
] |
18,717 | 08.lisp | atgreen_advent-of-code-2020/08.lisp | ;;; Advent Of Code 2020 - Day 8 - Anthony Green <[email protected]>
(ql:quickload :alexandria)
(defparameter +code+ (coerce (uiop:read-file-lines "08.input") 'vector))
(defvar *completed?* nil)
(defun run-code (code)
(loop
with acc = 0
with pc = 0
while (< pc (length code))
do
(progn
(let ((insn (subseq (aref code pc) 0 3))
(op (parse-integer (subseq (aref code pc) 4))))
(setf (aref code pc) "xxx 0")
(alexandria:eswitch (insn :test #'equal)
("acc" (setf acc (+ acc op)))
("nop" t)
("jmp" (incf pc (- op 1)))
("xxx" (return acc)))
(incf pc)))
finally (return (setf *completed?* acc))))
;; Solution 1
(run-code (copy-seq +code+))
;; Solution 2
(progn
(setf *completed?* nil)
(loop
with pc = -1
while (let ((code (copy-seq +code+)))
(flet ((run-test (ignore)
(run-code code)))
(incf pc)
(not (let ((insn (subseq (aref code pc) 0 3))
(op (parse-integer (subseq (aref code pc) 4))))
(alexandria:eswitch (insn :test #'equal)
("jmp"
(let ((acc (run-test (setf (aref code pc) "nop 0"))))
(when *completed?* (return acc))))
("acc" nil)
("nop"
(let ((acc (run-test (setf (aref code pc) (format nil "jmp ~A" op)))))
(when *completed?* (return acc)))))))))))
| 1,585 | Common Lisp | .lisp | 42 | 26.47619 | 94 | 0.471391 | atgreen/advent-of-code-2020 | 3 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | eb053128a058b6c9d645f41303d98695cf77b4ac609615c02bc1a5529bae08c4 | 18,717 | [
-1
] |
18,718 | 06.lisp | atgreen_advent-of-code-2020/06.lisp | ;;; Advent Of Code 2020 - Day 6 - Anthony Green <[email protected]>
(ql:quickload :alexandria)
(ql:quickload :cl-ppcre)
;; Solution 1
(apply #'+
(mapcar
(lambda (group)
(length (remove-duplicates
(cl-ppcre:regex-replace-all "\\n" group ""))))
(cl-ppcre:split "\\n\\n"
(alexandria:read-file-into-string "06.input"))))
;; Solution 2
(apply '+
(mapcar
(lambda (group)
(length (reduce #'intersection group)))
(mapcar (lambda (group)
(mapcar (lambda (answer)
(coerce answer 'list))
(cl-ppcre:split "\\n" group)))
(cl-ppcre:split "\\n\\n"
(alexandria:read-file-into-string "06.input")))))
| 818 | Common Lisp | .lisp | 22 | 25.636364 | 81 | 0.500631 | atgreen/advent-of-code-2020 | 3 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | ee33e8856e46e78176d7a7dd08a4d851467416f8e35e1c0fec6efccd34f457cc | 18,718 | [
-1
] |
18,719 | 02.lisp | atgreen_advent-of-code-2020/02.lisp | ;;; Advent Of Code 2020 - Day 2 - Anthony Green <[email protected]>
(ql:quickload :split-sequence)
;; Problem 1
(print (count-if
(lambda (line)
(destructuring-bind (freq-min rest-of-line)
(split-sequence:split-sequence #\- line)
(flet ((in-range (n min max)
(and (>= n min) (<= n max))))
(in-range (- (count (find-if #'alpha-char-p rest-of-line) rest-of-line) 1)
(parse-integer freq-min)
(parse-integer rest-of-line :junk-allowed t)))))
(uiop:read-file-lines "02.input")))
;; Problem 2
(print (count-if
(lambda (line)
(destructuring-bind (pos1 rest-of-line)
(split-sequence:split-sequence #\- line)
(destructuring-bind (before-colon after-colon)
(split-sequence:split-sequence #\: line)
(let ((char (find-if #'alpha-char-p rest-of-line)))
(not (eq (null (eq char (aref after-colon (parse-integer pos1))))
(null (eq char (aref after-colon (parse-integer rest-of-line :junk-allowed t))))))))))
(uiop:read-file-lines "02.input")))
| 1,192 | Common Lisp | .lisp | 24 | 37.791667 | 111 | 0.551073 | atgreen/advent-of-code-2020 | 3 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 89349d6b2283462c310422df79056adaecdd3ba3fea3da8e035cbf2b8719a499 | 18,719 | [
-1
] |
18,720 | 03.lisp | atgreen_advent-of-code-2020/03.lisp | ;;; Advent Of Code 2020 - Day 3 - Anthony Green <[email protected]>
(defparameter +map+ (uiop:read-file-lines "03.input"))
(defparameter +map-max-x+ (length (car +map+)))
(defparameter +map-max-y+ (length +map+))
(defun slide (x y slope-x slope-y)
(if (< y +map-max-y+)
(+ (slide (+ x slope-x) (+ y slope-y) slope-x slope-y)
(if (eq #\# (aref (nth y +map+) (rem x +map-max-x+))) 1 0))
0))
;; Part 1
(print (slide 0 0 3 1))
;; Part 2
(print (apply '* (loop for run in '((1 . 1) (3 . 1) (5 . 1) (7 . 1) (1 . 2))
collect (slide 0 0 (car run) (cdr run)))))
| 606 | Common Lisp | .lisp | 14 | 38.714286 | 76 | 0.55102 | atgreen/advent-of-code-2020 | 3 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 1f03b5eb3baed921c4cd75b04d589c536b1c004602e21c4bc0cccedea8f1941e | 18,720 | [
-1
] |
18,721 | 04.lisp | atgreen_advent-of-code-2020/04.lisp | ;;; Advent Of Code 2020 - Day 4 - Anthony Green <[email protected]>
(ql:quickload :split-sequence)
(ql:quickload :cl-ppcre)
(defparameter +passport-data+
(append (uiop:read-file-lines "04.input") '("")))
(defstruct doc
eyr
byr
hcl
cid
ecl
hgt
iyr
pid)
(defun complete-passport (doc)
(and doc
(doc-byr doc)
(doc-iyr doc)
(doc-eyr doc)
(doc-hgt doc)
(doc-hcl doc)
(doc-ecl doc)
(doc-pid doc)))
(defparameter +four-digit-matcher+
(cl-ppcre:create-scanner "^[0-9]{4}$"))
(defparameter +nine-digit-matcher+
(cl-ppcre:create-scanner "^[0-9]{9}$"))
(defparameter +hcl-matcher+
(cl-ppcre:create-scanner "^#[0-9a-f]{6}$"))
(defparameter +hgt-in-matcher+
(cl-ppcre:create-scanner "^[0-9]+in$"))
(defparameter +hgt-cm-matcher+
(cl-ppcre:create-scanner "^[0-9]+cm$"))
(defun valid-passport (doc)
(and (complete-passport doc)
(flet ((check-year (value min max)
(and (cl-ppcre:scan +four-digit-matcher+ value)
(<= min (parse-integer value) max))))
(and (check-year (doc-byr doc) 1920 2002)
(check-year (doc-iyr doc) 2010 2020)
(check-year (doc-eyr doc) 2020 2030)))
(or (and (cl-ppcre:scan +hgt-in-matcher+ (doc-hgt doc))
(<= 59 (parse-integer (doc-hgt doc) :junk-allowed t) 76))
(and (cl-ppcre:scan +hgt-cm-matcher+ (doc-hgt doc))
(<= 150 (parse-integer (doc-hgt doc) :junk-allowed t) 193)))
(cl-ppcre:scan +hcl-matcher+ (doc-hcl doc))
(let ((pos (search (doc-ecl doc) "ambblubrngrygrnhzloth")))
(and pos (eq 0 (rem pos 3))))
(cl-ppcre:scan +nine-digit-matcher+ (doc-pid doc))))
(defvar *doc* nil)
(defvar *docs* nil)
(progn
(setf *docs* '(nil))
(setf *doc* (make-doc))
(dolist (line +passport-data+)
(if (string= "" line)
(progn
(setf *docs* (cons *doc* *docs*))
(setf *doc* (make-doc)))
(dolist (value (split-sequence:split-sequence #\SPACE line))
(let ((key-value (split-sequence:split-sequence #\: value)))
;; This is dangerous.
;; https://www.reddit.com/r/Common_Lisp/comments/k79s59/common_lisp_for_advent_of_code_2020/gevk6dr?utm_source=share&utm_medium=web2x&context=3
(eval (read-from-string
(format nil "(setf (doc-~A *doc*) ~S)"
(car key-value) (cadr key-value))))))))
;; Step 1
(print (count-if #'complete-passport *docs*))
;; Step 2
(print (count-if #'valid-passport *docs*)))
| 2,564 | Common Lisp | .lisp | 70 | 30.142857 | 148 | 0.5938 | atgreen/advent-of-code-2020 | 3 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | c8280339474ac790d2c6a739ac84c65f213ba6211abd3b59ddecb6c2e5afe17d | 18,721 | [
-1
] |
18,722 | 05.lisp | atgreen_advent-of-code-2020/05.lisp | ;;; Advent Of Code 2020 - Day 5 - Anthony Green <[email protected]>
(defparameter +seat-ids+
(labels ((sub (str slist)
(if slist
(sub (substitute (caar slist) (cdar slist) str) (cdr slist))
(parse-integer str :radix 2 :junk-allowed t))))
(mapcar (lambda (str)
(sub str '((#\1 . #\B) (#\0 . #\F) (#\1 . #\R) (#\0 . #\L))))
(uiop:read-file-lines "05.input"))))
;; Problem 1
(apply #'max +seat-ids+)
;; Problem 2
(let ((seats (coerce (sort +seat-ids+ #'<) 'vector)))
(block seat-search
(loop for seat from 1 to (length seats)
do (unless (and (eq (aref seats (- seat 1))
(- (aref seats seat) 1))
(eq (aref seats (+ seat 1))
(+ (aref seats seat) 1)))
(return-from seat-search (+ 1 (aref seats seat)))))))
| 902 | Common Lisp | .lisp | 20 | 34.15 | 77 | 0.491468 | atgreen/advent-of-code-2020 | 3 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | df1dc61aaf3fefa291a2960fbce079f5ee518659813a19375768f8d3809ef707 | 18,722 | [
-1
] |
18,723 | 01.lisp | atgreen_advent-of-code-2020/01.lisp | ;;; Advent Of Code 2020 - Day 1 - Anthony Green <[email protected]>
(ql:quickload :alexandria)
(defparameter +numbers+ (mapcar #'parse-integer (uiop:read-file-lines "01.input")))
;; Solve for steps 1 and 2 using the same mechanism...
(macrolet ((find-numbers (l)
`(block try-block
(flet ((test-fn (p)
(when (equal 2020 (apply #'+ p))
(return-from try-block (apply #'* p)))))
(alexandria:map-combinations #'test-fn +numbers+ :length ,l)))))
(print (find-numbers 2))
(print (find-numbers 3)))
| 600 | Common Lisp | .lisp | 12 | 40.166667 | 83 | 0.576068 | atgreen/advent-of-code-2020 | 3 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 9e431a0b929a0d85ea8f3037b9cde2f86fdca041ff2fc3e6c3f6fb4419702cb4 | 18,723 | [
-1
] |
18,746 | package.lisp | vsedach_simple-vhost-proxy/package.lisp | (in-package #:cl)
(defpackage #:simple-vhost-proxy
(:use #:cl #:usocket #:flexi-streams #:anaphora)
(:export #:start-proxy))
| 130 | Common Lisp | .lisp | 4 | 30.25 | 50 | 0.68 | vsedach/simple-vhost-proxy | 3 | 0 | 0 | AGPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | a96b7b49a1d08709848057bae8c68da51800884bac55b58d717610ad319f10e0 | 18,746 | [
-1
] |
18,747 | timeouts.lisp | vsedach_simple-vhost-proxy/timeouts.lisp | (in-package #:simple-vhost-proxy)
;;; borrowed from hunchentoot, but this should really go into usocket!!!
(defun set-timeout (socket timeout) ;; in seconds
#+:clisp
(socket:socket-options (usocket:socket socket)
:SO-RCVTIMEO timeout :SO-SNDTIMEO timeout)
#+:openmcl
(progn
(setf (ccl:stream-input-timeout (usocket:socket socket)) timeout
(ccl:stream-output-timeout (usocket:socket socket)) timeout))
#+:sbcl
(setf (sb-impl::fd-stream-timeout (usocket:socket-stream socket))
(coerce timeout 'single-float))
#+:cmu
(setf (lisp::fd-stream-timeout (usocket:socket-stream socket))
(coerce timeout 'integer))
#-(or :clisp :openmcl :sbcl :cmu)
(warn "Socket timeouts not implemented!")) | 757 | Common Lisp | .lisp | 18 | 36.833333 | 72 | 0.686992 | vsedach/simple-vhost-proxy | 3 | 0 | 0 | AGPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | a0b1c0b4155e3f5821f8e30a2419b5f7f2e30f632b7558bc32a97f76fe0dc351 | 18,747 | [
-1
] |
18,748 | proxy.lisp | vsedach_simple-vhost-proxy/proxy.lisp | (in-package #:simple-vhost-proxy)
(defun starts-with? (string prefix)
(when (< (length prefix) (length string))
(string= string prefix :end1 (length prefix))))
(defun maybe-header-value (header-line header)
(when (starts-with? header-line header)
(subseq header-line (length header))))
(defun crlf (out)
(write-char #\Return out) (write-char #\Newline out))
(defun process-headers (header-stream client-ip proxy-ip)
(let (host content-length forwarded-for connection)
(values
(with-output-to-string (out)
(flet ((out (&rest stuff)
(dolist (x stuff) (princ x out)) (crlf out)))
(loop with h while (setf h (read-line header-stream)) do
(progn
(acond ((string= h "")
(loop-finish))
((maybe-header-value h "Host: ")
(setf host (subseq it 0 (or (position #\: it)
(length it))))
(out h))
((maybe-header-value h "Content-Length: ")
(setf content-length it) (out h))
((maybe-header-value h "Connection: ")
(setf connection t) (out "Connection: close"))
((maybe-header-value h "X-Forwarded-For: ")
(setf forwarded-for t)
(out h ", " proxy-ip))
(t (out h))))
finally (progn (unless forwarded-for
(out "X-Forwarded-For: " client-ip ", " proxy-ip))
(unless connection
(out "Connection: close"))))))
host
(when content-length (parse-integer content-length)))))
(defun forward-bytes (from to &key how-many)
(let ((buffer (make-array (min (or how-many 2048) 2048)
:element-type '(unsigned-byte 8)))
(so-far 0))
(loop for n = (read-sequence buffer from) do
(when (= 0 n) (loop-finish))
(write-sequence buffer to :end n)
(when (and how-many (<= how-many (incf so-far n))) (loop-finish)))
(force-output to)))
(defun forward-response (hosts-table browser-stream forward-headers host
content-length server-timeout)
(let ((server (cdr (or (assoc host hosts-table :test #'string=)
(car hosts-table)))))
(with-client-socket (server-socket server-stream (car server) (cadr server)
:element-type '(unsigned-byte 8))
(set-timeout server-socket server-timeout)
(let ((s (make-flexi-stream server-stream :external-format :latin1)))
(princ forward-headers s) (crlf s) (finish-output s))
(when content-length
(forward-bytes browser-stream server-stream :how-many content-length))
(forward-bytes server-stream browser-stream))))
(defun proxy-connection (browser-socket hosts-table client-timeout server-timeout)
(set-timeout browser-socket client-timeout)
(multiple-value-call #'forward-response
hosts-table
(socket-stream browser-socket)
(process-headers
(make-flexi-stream
(socket-stream browser-socket)
:external-format (make-external-format :latin1 :eol-style :crlf))
(usocket::host-to-hostname (get-peer-address browser-socket))
(usocket::host-to-hostname (get-local-address browser-socket)))
server-timeout))
(defun start-proxy (port hosts-table &key
(client-timeout 2)
(server-timeout 2))
"Start a reverse HTTP proxy on the specified port. hosts-table
should consist of a list of hosts to be forwarded to particular IPs
and ports, like so: ((\"domain1\" \"127.0.0.1\" 8080) (\"domain2\"
\"127.0.0.1\" 8081)) The first entry in the hosts-table is the default
forwarding address if none of the entries match
Returns the main proxy server thread.
Optional parameters:
client-timeout (read and write) in seconds
server-timeout (read and write) in seconds"
(bt:make-thread
(lambda ()
(with-server-socket (listener (socket-listen
*wildcard-host* port
:reuseaddress t
:backlog 20
:element-type '(unsigned-byte 8)))
(loop
(handler-case
(let ((socket (socket-accept listener)))
(bt:make-thread
(lambda ()
(handler-case
(with-connected-socket (socket socket)
(proxy-connection socket hosts-table
client-timeout server-timeout))
(error ())))
:name (format nil "simple-vhost-proxy (port ~A) connection thread"
port)))
(error ()))))) ;; probably should do something less dumb
:name (format nil "simple-vhost-proxy main thread (port ~A)" port)))
| 5,056 | Common Lisp | .lisp | 103 | 35.970874 | 83 | 0.560591 | vsedach/simple-vhost-proxy | 3 | 0 | 0 | AGPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | e18eeec226c14713385b12bb3b0d8d2291b7ec904cfac6587f4172cc51138914 | 18,748 | [
-1
] |
18,749 | simple-vhost-proxy.asd | vsedach_simple-vhost-proxy/simple-vhost-proxy.asd | (asdf:defsystem :simple-vhost-proxy
:name "simple-vhost-proxy"
:description "HTTP reverse proxy for virtual host web servers."
:author "Vladimir Sedach <[email protected]>"
:license "AGPLv3"
:serial t
:components ((:file "package")
(:file "timeouts")
(:file "proxy"))
:depends-on (#:usocket #:flexi-streams #:anaphora #:bordeaux-threads))
| 383 | Common Lisp | .asd | 10 | 32.9 | 72 | 0.664879 | vsedach/simple-vhost-proxy | 3 | 0 | 0 | AGPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | f21cfa27514d3c9925c105ea440889d85ba14045fdd3829a09349e07f4be1e3f | 18,749 | [
-1
] |
18,769 | utils.lisp | belaja-akacija_dmenu-bkmks/utils.lisp | (defmacro handle-error (condition)
`(multiple-value-bind (value y error) ,condition
(if (= error 1)
(uiop:quit 0)
(string-trim '(#\NewLine #\Space) value))))
(defun remove-lines (file lines-to-remove)
(let ((filtered-lines ""))
(with-open-file (in file)
(loop
for line-number from 1
for line = (read-line in nil nil)
while line
unless (string-equal lines-to-remove line)
do (setf filtered-lines (concatenate 'string filtered-lines line (string #\NewLine)))))
filtered-lines))
(defun overwrite-file! (file removed-lines &key (type :human))
(with-open-file (in file
:direction :output
:if-exists :supersede
:if-does-not-exist :create) ; overwrite file
(if (equal type :data)
(format in "~s" removed-lines)
(format in "~A" removed-lines))))
(defun show-dialog (dialog &key (justify "left"))
(let* ((justification (format nil "--justify=~A" justify))
(dialog-width (length dialog))
(dialog-height (length (cl-ppcre:split "\\n" dialog)))
(geometry (format nil "--geometry=~Ax~A+550+300" dialog-width (* 32 dialog-height))))
(handle-error
(uiop:run-program `("yad" "--text-info" "--wrap" "--margins=20" ,geometry ,justification "--fore=#f2e5bc" "--back=#32302f")
:input
(uiop:process-info-output
(uiop:launch-program `("echo" ,dialog) :output :stream))
:output :string
:ignore-error-status t))))
;; List->List
;; Filters out all the atomic parts of an entry and spits back out a list of
;; all the parts
(defun filter-entry (entry)
(cl-ppcre:split "\\s\\|\\s" (cadr entry))) ;dummy
;; TODO rename this function everywhere
(defun append->file (url desc path)
(with-open-file (output path :direction :output
:if-exists :append :if-does-not-exist :create)
(format output "~A | ~A~%" desc url )))
(defun get-directory-files (lst)
(mapcar #'pathname-name lst))
(defun index-of (lst ele i)
(cond ((null lst) nil)
((equal (car lst) ele) i)
((index-of (cdr lst) ele (1+ i)))))
(defun get-file-lines (file)
(let ((lngth 0)) (with-open-file (stream file)
(loop for line = (read-line stream nil)
while line
do (setf lngth (1+ lngth))))
(format nil "~s" lngth)))
(defun launch-dmenu (lngth file &optional label)
(handle-error
(uiop:run-program `("dmenu" "-l" ,lngth "-p" ,label)
:input file
:output :string
:ignore-error-status t)))
(defun launch-dmenu-prompt (prompt)
(handle-error
(uiop:run-program `("dmenu" "-l" "6" "-p" ,prompt) :output :string :ignore-error-status t)))
| 2,912 | Common Lisp | .lisp | 66 | 34.727273 | 129 | 0.576014 | belaja-akacija/dmenu-bkmks | 3 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | d1eb18553542aaa528959c235fc3c45e7300be4128f90585aee8f03b15939694 | 18,769 | [
-1
] |
18,770 | config.lisp | belaja-akacija_dmenu-bkmks/config.lisp | (defparameter *user-home* (namestring (user-homedir-pathname)))
(defparameter *config-path* (pathname (concatenate 'string *user-home* ".config/bkmks/config")))
(defparameter *url-file-path* (pathname (concatenate 'string *user-home* ".config/bkmks/files/")))
(defparameter *url-file-path-list* (directory (merge-pathnames *url-file-path* "*")))
(defparameter *url-file-name* "urls")
(defparameter *url-full-path* (merge-pathnames *url-file-path* (pathname *url-file-name*)))
(defun load-config (file)
(ensure-directories-exist file)
(if (probe-file file)
(modest-config:load-config file)
(overwrite-file! file ;; quietly fail by creating a new config and set the defaults
(set-default-config)
:type :data)))
(defun set-config! (plist key val)
(setf (getf plist key) val)
(overwrite-file! *config-path* plist :type :data))
(defun check-config (config)
;; should a dialog box come up instead so the user can fix the error themselves?
;; Or just set it to the defaults?
"check if things are valid in the config and handle them."
(cond ((equal (getf config 'current-file) nil)
(format t "setting current file to default")
(set-config! config 'current-file 0))
((not (realp (getf config 'current-file)))
(format t "file number not a number. Setting to default.")
(set-config! config 'current-file 0))
((> (getf config 'current-file) (length (getf config 'files)))
(format t "invalid file number. greater than. Setting to default")
(set-config! config 'current-file 0))
((< (getf config 'current-file) 0)
(format t "invalid file number. less than. Setting to default")
(set-config! config 'current-file 0))
(t (format t "nothing to do"))))
(defun set-default-config ()
`(menu "dmenu" browser "firefox" files ,*url-file-path-list* current-file 0))
(defun update-categories ()
(let ((config (load-config *config-path*))
(files (directory (merge-pathnames *url-file-path* "*"))))
(set-config! config 'files files)))
(defun update-home ()
(setf *user-home* (namestring (user-homedir-pathname)))
(setf *url-file-path* (pathname (concatenate 'string *user-home* ".config/bkmks/files/")))
(setf *url-full-path* (merge-pathnames *url-file-path* (pathname *url-file-name*)))
(setf *url-file-path-list* (directory (merge-pathnames *url-file-path* "*")))
(setf *config-path* (pathname (concatenate 'string *user-home* ".config/bkmks/config"))))
(defun update-globals ()
(let ((config (load-config *config-path*)))
(setf *config* config)
(setf *browser* (getf config 'browser))
(setf *preferred-menu* (getf config 'menu))
(setf *files* (getf config 'files))
(setf *file-state* (getf config 'current-file))
(setf *current-file* (nth *file-state* *files*))))
| 2,900 | Common Lisp | .lisp | 53 | 48.924528 | 100 | 0.663028 | belaja-akacija/dmenu-bkmks | 3 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | d110dc77df2fb38f8f25e8ec0198e8183441e3a6aef7a9aa153a6ad074b1b73f | 18,770 | [
-1
] |
18,771 | bkmks.asd | belaja-akacija_dmenu-bkmks/bkmks.asd | (defsystem "bkmks"
:description "bkms: unix bookmark management that sucks less. Lisp edition!"
:version "0.5.4"
:author "belaja-akacija"
;:depends-on ("cl-ppcre" "modest-config" "vlime")
:depends-on ("cl-ppcre" "modest-config" "vlime")
:components ((:file "utils")
(:file "config" :depends-on ("utils"))
(:file "main" :depends-on ("utils" "config")))
:build-operation "program-op"
:build-pathname "bkmks"
:entry-point "main"
:in-order-to ((test-op (test-op "bkmks/tests"))))
(defsystem "bkmks/tests"
:depends-on ("bkmks" "fiveam")
:components ((:file "tests/bkmks-tests")))
| 630 | Common Lisp | .asd | 16 | 34.9375 | 78 | 0.644372 | belaja-akacija/dmenu-bkmks | 3 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 7ea47e358b836a335f034c586ebc3c3d90db49750ec1a994939699ed75f473e8 | 18,771 | [
-1
] |
18,774 | Makefile | belaja-akacija_dmenu-bkmks/Makefile | LISP ?= sbcl
ASD := bkmks.asd
ASD_PATH := $(shell pwd)/$(ASD)
BINARY := bkmks
INSTALL_PATH := ~/.local/bin
load:
rlwrap -c $(LISP) --eval "(asdf:load-asd #P\"$(ASD_PATH)\")" \
--eval '(ql:quickload :$(BINARY))'
#--eval '(ql:quickload :$(BINARY))' \
#--eval '(if (cl-ppcre:all-matches "Vlime" (format nil "~A" (swank:list-threads))) 0 (vlime:main))'
load-test:
rlwrap -c $(LISP) --eval "(asdf:load-asd #P\"$(ASD_PATH)\")" \
--eval '(ql:quickload :bkmks/tests)' \
build:
$(LISP) --eval "(asdf:load-asd #P\"$(ASD_PATH)\")" \
--eval '(ql:quickload :bkmks)' \
--eval "(sb-ext:save-lisp-and-die #P\"$(BINARY)\" :toplevel #'main :executable t :compression 22)" \
--eval '(quit)'
install:
install -v $(BINARY) $(INSTALL_PATH)/$(BINARY)
clean:
rm -v $(BINARY)
uninstall:
rm -v $(INSTALL_PATH)/$(BINARY)
| 820 | Common Lisp | .l | 24 | 32.083333 | 102 | 0.613924 | belaja-akacija/dmenu-bkmks | 3 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 0c83b3194dff6814a87ec00f90fb0813bdc115a7c987a877d6df7f878dbc7c65 | 18,774 | [
-1
] |
18,790 | notify.lisp | jaredkrinke_thirteen-letters/notify.lisp | (in-package :13ls)
(defun-debounced run-notify-script (* 20 60) ()
(spew "Running notify.sh...~%")
(if (uiop:getenv "IFTTT_KEY")
(progn
(bt:make-thread #'(lambda ()
(uiop/run-program:run-program "./notify.sh")
:name "NotifyOneShot")))
(spew "Note: No IFTTT_KEY!~%")))
(defun notify (&key (client nil))
(if (not (and client
(or (equal "Jared" (slot-value client 'name))
(slot-value client 'bot))))
(run-notify-script)))
| 468 | Common Lisp | .lisp | 14 | 28.928571 | 51 | 0.610619 | jaredkrinke/thirteen-letters | 3 | 0 | 0 | AGPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 4b253dc4c525cb05e29c820af79a3d5dfc2d645b2ba6bf4604830cb012b5a3aa | 18,790 | [
-1
] |
18,791 | server.lisp | jaredkrinke_thirteen-letters/server.lisp | (defpackage :13l-server
(:documentation "Web server for online, multiplayer Thirteen Letters game")
(:nicknames :13ls)
(:use :cl
:13l)
(:local-nicknames (:lp :lparallel)
(:sp :spinneret))
(:export #:start-server
#:start-server-thread
#:stop-server))
(in-package :13ls)
;;; General utility functions
(defvar *verbose* nil)
(defmacro spew (&rest args)
"Logs to the console, if *verbose* is non-nil"
`(and *verbose* (format t ,@args)))
(defun alistp (value)
"Tests to see if a value is an a-list"
(and (listp value)
(every #'consp value)))
(defun alist-path (object &rest keys)
"Walk down an AList path"
(labels ((alist-path-recursive (object keys)
(if keys
(alist-path-recursive (cdr (assoc (car keys) object)) (cdr keys))
object)))
(alist-path-recursive object keys)))
(defmacro defun-debounced (name period (&rest vars) &body body)
"Defines a debounced function that won't be called if previously called within PERIOD seconds"
;;; TODO: gensym!
`(let ((period-native (* ,period internal-time-units-per-second))
(last-called nil))
(defun ,name (,@vars)
;;; TODO: gensym!
(let ((current-time (get-internal-real-time)))
(if (or (not last-called) (> current-time (+ last-called period-native)))
(progn
(setf last-called current-time)
,@body))))))
(defmacro loop-over-lines ((line-var path) &body body)
"Run LOOP over each line of a file"
`(with-open-file (stream ,path) ; TODO: gensym!
(loop for ,line-var = (read-line stream nil)
while ,line-var
,@body)))
(defun get-time ()
"Return a timestamp (in seconds, as a ratio)"
(/ (get-internal-real-time) internal-time-units-per-second))
;;; TODO: Hash table conversion functions aren't actually used anymroe
(defun hash-table->alist (table)
"Converts a hash table to an a-list"
(let ((alist nil))
(maphash #'(lambda (k v) (pushnew (cons k v) alist)) table)
alist))
(defun alist->hash-table (alist &key test)
"Converts an a-list to a hash table"
(let ((table (make-hash-table :test test)))
(loop for (k . v) in alist
do (setf (gethash k table) v))
table))
(defun olist-upsert (olist item &key key (test 'eql) create update less-than)
"Inserts or updates an item in an ordered list"
(let ((updated nil)
(existing-entry (find item olist :key key :test test)))
(if existing-entry
(setf updated (funcall update existing-entry))
(progn
(setf olist (nconc olist (list (funcall create))))
(setf updated t)))
(values (stable-sort olist less-than) updated)))
;;; Helpers
(defvar *valid-words*
(let ((hash-table (make-hash-table :test 'equal :size 264097)))
(loop-over-lines (word "yawl/yawl-0.3.2.03/word.list")
do (setf (gethash word hash-table) t))
hash-table))
(defun only-letters-p (word)
"Returns non-nil if the word consists solely of the letters A through Z"
(let ((min1 (char-code #\a))
(max1 (char-code #\z))
(min2 (char-code #\A))
(max2 (char-code #\Z)))
(loop for character across word
do (let ((code (char-code character)))
(if (not (or (and (>= code min1) (<= code max1))
(and (>= code min2) (<= code max2))))
(return-from only-letters-p nil))))
t))
;;; Leaderboard entries
(defclass entry ()
((client :initarg :client)
(word :initarg :word)
(time :initform (get-time))))
(defgeneric entry-word-length (entry))
(defmethod entry-word-length ((entry entry))
(length (slot-value entry 'word)))
(defmethod print-object ((object entry) stream)
(print-unreadable-object (object stream :type t)
(with-slots (client word time) object
(format stream "~a: ~s (~f)" client word time))))
;;; TODO: Seems like a macro might make sense...
(defun entry< (a b)
(let ((a-length (entry-word-length a))
(b-length (entry-word-length b)))
(or (> a-length b-length)
(and (= a-length b-length)
(< (slot-value a 'time) (slot-value b 'time))))))
;;; Server
;;; WebSocket server
(defparameter *message-handlers*
(list (cons "guess" 'client-guess)
(cons "rename" 'client-rename)))
(defvar *clients* nil)
(defclass socket (hunchensocket:websocket-resource)
()
(:documentation "WebSocket server/resource/socket")
(:default-initargs :client-class 'client))
(defclass client (hunchensocket:websocket-client)
((name :initform "(unknown)")
(active :initform nil)
(bot :initform nil))
(:documentation "WebSocket client"))
(defmethod hunchensocket:client-connected ((socket socket) client)
(lp:submit-task *queue* 'client-connect client))
(defmethod hunchensocket:client-disconnected ((socket socket) client)
(lp:submit-task *queue* 'client-disconnect client))
(defun make-keyword (string)
(intern (string-upcase string) :keyword))
(defmethod hunchensocket:text-message-received ((socket socket) client text)
;;; TODO: There's probably a macro for this sort of non-nil chaining...
(let* ((yason:*parse-object-as* :alist)
(yason:*parse-object-key-fn* 'make-keyword)
(message (handler-case (yason:parse text) (t () nil)))
(type (and (alistp message) (alist-path message :type)))
(handler (and type (cdr (assoc type *message-handlers* :test #'string-equal)))))
(if handler
(lp:submit-task *queue* handler client message)
(spew "Couldn't find a handler for message: ~s~%" text))))
(defun find-websocket-handler (request)
"Finds any relevant WebSocket handler, based on the REQUEST's SCRIPT-PATH"
(if (equal (hunchentoot:script-name request) *socket-path*)
*socket*))
;;; TODO: Same port as HTTP? If so, rename
(defparameter *socket-port* 13131)
(defparameter *socket-path* "/ws/13l" "Path to WebSocket interface")
(defvar *socket* (make-instance 'socket))
(defvar *server* (make-instance 'hunchensocket:websocket-acceptor
:address "127.0.0.1"
:port *socket-port*
:document-root nil
:error-template-directory nil
:access-log-destination nil))
;;; Disable Hunchentoot default status messages
(defmethod hunchentoot:acceptor-status-message ((acceptor (eql *server*)) http-status-code &rest args)
(declare (ignore args))
"")
;;; TODO: Plus or star?
(defparameter *round-time* 60 "Length of each round (in seconds)")
(defparameter *intermission-time* 15 "Length of time between rounds (in seconds)")
(defparameter *stats-file-name* "stats.txt" "File name for stats")
(defvar *on-activity* nil "Optional callback to call when there is activity on the server")
(defvar *round-done* t "True if there is no active round")
(defvar *done* t "True if the server should stop")
(defvar *queue* nil "Task queue")
;;; Server main worker logic
(defvar *solution* nil)
(defvar *solution-letters* nil)
(defvar *scrambled* nil)
(defvar *round-end* nil)
(defvar *intermission-end* nil)
(defvar *leaderboard* nil)
(defvar *news* nil)
(defvar *stats* nil)
(defun list->json (list stream)
(if (keywordp (caar list))
(yason:encode-alist list stream)
(yason:encode-plain-list-to-array list stream)))
(defun message->json (message)
"Encodes MESSAGE as JSON"
;;; TODO: Rewrite to use non-cl-json or bundle cl-json with Unicode (non-BMP) fix
(let ((yason:*symbol-key-encoder* #'yason:encode-symbol-as-lowercase)
(yason:*symbol-encoder* #'yason:encode-symbol-as-lowercase)
(yason:*list-encoder* #'list->json))
(yason:with-output-to-string* ()
(yason:encode-alist message))))
(defun send (client message)
"Sends MESSAGE to CLIENT, if non-nil"
(if message
(let ((text (message->json message)))
(spew "Sending to ~a: ~a~%" client text)
(ignore-errors
(hunchensocket:send-text-message client text)))))
(defun broadcast (message)
"Broadcasts a message to all players, if non-nil"
(if message
(let ((text (message->json message)))
(spew "Broadcast: ~a~%" text)
(loop for client in (hunchensocket:clients *socket*)
do (hunchensocket:send-text-message client text)))))
(defun make-message (type object)
"Makes a message of type TYPE"
(cons (cons :type type)
object))
(defun leaderboard->alist (&key reveal)
"Formats *LEADERBOARD* entries as a-lists (revealing words if REVEAL is non-nil)"
;;; TODO: Consider just going straight to JSON?
(mapcar #'(lambda (entry)
(with-slots (client word) entry
(list (cons :name (slot-value client 'name))
(cons :word (if reveal word
(char-repeat #\? (length word)))))))
*leaderboard*))
(defun get-current-state ()
"Gets the current puzzle state (in-progress or results)"
(if *round-done*
(list (cons :type :result)
(cons :solution *solution*)
(cons :remaining (float (max 0 (/ (- *intermission-end* (get-internal-real-time))
internal-time-units-per-second))))
(cons :leaderboard (leaderboard->alist :reveal t)))
(list (cons :type :state)
(cons :scrambled *scrambled*)
(cons :remaining (float (max 0 (/ (- *round-end* (get-internal-real-time))
internal-time-units-per-second))))
(cons :clients (count-if #'(lambda (client) (slot-value client 'active)) *clients*))
(cons :leaderboard (leaderboard->alist :reveal nil)))))
(defun broadcast-state ()
"Broadcasts puzzle state to all players"
(broadcast (get-current-state)))
(defun get-current-news ()
"Gets current news as a message, if any"
(if *news* (list (cons :type :news)
(cons :fragment *news*))))
(defun queue-news-update (news)
"Queues a task to update *NEWS* and broadcast the update"
(lp:submit-task *queue* #'(lambda ()
(setf *news* news)
(broadcast (get-current-news)))))
(defun client-connect (client)
"Handles a client connection work item"
(spew "Client connected: ~a~%" client)
(push client *clients*)
(send client (get-current-state))
(send client (get-current-news)))
(defun client-disconnect (client)
"Handles a client disconnection work item"
(spew "Client disconnected: ~a~%" client)
(setf *clients* (delete-if #'(lambda (c) (eql c client)) *clients*)))
(defun client-rename (client message)
"Handles a work item that associates a name with the given client"
(let ((name (alist-path message :name)))
(cond (name
(setf (slot-value client 'name) name)
(setf (slot-value client 'active) t)
(if (alist-path message :bot) (setf (slot-value client 'bot) t))
(spew "Renamed ~a to ~s~%" client (slot-value client 'name))))))
(defun client-guess (client message)
"Handles a guess work item from the given client"
(cond ((not *round-done*)
(let ((word (alist-path message :word)))
(if word (setf (slot-value client 'active) t))
(if (and word
(valid-word-p word)
(update-leaderboard client word))
(broadcast-state))))
(t (spew "Guess arrived after round ended~%"))))
(defun round-start (&optional (difficulty 0))
"Selects a new puzzle and broadcasts to all players"
(setf *solution* (get-random (nth difficulty *bucketed-words*)))
(setf *solution-letters* (get-letter-counts *solution*))
(setf *scrambled* (scramble *solution*))
(setf *round-end* (+ (get-internal-real-time) (* *round-time* internal-time-units-per-second)))
(setf *leaderboard* nil)
(setf *round-done* nil)
(broadcast-state))
(defun update-stats ()
"Updates overall win statistics"
(let ((winner (first *leaderboard*)))
(if winner
(with-slots (client) winner
(with-slots (name) client
(if name
(setf *stats*
(olist-upsert *stats*
name
:key #'car
:test 'equal
:create #'(lambda () (cons name 1))
:update #'(lambda (e) (incf (cdr e)))
:less-than #'(lambda (a b) (> (cdr a) (cdr b)))))))))))
(defun write-stats ()
"Persists win statistics to disk"
(with-open-file (stream *stats-file-name*
:direction :output
:if-exists :supersede)
(write *stats* :stream stream)))
(defun read-stats ()
"Reads persisted stats from disk"
(with-open-file (stream *stats-file-name* :if-does-not-exist nil)
(setf *stats* (if stream (read stream) nil))))
(defun format-stats ()
"Format *STATS* into an HTML string"
(let ((*print-pretty* nil)
(sp:*html-style* :tree))
(sp:with-html-string
(:h3 "Hall of Fame")
(:table (:tr (:th :class "center" "Name") (:th :class "center" "Wins"))
(loop for pair in *stats*
for i from 1 to 10
do (:tr (:td (car pair)) (:td :class "right" (cdr pair))))))))
(defun round-end ()
"Broadcasts the results of the round that just ended"
(setf *round-done* t)
(setf *intermission-end* (+ (get-internal-real-time) (* *intermission-time* internal-time-units-per-second)))
(broadcast-state)
(update-stats)
(if *leaderboard*
(queue-news-update (format-stats))))
(defun run-round ()
"Runs a single round"
(lp:submit-task *queue* 'round-start)
(sleep *round-time*)
(lp:submit-task *queue* 'round-end)
(sleep *intermission-time*))
(defun valid-word-p (word)
"Returns true if WORD is a real word and uses letters from *SCRAMBLED*"
(and (only-letters-p word)
(gethash word *valid-words*)
(every #'<= (get-letter-counts word) *solution-letters*)))
(defun update-leaderboard (client word)
"Updates the leaderboard (note: WORD is assumed valid); returns non-nil if the leaderboard was updated"
(multiple-value-bind (leaderboard updated)
(olist-upsert *leaderboard*
client
:key #'(lambda (e) (slot-value e 'client))
:create #'(lambda ()
(make-instance 'entry
:client client
:word word))
:update #'(lambda (e)
(if (< (length (slot-value e 'word)) (length word))
(progn
(setf (slot-value e 'word) word)
(setf (slot-value e 'time) (get-time)))))
:less-than #'entry<)
(setf *leaderboard* leaderboard)
(if (and updated *on-activity*) (funcall *on-activity* :client client))
updated))
(defun start-server ()
"Runs the server"
(initialize-random-state)
(unwind-protect
(progn
(read-stats)
(setf *done* nil)
(setf lp:*kernel* (lp:make-kernel 1))
(setf *queue* (lp:make-channel))
(setf hunchensocket:*websocket-dispatch-table* (list 'find-websocket-handler))
(hunchentoot:start *server*)
(spew "Server started~%")
(loop while (not *done*)
do (run-round))
(hunchentoot:stop *server*)
(setf hunchensocket:*websocket-dispatch-table* nil)
(lp:end-kernel :wait t)
(setf *queue* nil))
(write-stats)
(spew "Server stopped~%")))
(defun start-server-thread ()
"Runs the server in its own thread"
(bt:make-thread 'start-server :name "13l-server"))
(defun stop-server ()
"Stops the server"
(setf *done* t))
| 14,583 | Common Lisp | .lisp | 374 | 35.096257 | 111 | 0.677743 | jaredkrinke/thirteen-letters | 3 | 0 | 0 | AGPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 5bae622cdc5d19aa9f0f515667aace2a710f181772d2892702f9f9b30ad06243 | 18,791 | [
-1
] |
18,792 | chad-bot.lisp | jaredkrinke_thirteen-letters/chad-bot.lisp | ;(ql:quickload '(:websocket-driver-client :cl-json :scms))
;(load "shared.lisp")
(defpackage :chad-bot
(:documentation "A dumb bot for Thirteen Letters")
(:use :cl))
(in-package :chad-bot)
(defparameter *url* "wss://api.schemescape.com/ws/13l")
(defparameter *play-time* 300)
(defvar *url-override* nil)
(defvar *done* nil)
;;; Helpers
(defclass word-info ()
((word :initarg :word)
(length :initarg :length)
(letter-counts :initarg :letter-counts))
(:documentation "Information about a word"))
(defun get-word (line)
"Gets the word part of a tab-separated word+frequency pair"
(subseq line 0 (position #\Tab line)))
(defun for-most-frequent-words (count f)
"Maps (at most) the COUNT most frequent words"
(with-open-file (stream "count_1w.txt")
(loop for n from 1 to count
do (funcall f (get-word (read-line stream))))))
(defun make-word-info (word)
"Creates a WORD-INFO for WORD"
(make-instance 'word-info
:word word
:length (length word)
:letter-counts (13l:get-letter-counts word)))
(defun make-vocabulary (max-count &key (recall 1.0))
"Creates a bot vocabularly using the COUNT most frequent words"
(let* ((count (floor (* max-count recall)))
(word-infos (make-array count :initial-element nil))
(i -1))
(for-most-frequent-words count
#'(lambda (word)
(if (>= (random 1.0) recall)
(setf (aref word-infos (incf i)) (make-word-info word)))))
word-infos))
(defun find-next-guess (word-infos letter-counts &key (start 0) (min-length 1) (tries 1000000))
"Go through WORD-INFOS (starting at index START) TRIES times to find a matching word of length >= MIN-LENGTH"
(loop for i from start below (min (+ start tries) (length word-infos))
for word-info = (aref word-infos i)
if (and word-info
(>= (slot-value word-info 'length) min-length)
(13l:letter-subset-p letter-counts (slot-value word-info 'letter-counts)))
do (return (slot-value word-info 'word))
finally (return nil)))
;;; TODO: Support recall < 100%
(defun make-guess-generator (word-infos letter-counts)
"Creates a generator for guesses given the provided constraints"
(let ((start 0)
(min-length 3)
(guess nil))
(lambda (tries)
(setf guess (find-next-guess word-infos
letter-counts
:start start
:min-length min-length
:tries tries))
(if guess
(progn
(setf start 0)
(setf min-length (1+ (length guess))))
(setf start (+ start tries)))
guess)))
;;; Bot implementation
(defclass bot ()
((lock :initform (bt:make-lock))
(name :initarg :name)
(url :initarg :url)
(state :initform :between-rounds)
(word-infos :initarg :word-infos)
(think-period :initarg :think-period)
(try-rate :initarg :try-rate)
client)
(:documentation "Framework for vocabulary-based bots"))
(defmethod initialize-instance :after ((bot bot) &key)
(bt:with-lock-held ((slot-value bot 'lock))
(let ((client (wsd:make-client (slot-value bot 'url))))
(setf (slot-value bot 'client) client)
(wsd:on :open client
(lambda ()
(format t "Connected!~%")
(send-json client (list (cons :type "rename")
(cons :name (slot-value bot 'name))
(cons :bot t)))))
(wsd:on :close client
(lambda (&key code reason)
(format t "Disconnected! ~a, ~a~%" code reason)))
(wsd:on :message client
(lambda (json)
(bot-handle-message bot (json:decode-json-from-string json))))
(wsd:start-connection client))))
(defgeneric bot-handle-message (bot message)
(:documentation "Handler for messages"))
;;; Note: These should be called under lock
(defgeneric bot-round-start (bot message)
(:documentation "Called (under lock) when a round starts"))
(defgeneric bot-round-end (bot message)
(:documentation "Called (under lock) when a roudn ends"))
(defun bot-close (bot)
"Terminate a bot"
(setf (slot-value bot 'state) :disconnected)
(wsd:close-connection (slot-value bot 'client)))
(defun send-json (client message)
"Encodes a message into JSON and sends it"
(let ((json (json:encode-json-to-string message)))
(format t "Sending: ~a~%" json)
(wsd:send-text client json)))
(defun send-guess (client guess)
"Sends a 'guess' message"
(send-json client
(list (cons :type "guess")
(cons :word guess))))
(defun bot-send-guess (bot guess)
"Sends a guess from the bot (note: this doesn't strictly avoid sending guesses between rounds"
(if (eql (slot-value bot 'state) :in-round)
(bt:with-lock-held ((slot-value bot 'lock))
(send-guess (slot-value bot 'client) guess))))
(defmethod bot-handle-message ((bot bot) message)
(bt:with-lock-held ((slot-value bot 'lock))
(let ((message-type (cdr (assoc :type message :test 'equal))))
(case (slot-value bot 'state)
(:between-rounds
(cond
((equal message-type "state")
(setf (slot-value bot 'state) :in-round)
(bot-round-start bot message))))
(:in-round
(cond
((equal message-type "result")
(setf (slot-value bot 'state) :between-rounds)
(bot-round-end bot message))))))))
(defmethod bot-round-start ((bot bot) message)
"Start a 'guessing' thread for the bot"
(with-slots (think-period try-rate) bot
(let* ((tries-per-period (* think-period try-rate))
(scrambled (scms:alist-path message :scrambled))
(generator (make-guess-generator (slot-value bot 'word-infos)
(13l:get-letter-counts scrambled))))
(bt:make-thread
#'(lambda ()
(loop while (eql (slot-value bot 'state) :in-round)
do (sleep think-period)
(let ((guess (funcall generator tries-per-period)))
(if guess (bot-send-guess bot guess)))))
:name "bot-thread"))))
(defmethod bot-round-end ((bot bot) message)
(format t "Bot: round ended! ~a ~%" bot))
(defun make-bot-test (&key
(name "Chad Bot")
(vocabulary-size 1000)
(think-period 5)
(try-rate 10)
(recall 1.0))
"Makes a simpler bot for testing purposes"
(make-instance 'bot
:name name
:url (or *url-override* *url*)
:word-infos (make-vocabulary vocabulary-size :recall recall)
:think-period think-period
:try-rate try-rate))
(defparameter *names* '("Mike"
"Chris"
"Matt"
"Josh"
"Jake"
"Nick"
"Andrew"
"Dan"
"Tyler"
"Joe"
"Brandon"
"David"
"Jim"
"Ryan"
"John"
"Zach"
"Justin"
"Bill"
"Tony"
"Rob"
"Jessica"
"Ashley"
"Emily"
"Sarah"
"Samantha"
"Amanda"
"Brittany"
"Elizabeth"
"Taylor"
"Megan"
"Hannah"
"Kayla"
"Lauren"
"Stephanie"
"Rachel"
"Jennifer"
"Nicole"
"Alexis"
"Victoria"
"Amber"))
(defun run-bot (bot seconds)
"Lets a bot run for SECONDS seconds and then closes it"
(sleep seconds)
(format t "Stopping bot ~a~%" (slot-value bot 'name))
(bot-close bot))
(defun spawn-bot ()
"Spawns a bot that runs for some amount of time"
(let* ((name (13l:get-random *names*))
(vocabulary-size (+ 500 (random 1500)))
(think-period (+ 3 (random 6)))
(try-rate (+ 5 (random 15)))
(recall (+ 0.8 (random 0.2)))
(play-time (+ *play-time* (random *play-time*)))
(bot (ignore-errors (make-bot-test :name name
:vocabulary-size vocabulary-size
:think-period think-period
:try-rate try-rate
:recall recall))))
(if bot
(progn
(format t "Starting bot ~a for ~a seconds~%" name play-time)
(bt:make-thread (lambda () (run-bot bot play-time))
:name (format nil "bot-~a" name)))
(format t "Failed to start bot!~%"))))
(defun start-bots ()
(setf *done* nil)
(bt:make-thread
(lambda ()
(loop while (not *done*)
do (spawn-bot)
(sleep (+ *play-time* (random *play-time*))))
(format t "Orchestrator ended"))
:name "bot-orchestrator"))
(defun stop-bots ()
(setf *done* t))
;;; TODO: Consider sending pings:
;; (loop do (sleep 60)
;; (wsd:send-ping client)))))
| 7,894 | Common Lisp | .lisp | 242 | 28.628099 | 111 | 0.659798 | jaredkrinke/thirteen-letters | 3 | 0 | 0 | AGPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | e4922ec6341e4d7a97f77c47b0970a0f7f6e376a10a8688c788126f809c87d28 | 18,792 | [
-1
] |
18,793 | data.lisp | jaredkrinke_thirteen-letters/data.lisp |
(("international" "entertainment" "environmental" "opportunities"
"communication" "accommodation" "organizations" "understanding"
"documentation" "announcements" "manufacturing" "configuration"
"comprehensive" "approximately" "automatically" "advertisement"
"manufacturers" "professionals" "miscellaneous" "relationships"
"administrator" "participation" "certification" "investigation"
"circumstances" "contributions" "consideration" "significantly"
"consolidation" "accessibility" "subscriptions" "specification"
"organisations" "collaboration" "corresponding" "determination"
"unfortunately" "concentration" "participating" "establishment"
"presentations" "undergraduate" "effectiveness" "institutional"
"functionality" "compatibility" "informational" "architectural"
"authorization" "psychological" "collaborative" "instructional"
"biotechnology" "technological" "demonstration" "sophisticated"
"vulnerability" "congressional" "modifications" "practitioners"
"extraordinary" "photographers" "possibilities" "semiconductor"
"illustrations" "substantially" "inappropriate" "distinguished"
"developmental" "notifications" "independently" "consciousness"
"transcription" "complications" "distributions" "championships"
"precipitation" "mediterranean" "revolutionary" "accreditation"
"parliamentary" "questionnaire" "qualification" "computational"
"characterized" "conversations" "bibliographic" "investigators"
"complimentary" "contamination" "alternatively" "controversial"
"installations" "entrepreneurs" "commissioners" "interventions"
"restructuring" "strengthening" "complementary" "reimbursement"
"investigating" "neighborhoods" "incorporation" "appropriately"
"traditionally" "objectionable" "globalization" "inspirational"
"philosophical" "justification" "incorporating" "supplementary"
"discrepancies" "consultations" "prescriptions" "dissemination"
"conservatives" "communicating" "visualization" "prerequisites"
"appropriation" "proliferation" "approximation" "correspondent"
"beneficiaries" "clarification" "abbreviations" "neighbourhood"
"jurisdictions" "personalities" "customization" "autobiography"
"architectures" "statistically" "demonstrating" "profitability"
"grandchildren" "introductions" "physiological" "unprecedented"
"knowledgeable" "registrations" "transvestites" "chronological"
"encouragement" "disadvantages" "methodologies" "multicultural"
"refrigeration" "uncomfortable" "reconditioned" "enlightenment"
"disadvantaged" "comprehension" "uncertainties" "redevelopment"
"investigative" "breastfeeding" "inconvenience" "decomposition"
"predominantly" "applicability" "administering" "privatization"
"intentionally" "interpersonal" "redistributed" "transmissions"
"homosexuality" "disappointing" "schizophrenia" "stabilization"
"authoritative" "consequential" "multinational" "mitochondrial"
"probabilities" "exceptionally" "interestingly" "retrospective"
"reproductions" "discretionary" "merchandising" "pronunciation"
"fundamentally" "clearinghouse" "reinforcement" "psychotherapy"
"assassination" "dehydrogenase" "refrigerators" "abnormalities"
"heterogeneous" "psychologists" "participatory" "multifunction"
"skateboarding" "globalisation" "differentiate" "righteousness"
"headquartered" "contradiction" "authenticated" "unforgettable"
"macroeconomic" "commissioning" "deterioration" "cancellations"
"indispensable" "subcategories" "contraception" "confrontation"
"unpredictable" "modernization" "ophthalmology" "compassionate"
"noncommercial" "documentaries" "amplification" "intracellular"
"fragmentation" "carbohydrates" "concentrating" "optimizations"
"transnational" "employability" "authorisation" "endocrinology"
"theoretically" "typographical" "accompaniment" "insignificant"
"veterinarians" "telemarketing" "confederation" "constructions"
"manifestation" "gravitational" "substitutions" "saccharomyces"
"constellation" "strategically" "extracellular" "postsecondary"
"civilizations" "collaborating" "socioeconomic" "congregations"
"unconditional" "progressively" "probabilistic" "commemorative"
"subcontractor" "hydrochloride" "magnification" "thunderstorms"
"disappearance" "hybridization" "acknowledging" "anniversaries"
"jurisprudence" "homeschooling" "perpendicular" "polypropylene"
"interpolation" "deterministic" "baccalaureate" "affordability"
"contradictory" "misunderstood" "intersections" "characterised")
("postoperative" "morphological" "horticultural" "cryptographic"
"collaborators" "acetaminophen" "contraceptive" "interrogation"
"embarrassment" "predetermined" "observational" "reconstructed"
"privatisation" "encapsulation" "normalization" "comparatively"
"consolidating" "recombination" "experimenting" "instantaneous"
"denominations" "irresponsible" "heterogeneity" "confectionery"
"electrostatic" "craftsmanship" "refurbishment" "nutritionists"
"antimicrobial" "intellectuals" "fertilization" "dissertations"
"solicitations" "republication" "inadvertently" "deliberations"
"uninterrupted" "transactional" "encyclopaedia" "contemplating"
"reinstatement" "inconsistency" "combinatorial" "spontaneously"
"distinguishes" "decentralized" "interactivity" "intercultural"
"transatlantic" "polycarbonate" "disbursements" "chiropractors"
"exhibitionism" "individuality" "accommodating" "improvisation"
"invertebrates" "encyclopedias" "constitutions" "interruptions"
"transmembrane" "controversies" "realistically" "unnecessarily"
"technologists" "inexperienced" "competitively" "physiotherapy"
"contingencies" "psychiatrists" "discontinuity" "circumference"
"underestimate" "exponentially" "noncompliance" "ramifications"
"sterilization" "incarceration" "sedimentation" "thermoplastic"
"demonstrators" "contemplation" "accomplishing" "brainstorming"
"modernisation" "intermediates" "granddaughter" "conscientious"
"endometriosis" "streptococcus" "dysfunctional" "opportunistic"
"communicative" "authoritarian" "precautionary" "petrochemical"
"mathematician" "homeownership" "disseminating" "proportionate"
"breakthroughs" "immunizations" "intelligently" "apportionment"
"thermodynamic" "mycobacterium" "differentials" "nationalities"
"preservatives" "unintentional" "disagreements" "hyperactivity"
"deforestation" "radioactivity" "archeological" "videographers"
"hydroelectric" "insufficiency" "translational" "deteriorating"
"philanthropic" "reincarnation" "bidirectional" "oceanographic"
"acceptability" "rollercoaster" "decompression" "resuscitation"
"metamorphosis" "translocation" "serialization" "imperfections"
"instrumentals" "intelligencer" "neuromuscular" "waterproofing"
"spectroscopic" "commemoration" "repercussions" "acquaintances"
"unenforceable" "interoperable" "mainstreaming" "harmonization"
"discriminated" "visualisation" "interconnects" "socialization"
"microcomputer" "photographing" "companionship" "manipulations"
"intrinsically" "recollections" "perturbations" "gratification"
"extinguishers" "extensibility" "eavesdropping" "screenwriting"
"antibacterial" "characterizes" "supercomputer" "compositional"
"biodegradable" "interactively" "impossibility" "metallurgical"
"contravention" "reunification" "indeterminate" "redistricting"
"interceptions" "comparability" "qualitatively" "phytoplankton"
"sensitivities" "factorization" "transgendered" "toxicological"
"communicators" "astrophysical" "immunological" "telecommuting"
"polymorphisms" "misconception" "impressionist" "acetylcholine"
"sequestration" "conditionally" "congratulated" "topographical"
"phenomenology" "substantiated" "cooperatively" "biostatistics"
"choreographer" "impressionism" "paraphernalia" "unsustainable"
"unanticipated" "extrapolation" "epidemiologic" "individualism"
"hematopoietic" "gubernatorial" "weightlifting" "pediatricians"
"expeditionary" "triglycerides" "transitioning" "policyholders"
"exhibitionist" "preponderance" "subcommittees" "commemorating"
"anthropogenic" "preliminaries" "reciprocating" "harmonisation"
"credentialing" "transparently" "magnetization" "externalities"
"instinctively" "glycoproteins" "idiosyncratic" "dependability"
"prostaglandin" "straightening" "synchronizing" "schizophrenic"
"whistleblower" "concatenation" "reintegration" "introspection"
"sensibilities" "contemplative" "delicatessens" "postmodernism"
"extinguishing" "disconnection" "unconsciously" "unwillingness"
"triangulation" "admissibility" "replenishment" "dexamethasone"
"radioisotopes" "obstetricians" "prefabricated" "archaeologist"
"propositional" "disengagement" "instantiation" "reengineering"
"mismanagement" "phenylalanine" "transcriptase" "aesthetically"
"stereotypical" "victimization" "extermination" "transposition"
"observatories" "discontinuous" "heartbreaking" "reconstituted"
"incrementally" "maxillofacial" "incapacitated" "counterstrike")
("bacteriophage" "stabilisation" "dermatologist" "orchestration"
"uncomplicated" "confirmations" "accumulations" "revolutionize"
"piezoelectric" "discoloration" "supplementing" "illuminations"
"consecutively" "amitriptyline" "sportsmanship" "rearrangement"
"preconditions" "preprocessing" "consultancies" "unaccompanied"
"cerebrospinal" "inconceivable" "combinatorics" "parameterized"
"manageability" "infringements" "disillusioned" "preoccupation"
"inexpensively" "argumentation" "radionuclides" "fractionation"
"displacements" "intermountain" "immunotherapy" "categorically"
"defibrillator" "disrespectful" "unequivocally" "gynecologists"
"neurosciences" "librarianship" "malformations" "singularities"
"complementing" "conspicuously" "phospholipase" "peculiarities"
"involuntarily" "quarterfinals" "rectification" "stratospheric"
"nonparametric" "approximating" "customisation" "conglomerates"
"dehumidifiers" "sensitization" "rehabilitated" "superstitions"
"unambiguously" "instabilities" "reforestation" "paradoxically"
"introspective" "repeatability" "reminiscences" "subordination"
"meningococcal" "disinterested" "transgression" "campylobacter"
"choreographed" "retroactively" "professorship" "neuroblastoma"
"hermaphrodite" "phenylephrine" "discontinuing" "intergalactic"
"lactobacillus" "expeditiously" "antipsychotic" "disconnecting"
"predominately" "operationally" "stratigraphic" "accelerometer"
"dimensionless" "contractually" "meteorologist" "superstitious"
"cardiologists" "vegetarianism" "authenticator" "trigonometric"
"disaggregated" "congratulates" "phospholipids" "disinfectants"
"randomization" "ergonomically" "airworthiness" "juxtaposition"
"superposition" "chrysanthemum" "fortification" "unconstrained"
"materialistic" "congresswoman" "transcendence" "statisticians"
"decarboxylase" "provisionally" "underpinnings" "undeliverable"
"undistributed" "retransmitted" "geometrically" "expressionism"
"morphogenesis" "screenwriters" "misunderstand" "painstakingly"
"proliferative" "straighteners" "repositioning" "embellishment"
"contradicting" "impersonation" "decentralised" "standardizing"
"survivability" "spectacularly" "condescending" "reappointment"
"geomorphology" "uninteresting" "telemarketers" "nonconforming"
"distributable" "pathogenicity" "matriculation" "photoelectric"
"proclamations" "argumentative" "subparagraphs" "intelligences"
"expropriation" "oscilloscopes" "supersymmetry" "gynecological"
"supercritical" "biomechanical" "featherweight" "assertiveness"
"multivitamins" "postgraduates" "candleholders" "metronidazole"
"astonishingly" "falsification" "potentiometer" "concentrators"
"intramuscular" "synchronicity" "recirculation" "spectrometers"
"connectedness" "pharmacologic" "fantastically" "videocassette"
"scintillation" "homeschoolers" "protectionism" "phenobarbital"
"photochemical" "distinctively" "bootstrapping" "glycosylation"
"nitroglycerin" "proliferating" "irreplaceable" "monochromatic"
"disconcerting" "appropriating" "circumvention" "encapsulating"
"misadventures" "anticoagulant" "rediscovering" "undergarments"
"prospectively" "impersonators" "hydrocephalus" "verifications"
"nutritionally" "carbamazepine" "insensitivity" "transportable"
"quartermaster" "suppositories" "inevitability" "desegregation"
"educationally" "contaminating" "infinitesimal" "superficially"
"reprehensible" "indescribable" "inhomogeneous" "underutilized"
"entomological" "preconception" "affirmatively" "ferromagnetic"
"microeconomic" "summarization" "underclassman" "agglomeration"
"trainspotting" "spokespersons" "commercialize" "photovoltaics"
"bureaucracies" "galactosidase" "ideologically" "hydrodynamics"
"businesswoman" "dismemberment" "immunosorbent" "consternation"
"intravenously" "magnetosphere" "decaffeinated" "impracticable"
"tyrannosaurus" "transplanting" "breathability" "ornamentation"
"pornographers" "uncomfortably" "consolidators" "battlegrounds"
"restaurateurs" "antihistamine" "nonrefundable" "intercellular"
"motorcyclists" "streptococcal" "incriminating" "magnificently"
"nationalistic" "energetically" "necessitating" "mineralogical"
"hallucination" "kindergartens" "videorecorder" "hyperglycemia"
"destabilizing" "perfectionist" "percussionist" "sociocultural"
"disintegrated" "forgetfulness" "normalisation" "overestimated"
"conformations" "knickerbocker" "acidification" "regurgitation")
("continuations" "dictatorships" "assistantship" "prosecutorial"
"evolutionists" "genitourinary" "handkerchiefs" "mitochondrion"
"investigatory" "pronouncement" "wallcoverings" "contralateral"
"administrated" "inclusiveness" "discriminates" "reexamination"
"interferences" "syntactically" "marketability" "commendations"
"signification" "protectionist" "formalization" "blacksmithing"
"calcification" "intravascular" "comprehending" "inexhaustible"
"inflorescence" "demonstrative" "psychosomatic" "interrogators"
"neurotoxicity" "cyanobacteria" "geostationary" "fertilisation"
"inconsiderate" "participative" "interlocutory" "prostatectomy"
"reprogramming" "hieroglyphics" "circumscribed" "mortification"
"impermissible" "tetrachloride" "sleeplessness" "expandability"
"authentically" "supranational" "appurtenances" "uncircumcised"
"lymphoblastic" "orthodontists" "deductibility" "neurosurgical"
"merchandisers" "domestication" "unpretentious" "heartbreakers"
"intermissions" "inconspicuous" "toxoplasmosis" "interregional"
"civilisations" "renegotiation" "presbyterians" "unadulterated"
"afforestation" "prohibitively" "phosphorylase" "recirculating"
"grandfathered" "leishmaniasis" "monotonically" "counterattack"
"posttraumatic" "thermocouples" "transmutation" "precipitating"
"authenticates" "schoolteacher" "transmissible" "arteriovenous"
"sterilisation" "commercialism" "digestibility" "corticotropin"
"unaccountable" "substantively" "linearization" "uncooperative"
"microvascular" "scintillating" "confectionary" "microorganism"
"counterweight" "refrigerating" "patentability" "grammatically"
"specificities" "receptionists" "subcontracted" "stoichiometry"
"ineligibility" "ferroelectric" "discographies" "heterosexuals"
"teleportation" "pyrophosphate" "conceptualize" "commonalities"
"poliomyelitis" "backgrounders" "hydrogenation" "transpersonal"
"transmittance" "industrialist" "frequentation" "hallucinogens"
"photoreceptor" "symmetrically" "reconsidering" "extrajudicial"
"morphogenetic" "motherfuckers" "powerlessness" "tranquilizers"
"embryogenesis" "reformulation" "osteomyelitis" "articulations"
"mononucleosis" "transpiration" "disincentives" "reverberation"
"apprehensions" "shareholdings" "schematically" "accelerations"
"actualization" "soundproofing" "biogeographic" "particularity"
"globetrotters" "thoroughfares" "reconfiguring" "amniocentesis"
"interruptible" "thunderstruck" "procrastinate" "parenthetical"
"victimisation" "sarcastically" "misstatements" "micronutrient"
"reorientation" "disheartening" "synchronously" "uncompensated"
"acculturation" "ecotoxicology" "extrapolating" "confectioners"
"theologically" "personalizing" "methylmercury" "interpolating"
"diametrically" "psychodynamic" "acupuncturist" "encroachments"
"sadomasochism" "determinative" "disqualifying" "discriminator"
"republicanism" "somatosensory" "individualist" "thermonuclear"
"photoelectron" "glorification" "irrepressible" "interrogating"
"nondisclosure" "complimenting" "mechanization" "multivariable"
"reaffirmation" "noradrenaline" "circumventing" "multicellular"
"unjustifiable" "electrocution" "functionaries" "concessionary"
"foreshadowing" "anachronistic" "impersonating" "uncoordinated"
"reprographics" "expressionist" "acrylonitrile" "filmographies"
"indeterminacy" "irrationality" "unpleasurable" "incommunicado"
"inventiveness" "corroboration" "orchestrating" "silvicultural"
"equilibration" "interrogative" "quadrilateral" "bougainvillea"
"infallibility" "neoliberalism" "frighteningly" "seismological"
"reestablished" "imaginatively" "isoproterenol" "malabsorption"
"temperamental" "multispectral" "adjustability" "flexibilities"
"concomitantly" "experimenters" "pseudoscience" "archeologists"
"orthogonality" "rationalizing" "unexplainable" "antiterrorism"
"carboniferous" "nephrologists" "underemployed" "incrimination"
"palaeontology" "subpopulation" "proportioning" "dispassionate"
"unrecoverable" "exterminating" "relinquishing" "triamcinolone"
"housebreaking" "untrustworthy" "compensations" "rollerblading"
"coeducational" "unrepresented" "spiritualized" "conflagration"
"transshipment" "undercarriage" "immunologists" "unimplemented"
"holidaymakers" "unsympathetic" "condescension" "troublemakers"
"abolitionists" "preprogrammed" "algebraically" "unreliability"
"stylistically" "associativity" "interspecific" "accoutrements")
("assemblywoman" "southwesterly" "foreknowledge" "semiclassical"
"metamorphoses" "northeasterly" "histochemical" "biocompatible"
"extragalactic" "protectorates" "agrochemicals" "hybridisation"
"hematological" "northwesterly" "strangulation" "unimaginative"
"swashbuckling" "hydraulically" "periodontitis" "instantiating"
"nullification" "housecleaning" "invincibility" "rapprochement"
"arboriculture" "exacerbations" "superchargers" "dissimilarity"
"episcopalians" "imperceptible" "topologically" "reversibility"
"stormtroopers" "mouthwatering" "indefatigable" "revolutionise"
"agglutination" "hematologists" "recalculation" "terminologies"
"perfectionism" "catecholamine" "structuralism" "neuraminidase"
"serendipitous" "computability" "decongestants" "thermoforming"
"combinational" "mycobacterial" "attentiveness" "legislatively"
"proteoglycans" "sedimentology" "communautaire" "neuropeptides"
"tumorigenesis" "pharmacopoeia" "valedictorian" "chromatograph"
"proficiencies" "insubstantial" "bioflavonoids" "premenopausal"
"parallelogram" "preamplifiers" "cryptanalysis" "corroborating"
"leptospirosis" "disfigurement" "rhododendrons" "unilateralism"
"schadenfreude" "nortriptyline" "endopeptidase" "deconstructed"
"skateboarders" "intermarriage" "aggiornamento" "flabbergasted"
"spectrometric" "protestations" "cytopathology" "outperforming"
"entanglements" "subsidization" "adjudications" "paternalistic"
"ventriloquist" "directorships" "steganography" "southeasterly"
"uncollectible" "socialisation" "diaphragmatic" "thoroughbreds"
"characterises" "granulomatous" "pervasiveness" "hydroxylation"
"antisymmetric" "nitrification" "contractility" "semiautomatic"
"proselytizing" "unfashionable" "untransformed" "observability"
"masterclasses" "pharmaceutics" "unforeseeable" "officeholders"
"ratifications" "conservatoire" "cycloheximide" "aspergillosis"
"interjections" "automorphisms" "undisciplined" "disinvestment"
"dimensionally" "interrogatory" "vocalizations" "photoemission"
"hypercalcemia" "dramatization" "sigmoidoscopy" "inflexibility"
"hydrogeologic" "arbitrariness" "copyrightable" "cholecystitis"
"denunciations" "physiologists" "nonconformity" "representable"
"psychophysics" "uninhabitable" "nonstructural" "communitarian"
"microanalysis" "hemispherical" "indoctrinated" "scriptwriting"
"dispositional" "anaesthetists" "chlamydomonas" "geoscientists"
"disassembling" "pentobarbital" "prepositional" "intracerebral"
"circumstellar" "counteracting" "subassemblies" "paediatrician"
"neurosurgeons" "transcultural" "concatenating" "polyurethanes"
"telecommuters" "overstatement" "audiocassette" "geophysicists"
"inquisitively" "physiographic" "multicoloured" "overwintering"
"birefringence" "interpretable" "motherfucking" "presumptively"
"homomorphisms" "interrelation" "psychometrics" "fictionalized"
"unappreciated" "criminologist" "convalescence" "preliminarily"
"choreographic" "delinquencies" "postmodernist" "psychoanalyst"
"ascertainable" "localizations" "incorruptible" "businesswomen"
"undercurrents" "heterotrophic" "criminalizing" "terephthalate"
"fingerprinted" "unconditioned" "monochromator" "equivalencies"
"bromocriptine" "neurochemical" "bioenergetics" "staphylococci"
"hemagglutinin" "pragmatically" "directionally" "ascertainment"
"cartographers" "surreptitious" "integrability" "microcircuits"
"containerized" "sanctimonious" "turbochargers" "contortionist"
"outstandingly" "sensitisation" "hematopoiesis" "functionalism"
"nonstationary" "unintelligent" "cryptozoology" "propagandists"
"structuralist" "cosmetologist" "isomerization" "peptidoglycan"
"hyperhidrosis" "universalists" "nonconformist" "demyelinating"
"individuation" "electroplated" "misperception" "nonclassified"
"salmonellosis" "kaleidoscopic" "hallucinating" "consanguinity"
"exterminators" "exaggerations" "progressivism" "unobtrusively"
"metallization" "vitrification" "demultiplexer" "grandstanding"
"cheeseburgers" "particleboard" "precipitously" "preproduction"
"interactional" "associational" "refractometer" "antiepileptic"
"underreported" "problematical" "lexicographic" "interlocutors"
"phencyclidine" "recalibration" "cruiserweight" "hypoglycaemia"
"convolutional" "extratropical" "demilitarized" "metamorphosed"
"imperialistic" "electromagnet" "condemnations" "tonsillectomy"
"norethindrone" "indifferently" "intransigence" "reinvigorated")
("dispossession" "recompilation" "frustratingly" "statesmanship"
"sensorineural" "microcassette" "counterclaims" "misrepresents"
"antipersonnel" "parenthesized" "substructures" "polarizations"
"supplications" "organogenesis" "astronautical" "democratizing"
"irresponsibly" "defensiveness" "reinterpreted" "transgressive"
"interposition" "satisfactions" "randomisation" "incredulously"
"inefficiently" "reproducibles" "sharpshooters" "uncompetitive"
"recommendable" "optimisations" "humanitarians" "teleconverter"
"decontaminate" "glucuronidase" "dollarization" "retroactivity"
"intraspecific" "nonfunctional" "tortoiseshell" "oropharyngeal"
"photographies" "globetrotting" "streptokinase" "shrinkwrapped"
"anthroposophy" "overshadowing" "decompressing" "exclusiveness"
"steadfastness" "mummification" "inexpressible" "reintroducing"
"conquistadors" "repossessions" "commutativity" "submillimeter"
"internalizing" "archaeopteryx" "microscopical" "compressional"
"augmentations" "nonperforming" "dismantlement" "nonindigenous"
"swashbucklers" "guardianships" "transurethral" "gonadotropins"
"haemodialysis" "endonucleases" "gynaecologist" "correlational"
"heterozygotes" "remanufacture" "masculinities" "tetracyclines"
"psychobiology" "supernumerary" "indiscretions" "unpredictably"
"cephalosporin" "thyroglobulin" "imperceptibly" "underwhelming"
"overestimates" "unquestioning" "worthlessness" "synthetically"
"uninformative" "detectability" "reactionaries" "acetazolamide"
"macromolecule" "cryopreserved" "transgressors" "generalizable"
"trophoblastic" "upperclassmen" "homeomorphism" "cyanoacrylate"
"geochronology" "subcomponents" "intermingling" "hallucinatory"
"penicillamine" "dangerousness" "dispensations" "irretrievably"
"overabundance" "storyboarding" "submandibular" "spiritualists"
"misidentified" "inhomogeneity" "unfamiliarity" "believability"
"groundskeeper" "anthropometry" "metabolically" "carryforwards"
"countersigned" "projectionist" "impermissibly" "underclassmen"
"formalisation" "familiarizing" "syllabication" "oceanographer"
"radiographers" "devastatingly" "thermosetting" "miscalculated"
"extravagantly" "interchanging" "improbability" "provocatively"
"affenpinscher" "muzzleloading" "parallelizing" "malfunctioned"
"filibustering" "immunisations" "accommodative" "horsefeathers"
"improprieties" "subdiscipline" "photodetector" "backscattered"
"intermetallic" "eventualities" "catalytically" "hermeneutical"
"reverberating" "destructively" "theoreticians" "anticipations"
"ornithologist" "quasiparticle" "multiemployer" "reapplication"
"orientational" "pyrimethamine" "ministrations" "fingerpicking"
"supercollider" "commercialise" "translocating" "vectorization"
"isocarboxazid" "assassinating" "misclassified" "oystercatcher"
"individualize" "enterocolitis" "photocopiable" "preceptorship"
"lackadaisical" "functionalist" "unserviceable" "crystallinity"
"periodontists" "eigenfunction" "clandestinely" "overstretched"
"neurovascular" "requisitioned" "homogeneously" "daguerreotype"
"disintegrates" "densification" "thyroidectomy" "insurrections"
"stenographers" "beatification" "biochemically" "premeditation"
"parainfluenza" "substantiates" "calligraphers" "semifinalists"
"intercalation" "microwaveable" "entomologists" "postponements"
"adventuresome" "intrapersonal" "destabilising" "nondegenerate"
"ethnocentrism" "bioengineered" "inviolability" "microsurgical"
"extravasation" "sportswriters" "fermentations" "afterthoughts"
"chateaubriand" "hundredweight" "kaleidoscopes" "appreciations"
"ambassadorial" "cartilaginous" "chromatograms" "unjustifiably"
"aminophylline" "unpasteurized" "desensitizing" "nomenclatural"
"standardising" "hypochondriac" "televangelist" "scriptwriters"
"memorializing" "substitutable" "predilections" "enzymatically"
"postemergence" "adrenalectomy" "noradrenergic" "reallocations"
"gerontologist" "unsatisfiable" "encouragingly" "unenlightened"
"wholesomeness" "nonaffiliated" "thermogenesis" "detrimentally"
"arteriography" "phycoerythrin" "overconfident" "integumentary"
"unconquerable" "associateship" "toxicologists" "nonmembership"
"renegotiating" "industrialism" "musicological" "compartmental"
"tessellations" "pneumatically" "minicomputers" "supercharging"
"architectonic" "synchronising" "phytochemical" "swordsmanship"
"stereographic" "mechanisation" "connectionism" "encyclopaedic")
("miscegenation" "ungrammatical" "monstrosities" "hydroperoxide"
"phosphorylate" "bioprocessing" "scarification" "knuckleduster"
"antimalarials" "speakerphones" "cabinetmaking" "nongovernment"
"chlorobenzene" "concertmaster" "inspectorates" "externalizing"
"ribonucleases" "intermittency" "disproportion" "embrittlement"
"sexploitation" "radiochemical" "verifiability" "beneficiation"
"overpopulated" "nondeductible" "magnetometers" "brokenhearted"
"disparagement" "unmentionable" "unimpeachable" "underpayments"
"bibliographer" "amalgamations" "paleomagnetic" "therapeutical"
"demyelination" "electrophilic" "northeastward" "supermajority"
"overdeveloped" "predominating" "voluntariness" "sophisticates"
"incandescence" "incorporators" "churchwardens" "electromotive"
"hypersurfaces" "bouillabaisse" "auctioneering" "commencements"
"impulsiveness" "irretrievable" "climatologist" "incontestable"
"ventriloquism" "overprotected" "contextualize" "unselfishness"
"multitudinous" "recompression" "artificiality" "reflectometry"
"transgressing" "foraminiferal" "reciprocation" "unspectacular"
"subordinating" "subsidisation" "treacherously" "disassociated"
"oligopolistic" "existentially" "inflammations" "gonadotrophin"
"constructible" "mobilizations" "redistributes" "transaminases"
"neoclassicism" "underachiever" "pontificating" "antispasmodic"
"cabinetmakers" "polytechnical" "sensitiveness" "thoroughgoing"
"rhodochrosite" "personalising" "superimposing" "irrecoverable"
"transferrable" "effervescence" "corroborative" "crossbreeding"
"hyaluronidase" "recrimination" "reassignments" "physostigmine"
"ceruloplasmin" "thoughtlessly" "mispronounced" "mischievously"
"nondecreasing" "masterminding" "appropriators" "unsentimental"
"scintillators" "pedagogically" "scholasticism" "cannibalistic"
"indescribably" "anaesthetized" "palaeoecology" "reflectometer"
"principalship" "hydroxylamine" "nonesterified" "disentangling"
"longsuffering" "rationalising" "dimethylamine" "spathiphyllum"
"prophetically" "muzzleloaders" "radiolocation" "arachnophobia"
"speculatively" "interbreeding" "chromospheric" "insupportable"
"gastrocnemius" "autochthonous" "allergenicity" "retrogression"
"stratocumulus" "periodization" "straitjackets" "unproblematic"
"eavesdroppers" "progressivity" "unflinchingly" "narrowcasting"
"commonwealths" "tranquilizing" "reimportation" "actinomycetes"
"huckleberries" "transthoracic" "intercessions" "grantsmanship"
"disrespecting" "reduplication" "noncontiguous" "balkanization"
"counterfeited" "macroglobulin" "consistencies" "thermographic"
"knowledgeably" "periodicities" "incorrectness" "conceptualise"
"insectivorous" "marginalizing" "sphingomyelin" "premedication"
"microphysical" "reliabilities" "dramatisation" "antirheumatic"
"disfunctional" "housetraining" "passionflower" "mucocutaneous"
"childproofing" "inferentially" "rationalistic" "seismologists"
"efflorescence" "thrombophilia" "northwestward" "quadratically"
"iontophoresis" "speleological" "misalignments" "compartmented"
"inquisitorial" "pneumonectomy" "anticlimactic" "intergranular"
"newsgathering" "ecophysiology" "telencephalon" "intercropping"
"introgression" "anticlockwise" "disaccharides" "revolutionist"
"instrumenting" "materializing" "myelofibrosis" "replicability"
"ontologically" "reutilization" "reticulocytes" "cyclodextrins"
"signalization" "indiscernible" "tantalizingly" "mesencephalon"
"unsuitability" "diagnostician" "factorisation" "agriculturist"
"syringomyelia" "dishonourable" "bachelorettes" "intrusiveness"
"heuristically" "unsupportable" "glycopeptides" "mystification"
"macronutrient" "regurgitating" "nonjudgmental" "postinfection"
"abortifacient" "noninfectious" "epicondylitis" "misallocation"
"rollerskating" "antisubmarine" "noncombatants" "trinucleotide"
"extravaganzas" "hypertensives" "lymphadenitis" "preternatural"
"dinitrophenol" "ineffectively" "interlanguage" "microfilament"
"serologically" "tablespoonful" "confraternity" "residentially"
"crystallizing" "anthelmintics" "sympathectomy" "constrictions"
"nonresponsive" "aestheticians" "aggiornamenti" "dissimulation"
"underachieved" "theatricality" "degranulation" "threateningly"
"quasicrystals" "pharmacognosy" "gesticulating" "benzimidazole"
"reassessments" "caricaturists" "unaccountably" "structuration"
"untraditional" "nucleoprotein" "radiolabelled" "deodorization")
("overvaluation" "crisscrossing" "deontological" "councilperson"
"insubordinate" "nonproductive" "directionless" "retrospection"
"unmistakeable" "psychotropics" "professoriate" "ceremoniously"
"posttreatment" "tenosynovitis" "unexceptional" "cosmeceutical"
"containerised" "reclassifying" "sulfonylureas" "chemisorption"
"schoolmasters" "demineralized" "distortionary" "cysticercosis"
"sharecroppers" "enteroviruses" "phenothiazine" "nonimmigrants"
"atherogenesis" "ethnographies" "thiabendazole" "supervenience"
"fluorocarbons" "smallholdings" "interdistrict" "intrathoracic"
"descriptively" "receptiveness" "micrographics" "recalculating"
"dischargeable" "turbocharging" "segmentations" "reflexologist"
"territorially" "crosscurrents" "counterpoints" "overemphasize"
"triethylamine" "confessionals" "accessorizing" "carnivalesque"
"solemnization" "semiempirical" "questioningly" "anthraquinone"
"radioactively" "kindergartner" "metropolitans" "metalliferous"
"precipitators" "ventrolateral" "synchronizers" "hyperglycemic"
"floodlighting" "numerological" "cinematograph" "winterization"
"metallography" "biopsychology" "tradespersons" "catastrophism"
"mountainsides" "uninterpreted" "cycloaddition" "discomforting"
"insensibility" "thanksgivings" "unexperienced" "laughingstock"
"upgradability" "concupiscence" "editorialized" "nonpathogenic"
"megaloblastic" "troubleshoots" "unilateralist" "anaerobically"
"reformulating" "phytotoxicity" "attributional" "companionable"
"documentarian" "subcommission" "significative" "supplementals"
"excommunicate" "hypothesizing" "flamethrowers" "matriculating"
"sulfacetamide" "superordinate" "actinomycosis" "methemoglobin"
"lexicographer" "cyclohexanone" "wordprocessor" "transformable"
"boardinghouse" "southeastward" "superfluidity" "statelessness"
"cytochemistry" "custodianship" "conservancies" "sharecropping"
"misdemeanours" "christianized" "clockwatchers" "steroidogenic"
"industriously" "bioelectrical" "blastomycosis" "sensationally"
"creditability" "interstitials" "distressingly" "spectinomycin"
"incompatibles" "reacquisition" "mobilisations" "resurrections"
"appealability" "confiscations" "declaratively" "ecclesiastics"
"nonnegotiable" "lithographers" "antiterrorist" "petrophysical"
"arachnoiditis" "solderability" "measurability" "expectoration"
"transfections" "unsurpassable" "psychokinetic" "reproachfully"
"offensiveness" "hyperuricemia" "decompensated" "cryogenically"
"blepharospasm" "disgracefully" "psychokinesis" "felicitations"
"indisposition" "warmheartedly" "taxonomically" "serodiagnosis"
"serialisation" "rehabilitator" "antigenically" "superfamilies"
"disorientated" "prosthodontic" "vulcanization" "elephantiasis"
"magnetisation" "stromatolites" "proscriptions" "reauthorizing"
"carpetbaggers" "cardiographer" "metastability" "anaphylactoid"
"proteinaceous" "equipotential" "speechwriters" "confabulation"
"cardinalities" "spermatocytes" "ethnographers" "incongruities"
"nomenclatures" "musicologists" "computerizing" "interobserver"
"cosmopolitans" "microlighting" "thoracolumbar" "scintigraphic"
"fascinatingly" "promiscuously" "polybutadiene" "disparagingly"
"incarcerating" "autocatalytic" "deprogramming" "redefinitions"
"multiparticle" "pointlessness" "imperturbable" "reconstructor"
"regimentation" "thermotherapy" "dibenzofurans" "deceitfulness"
"propositioned" "gastronomical" "unwarrantable" "geoscientific"
"oversaturated" "uncorrectable" "kinematically" "microclimates"
"embryological" "adenoidectomy" "nightclubbing" "microcapsules"
"receiverships" "nonresponders" "herpesviruses" "methacrylates"
"undereducated" "variabilities" "nonconference" "supernaturals"
"restrictively" "infeasibility" "protuberances" "sulfanilamide"
"negotiability" "polyethylenes" "disinhibition" "triphosphates"
"hypertrophied" "generalissimo" "recomputation" "calculational"
"commiseration" "redescription" "overqualified" "maladjustment"
"alphanumerics" "nonconsensual" "benthopelagic" "multitalented"
"superheroines" "imponderables" "symbolization" "particularism"
"recapitulates" "prevarication" "mesencephalic" "decriminalize"
"remonstrances" "reintegrating" "quasiperiodic" "armamentarium"
"penicillinase" "nonregistered" "newsmagazines" "triangulating"
"incongruously" "agreeableness" "preprocessors" "provincialism"
"impoverishing" "realizability" "interferogram" "stratovolcano")
("oversensitive" "adiabatically" "multicurrency" "hereditaments"
"microinjected" "palynological" "extravagances" "chronobiology"
"recapitulated" "malacological" "stereoisomers" "cosponsorship"
"understaffing" "exploitations" "illocutionary" "nostalgically"
"discriminants" "domesticating" "southwestward" "hypothecation"
"expostulation" "commandeering" "concentricity" "microbiologic"
"millionairess" "metallurgists" "selectivities" "interparticle"
"actualisation" "galactosamine" "polychromatic" "explosiveness"
"retrogressive" "hydrocolloids" "merchandizing" "unforgettably"
"tricarboxylic" "secessionists" "preemployment" "unrelentingly"
"neurogenetics" "educationists" "circumcisions" "hypoglycaemic"
"disubstituted" "anaesthetised" "endomorphisms" "archbishopric"
"brachiosaurus" "naphthylamine" "preventatives" "zooxanthellae"
"stationmaster" "religiousness" "inaugurations" "expansiveness"
"glaciological" "osteopetrosis" "alstroemerias" "fossiliferous"
"retrenchments" "everlastingly" "hemicellulose" "electrologist"
"silkscreening" "contextualise" "hypermobility" "colloquialism"
"whithersoever" "neonatologist" "verbalization" "expropriating"
"toothbrushing" "dehumidifying" "laryngoscopes" "cryptographer"
"planetesimals" "degradability" "maliciousness" "disambiguated"
"microhabitats" "primogeniture" "asthenosphere" "blandishments"
"micromanaging" "nonuniformity" "stepdaughters" "industrialize"
"deliciousness" "lactoglobulin" "millennialism" "invitationals"
"psychosurgery" "versification" "misinterprets" "readjustments"
"incontestably" "geriatricians" "purifications" "sportscasters"
"childlessness" "foreshortened" "cohomological" "nonperishable"
"coordinations" "transmittable" "disempowering" "superannuated"
"significances" "diffusivities" "dysmenorrhoea" "autocephalous"
"megakaryocyte" "bildungsroman" "spectrographs" "ignominiously"
"preadolescent" "eccentrically" "granularities" "intercalating"
"corticospinal" "familiarising" "aboriginality" "manufactories"
"cinematically" "faithlessness" "dieffenbachia" "psychohistory"
"anticommunist" "cannibalizing" "approximative" "bioconversion"
"isolationists" "unremittingly" "accouterments" "epistemically"
"transliterate" "infiltrations" "equestrianism" "seaworthiness"
"ultramarathon" "predestinated" "depreciations" "unsubstantial"
"bibliotherapy" "nonexpendable" "considerately" "weightlifters"
"inexpressibly" "condensations" "deformability" "cylindrically"
"overburdening" "senselessness" "pontification" "semisynthetic"
"prevocational" "nationalizing" "metaphysician" "nonforfeiture"
"prejudicially" "archaeologies" "extravascular" "microfilariae"
"mistranslated" "inconceivably" "astrodynamics" "interspersing"
"superintended" "counteraction" "phosphokinase" "preindustrial"
"ectoparasites" "fortuneteller" "changeability" "unarticulated"
"microswitches" "improvisatory" "diphenylamine" "archimandrite"
"sovereignties" "hexamethonium" "remunerations" "discreditable"
"nephropathies" "spermatogonia" "resynchronize" "antiparticles"
"chromosomally" "gametogenesis" "statesmanlike" "carbonization"
"slipstreaming" "nonscientific" "bacteriologic" "pharmacopeial"
"preservations" "thenceforward" "recalcitrance" "intuitiveness"
"bioequivalent" "shortchanging" "nonincreasing" "nephelometric"
"unsymmetrical" "climatologies" "overachieving" "conceptualism"
"reformatories" "anticorrosion" "imprisonments" "chemoreceptor"
"agglomerative" "polyribosomes" "multivibrator" "insensitively"
"preregistered" "semipermeable" "spasmodically" "editorialists"
"intermembrane" "allegorically" "prophylactics" "isoantibodies"
"labyrinthitis" "commensurable" "precipitately" "unceremonious"
"mineralogists" "obliviousness" "expectational" "enigmatically"
"unthreatening" "resistivities" "densitometric" "sesquiterpene"
"gerrymandered" "extortionists" "walkingsticks" "governorships"
"clairaudience" "fonctionnaire" "admonishments" "pronounceable"
"roentgenology" "dialectically" "cytologically" "infuriatingly"
"carboxylation" "psychographic" "shamelessness" "remorselessly"
"hypervelocity" "metabolizable" "colonoscopies" "anticommunism"
"behaviourally" "rehabilitates" "incompetently" "extensiveness"
"wonderfulness" "counterfeiter" "disequilibria" "amphitheaters"
"alphabetizing" "sentimentally" "checkweighers" "metachromatic"
"ineffectually" "spondylolysis" "lightfastness" "systematizing")
("valvuloplasty" "invertibility" "unemancipated" "ethanolamines"
"romanticizing" "situationally" "implantations" "revaccination"
"perspicacious" "underprepared" "monofilaments" "isometrically"
"spermatogenic" "weathercaster" "mesotheliomas" "nonpermissive"
"picturesquely" "nonconductive" "preganglionic" "inclinometers"
"recrudescence" "dinucleotides" "flavoproteins" "psychrometric"
"reasonability" "nonindustrial" "quadripartite" "metastasizing"
"sportsmanlike" "endolymphatic" "resuscitating" "irrelevancies"
"pusillanimous" "equilibrating" "magnetostatic" "butterfingers"
"distinguisher" "quadruplicate" "machinability" "outspokenness"
"referentially" "phylloquinone" "entrenchments" "impersonality"
"sacrificially" "tantalisingly" "canthaxanthin" "decelerations"
"informalities" "troublemaking" "invalidations" "totalitarians"
"seismographic" "commerciality" "monosyllables" "surveillances"
"undescribable" "grandiloquent" "greenskeepers" "catechumenate"
"participators" "seductiveness" "biculturalism" "intracavitary"
"allochthonous" "unchallenging" "nonhomologous" "foregrounding"
"magnanimously" "semipermanent" "preponderates" "fossilization"
"transversally" "managerialism" "landownership" "cephalometric"
"casualisation" "nightwatchman" "stepparenting" "pathognomonic"
"patternmakers" "modifiability" "prepositioned" "degenerations"
"thunderstrike" "interindustry" "excessiveness" "administrates"
"homoeroticism" "dingleberries" "transversions" "geotechnology"
"dissociations" "lymphocytosis" "breathalyzers" "unremunerated"
"disallowances" "squeamishness" "epileptogenic" "unforgiveness"
"enculturation" "secretagogues" "commiserating" "amortizations"
"indeterminism" "halfheartedly" "superclusters" "intermediated"
"outmaneuvered" "reestablishes" "intoxications" "endosymbionts"
"backgrounding" "chargeability" "densitometers" "dermatophytes"
"circumspectly" "bronchoscopic" "criminalising" "characterless"
"marketization" "moneychangers" "paramyxovirus" "overproducing"
"multifilament" "overexploited" "disseminators" "sportspersons"
"democratising" "haemorrhaging" "demographical" "oxyhemoglobin"
"blackcurrants" "reinnervation" "lymphosarcoma" "proselytising"
"internalising" "antiparasitic" "generalisable" "disfranchised"
"axiomatically" "cryptanalytic" "dissatisfying" "prognosticate"
"diastereomers" "recomposition" "spectatorship" "glioblastomas"
"overachievers" "obsessiveness" "underexposure" "circumstanced"
"heartlessness" "superhighways" "photoperiodic" "belligerently"
"patriotically" "aristocracies" "haemophiliacs" "decapitations"
"precapitalist" "amphitheatres" "watercolorist" "sequentiality"
"discontiguous" "resuscitative" "ultraviolence" "apportionable"
"intercommunal" "deformational" "octogenarians" "indefatigably"
"repatriations" "megalopolitan" "irrationalism" "indispensably"
"informatively" "unpasteurised" "unspecialized" "remeasurement"
"brutalization" "basidiomycete" "copartnership" "uncomplaining"
"circumscribes" "draftsmanship" "nonassessable" "pretentiously"
"photoproducts" "forementioned" "conservations" "tenderhearted"
"underspending" "exaggeratedly" "vernalization" "pulverization"
"symbiotically" "chairmanships" "underclothing" "countermanded"
"upperclassman" "annihilations" "recalibrating" "endosymbiotic"
"structureless" "fluorochromes" "perfunctorily" "sledgehammers"
"nitrobenzenes" "underutilised" "predesignated" "epiphenomenon"
"uncleanliness" "fictionalised" "collectivists" "quadriplegics"
"refractometry" "instinctually" "phototoxicity" "attainability"
"groundstrokes" "extendibility" "producibility" "improvidently"
"baculoviruses" "radiolabeling" "idealizations" "propagandized"
"tricentennial" "demilitarised" "antinomianism" "reinvestments"
"dissimilatory" "restauranteur" "healthfulness" "dramaturgical"
"elasmobranchs" "bewilderingly" "reverentially" "aromatization"
"chromatically" "spellcheckers" "secretiveness" "superlatively"
"bloodcurdling" "doubleheaders" "nonrefillable" "nonautonomous"
"pluralization" "aldosteronism" "neurofibromas" "stereological"
"ratiocination" "marginalising" "seroconverted" "superabundant"
"hypercritical" "extensionists" "rejectionists" "defensibility"
"beginningless" "infraspecific" "rationalities" "deferentially"
"monoaminergic" "resubmissions" "combativeness" "nonbiological"
"isoelectronic" "cytodiagnosis" "unconformably")) | 44,876 | Common Lisp | .lisp | 680 | 63.008824 | 66 | 0.799778 | jaredkrinke/thirteen-letters | 3 | 0 | 0 | AGPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 81f8f3059eb32b0ee41f77ab049de0b0ad043e1a30fd395deb0ea62f384cdd01 | 18,793 | [
-1
] |
18,794 | shared.lisp | jaredkrinke_thirteen-letters/shared.lisp | (defpackage :13l-shared
(:documentation "Package for sharing code amongst Thirteen Letters console, server, and web versions")
(:nicknames :13l)
(:use :cl)
(:export #:*bucketed-words*
#:*difficulty-buckets*
#:*puzzle-length*
#:char-repeat
#:get-letter-counts
#:get-random
#:initialize-random-state
#:letter-subset-p
#:shuffle
#:shuffle-string
#:scramble
#:unscramble))
(in-package :13l)
(defparameter *puzzle-length* 13)
(defparameter *difficulty-buckets* 10)
(defmacro define-bucketed-words ()
"Injects word list at compile time"
(with-open-file (stream "data.lisp")
`(defparameter *bucketed-words* ',(read stream))))
(define-bucketed-words)
(defun initialize-random-state ()
"Initializes the random number generator"
(setf *random-state* (make-random-state t)))
(defun get-random (sequence)
"Randomly selects an item from SEQUENCE"
(nth (random (length sequence)) sequence))
(defun fully-scrambled-p (scrambled solution)
"Returns NIL if any character in SCRAMBLED matches a letter in SOLUTION"
(loop for scrambled-character across scrambled
for solution-character across solution
when (char-equal scrambled-character solution-character) do (return nil)
finally (return t)))
(defun shuffle (sequence &rest rest &key &allow-other-keys)
"Returns a copy of SEQUENCE (as an array) with its elements shuffled (note: extra arguments are passed to MAKE-ARRAY)"
(let* ((length (length sequence))
(array (apply #'make-array length :initial-contents sequence rest)))
(loop for i upfrom 0
for n downfrom length
while (> n 1)
do (let ((target (+ i (random n))))
(rotatef (aref array i) (aref array target))))
array))
(defun shuffle-string (string)
"Returns a copy of STRING with its characters shuffled"
(shuffle string :element-type 'character))
(defun char-repeat (character times)
"Returns a string with CHARACTER repeated TIMES times"
(make-array times :element-type 'character :initial-element character))
(defun scramble (word)
"Shuffles a word, ensuring that no character is in the correct place"
(loop with scrambled = word
until (fully-scrambled-p scrambled word)
do (setf scrambled (shuffle-string scrambled))
finally (return scrambled)))
(defun unscramble (scrambled solution index)
"Unscrambles the letter at INDEX in SCRAMBLED"
(let* ((c (aref solution index))
(target (position c scrambled :start index)))
(rotatef (aref scrambled index) (aref scrambled target))))
(defun get-letter-counts (word)
"Gets an array of the letter counts within a word"
(let ((normalized-word (string-downcase word))
(base (char-code #\a))
(counts (make-array 26)))
(loop for letter across normalized-word
do (incf (aref counts (- (char-code letter) base))))
counts))
(defun letter-subset-p (superset-letter-counts subset-letter-counts)
"Returns non-nil if SUBSET-LETTER-COUNTS uses only letters from SUPERSET-LETTER-COUNTS"
(every #'<= subset-letter-counts superset-letter-counts))
| 3,030 | Common Lisp | .lisp | 74 | 37.702703 | 120 | 0.737593 | jaredkrinke/thirteen-letters | 3 | 0 | 0 | AGPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 1d44cd5bff018078b5fa23a786def99ba78978ce08e76678d7ffd8ab88fb8c4a | 18,794 | [
-1
] |
18,795 | console.lisp | jaredkrinke_thirteen-letters/console.lisp | (defpackage :13l-console
(:documentation "Single-player, console version of Thirteen Letters")
(:nicknames :13lc)
(:use :cl
:13l)
(:export #:play
#:menu))
(in-package :13lc)
(defun play (&optional (difficulty 0))
"Play one round on the given difficulty level"
(let* ((solution (get-random (nth difficulty *bucketed-words*)))
(scrambled (scramble solution)))
(loop for tries upfrom 0
for attempt upfrom 1
with continue = t
with won = nil
with preamble = "Unscramble the following word"
while continue
do (format t
"~%~%~a, or enter 'q' to give up (attempt #~a):~% ~a~a~% ~a~%~%> "
preamble
attempt
(char-repeat #\Space tries)
(char-repeat #\_ (- *puzzle-length* tries))
scrambled)
(let* ((guess (read-line)))
(cond ((string= guess solution)
(format t
"~%~%Correct! Solved on attempt ~a (difficulty ~a).~%~%"
attempt
(1+ difficulty))
(setf continue nil)
(setf won t))
((string= guess "q")
(format t "~%~%Better luck next time!~%~%")
(setf continue nil))
((string= scrambled solution)
(format t "~%~%Too slow! Better luck next time!~%~%")
(setf continue nil))
(t
(unscramble scrambled solution tries)
(cond ((string= scrambled solution)
(format t "~%~%Too slow! The correct answer was: ~a~%~%" solution)
(setf continue nil))
(t
(format t "~%~%Nope! Guess again"))))))
finally (return (and won tries)))))
(defun menu ()
"Show the title menu and prompt for difficulty level (or exit)"
(initialize-random-state)
(format t
"
=== Thirteen Letters ===
- Goal: Unscramble a thirteen-letter word in as few guesses as possible.
- After each incorrect guess, one letter will be unscrambled.
- There are ~a difficulty levels (1 being the easiest)~%~%"
*difficulty-buckets*)
(loop with continue = t
while continue
do (format t
"Enter a difficulty level, 1 - ~a (or 'q' to quit):~%~%> "
*difficulty-buckets*)
(let* ((input (read-line))
(number (parse-integer input :junk-allowed t))
(difficulty (and number (>= number 1) (<= number *difficulty-buckets*) number)))
(cond ((string= "q" input)
(format t "~%~%So long!~%")
(setf continue nil))
(difficulty
(play (1- difficulty)))
(t
(format t "~%Invalid input!~%"))))))
| 2,439 | Common Lisp | .lisp | 72 | 28.194444 | 84 | 0.606266 | jaredkrinke/thirteen-letters | 3 | 0 | 0 | AGPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | be80a331a6c10384e7595bbf722d771c458a95db6f5706d0fc3e5ec0d4fb8c55 | 18,795 | [
-1
] |
18,796 | run-server.lisp | jaredkrinke_thirteen-letters/run-server.lisp | (ql:quickload :13l-server)
(load "notify.lisp")
(in-package :13ls)
(setf *on-activity* 'notify)
(start-server-thread)
| 120 | Common Lisp | .lisp | 5 | 22.6 | 28 | 0.743363 | jaredkrinke/thirteen-letters | 3 | 0 | 0 | AGPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | b89417cd265d549469c24d1962278eb153d96c81e169f72a4f4cfba4ddb94e31 | 18,796 | [
-1
] |
18,797 | web.lisp | jaredkrinke_thirteen-letters/web.lisp | (defpackage :13l-web
(:documentation "HTML/JS/CSS generator for Thirteen Letters on the web")
(:nicknames :13lw)
(:use :cl)
(:import-from #:parenscript #:ps #:@)
(:local-nicknames (#:sp #:spinneret)))
(in-package :13lw)
;;; JavaScript
;;; TODO: Path should be shared with back-end code
(defvar *web-socket-url* "wss://api.schemescape.com/ws/13l")
(defvar *web-socket-url-override* nil)
(ps:defpsmacro get-id (id)
`((@ document get-element-by-id) ,id))
(ps:defpsmacro watch (&body body)
`(ps:try (progn ,@body) (:catch (e) (error (+ (@ e message) " (" (@ e line-number) ")")))))
(ps:defpsmacro clear-children (node)
`(setf (@ ,node inner-h-t-m-l) ""))
(ps:defpsmacro append-text (node text)
`((@ ,node append-child) ((@ document create-text-node) ,text)))
(defun make-script (&key web-socket-url)
(ps
(defparameter *web-socket-url* (ps:lisp web-socket-url))
(defparameter *name-key* "13l_name")
(defparameter *a* ((@ "a" char-code-at) 0))
(defparameter *z* ((@ "z" char-code-at) 0))
(defun debug (message)
(let ((debug-div ((@ document get-element-by-id) "debug"))
(node ((@ document create-element) "p")))
(append-text node message)
((@ debug-div append-child) node)
nil))
(defun error (error-string)
(debug (+ "ERROR: " error-string))
nil)
(defun get-letter-counts (word)
(let ((counts (ps:create))
(code))
(loop for i from 0 to 25 do (setf (elt counts i) 0))
(loop for i from 0 to (1- (@ word length))
do (setf code ((@ word char-code-at) i))
(if (and (>= code *a*)
(<= code *z*))
(incf (elt counts (- code *a*)))
(return-from get-letter-counts nil)))
counts))
(defun is-valid (expected-counts word)
(let ((actual-counts (get-letter-counts word)))
(if (not actual-counts) (return-from is-valid nil))
(loop for i from 0 to 25
do (if (> (elt actual-counts i) (elt expected-counts i))
(return-from is-valid nil)))
t))
(watch
(let ((socket)
(scrambled)
(scrambled-letter-counts (get-letter-counts ""))
(timer-id)
(validation-timer-id)
(countdown-end-timestamp)
(intro-div (get-id "intro"))
(main-div (get-id "main"))
(time-div (get-id "time"))
(time-title-span (get-id "time-title"))
(time-left-span (get-id "time-left"))
(top-div (get-id "top"))
(player-count-span (get-id "player-count"))
(tbody (get-id "tbody"))
(result-div (get-id "result"))
(debug-div (get-id "debug"))
(news-div (get-id "news"))
(name-input (get-id "name"))
(start-button (get-id "start"))
(guess-input (get-id "guess"))
(winner-span (get-id "winner"))
(winning-word-span (get-id "winning-word")))
(defun hide (element) ((@ element class-list add) "hidden"))
(defun show (element)((@ element class-list remove) "hidden"))
(defun update-letters (word)
(dotimes (i (@ word length))
(let ((letter-span (get-id (+ "l" i))))
(setf (@ letter-span inner-text) (aref word i)))))
(defun round-started (message)
(setf scrambled (@ message scrambled))
(setf scrambled-letter-counts (get-letter-counts scrambled))
(show guess-input)
(show time-div)
(setf (@ time-title-span inner-text) "Time")
(hide result-div)
(setf (@ guess-input value) "")
((@ guess-input focus))
(update-letters scrambled))
(defun round-ended (message)
(show result-div)
(show time-div)
(setf (@ time-title-span inner-text) "Next")
(hide guess-input)
(let* ((entries (@ message leaderboard))
(winning-entry (and entries (aref entries 0))))
(update-letters (@ message solution))
(setf (@ winner-span inner-text) (if winning-entry (@ winning-entry name) "(no one)"))
(setf (@ winning-word-span inner-text) (if winning-entry (@ winning-entry word) "---"))))
(defun unregister-timer ()
(if timer-id (clear-timeout timer-id)))
(defun reset-remaining ()
(unregister-timer)
(setf (@ time-left-span inner-text) "")
nil)
(defun update-time-left ()
(reset-remaining)
(if countdown-end-timestamp
(let* ((remaining-ms (max 0 (- countdown-end-timestamp ((@ -date now)))))
(remaining-seconds (/ remaining-ms 1000))
(floored ((@ -math floor) remaining-seconds))
(text (+ "" floored))
(fraction-ms (max 0 ((@ -math floor) (* (- remaining-seconds
floored)
1000)))))
(setf (@ time-left-span inner-text) text)
(if (> remaining-ms 0)
(setf timer-id (set-timeout update-time-left fraction-ms)))))
nil)
(defun update-remaining (remaining)
(setf countdown-end-timestamp (+ ((@ -date now))
((@ -math floor) (* remaining 1000))))
(update-time-left)
nil)
(defun update-leaderboard (message)
;;; Update leaderboard
(let ((entries (@ message leaderboard)))
(clear-children tbody)
(if entries
(dolist (entry entries)
(let ((row ((@ document create-element) "tr"))
(col-name ((@ document create-element) "td"))
(col-word ((@ document create-element) "td")))
(append-text col-name (@ entry name))
((@ row append-child) col-name)
(append-text col-word (@ entry word))
((@ col-word class-list add) "right")
((@ col-word class-list add) "caps")
((@ row append-child) col-word)
((@ tbody append-child) row)))))
;;; Also update player count, if needed
(let ((client-count (@ message clients)))
(if (>= client-count 0)
(setf (@ player-count-span inner-text)
(max 1 client-count))))
;;; Also update time, if needed
(let ((remaining (@ message remaining)))
(if remaining
(update-remaining remaining)
(reset-remaining))))
(defun handle-error ()
(error "WebSocket error!"))
(defun update-news (message)
(let ((fragment (@ message fragment)))
(setf (@ news-div inner-h-t-m-l) fragment)))
(defun handle-update (event)
(watch
(let* ((json (@ event data))
(message ((@ *JSON* parse) json)))
(case (@ message type)
("state"
(if (not (= scrambled (@ message scrambled))) (round-started message))
(update-leaderboard message))
("result"
(update-leaderboard message)
(round-ended message))
("news"
(update-news message)))
nil)))
(defun send (message)
(if socket
(let ((json ((@ *json* stringify) message)))
((@ socket send) json))))
(defun send-rename ()
(let* ((name-raw (@ name-input value))
(name ((@ name-raw trim))))
(if name
(progn
(send (ps:create type "rename"
name name))
((@ local-storage set-item) *name-key* name))))
nil)
(defun handle-visibility-changed ()
(if (and (not socket)
(= (@ document visibility-state) "visible"))
(connect-socket))
nil)
(defun connect-socket ()
(setf socket (ps:new (-web-socket *web-socket-url*)))
(setf (@ socket onopen) send-rename)
(setf (@ socket onmessage) handle-update)
(setf (@ socket onclose) #'(lambda () (setf socket nil))))
(defun handle-start ()
(watch
(hide intro-div)
(show main-div)
(show top-div)
(if (not socket) (connect-socket))
((@ document add-event-listener) "visibilitychange" #'(lambda ()
(set-timeout handle-visibility-changed 100)))
nil))
(defun get-guess ()
((@ ((@ (@ guess-input value) to-lower-case)) trim)))
(defun send-guess ()
(let* ((word (get-guess))
(message (ps:create type "guess"
word word)))
(send message)
(setf (@ guess-input value) "")
((@ guess-input class-list remove) "invalid")))
(defun validate-current-guess ()
(setf validation-timer-id nil)
(let ((word (get-guess)))
(if (is-valid scrambled-letter-counts word)
((@ guess-input class-list remove) "invalid")
((@ guess-input class-list add) "invalid")))
nil)
(defun schedule-validation-if-needed ()
(if (not validation-timer-id)
(setf validation-timer-id (set-timeout validate-current-guess 50))))
(defun handle-key-down (event)
(watch
(let ((key (@ event key)))
(if (= key "Enter")
(progn (send-guess))
(schedule-validation-if-needed)))))
(defun handle-name-key-down (event)
(watch
(let ((key (@ event key)))
(if (= key "Enter") (handle-start)))))
(setf (@ start-button onclick) handle-start)
(setf (@ name-input onkeydown) handle-name-key-down)
(setf (@ start-button onerror) handle-error)
(setf (@ guess-input onkeydown) handle-key-down)
;;; Try to restore name from localStorage
(let ((saved-name ((@ local-storage get-item) *name-key*) ""))
(if saved-name (setf (@ name-input value) saved-name)))
nil))))
;;; CSS
(defparameter *css*
(cl-css:css
'(("html, body" :margin 0)
("body" :background-color "#eee"
:color "#222")
("body, button, input" :font-family "'Cascadia Mono', 'Consolas', monospace")
("table" :width "100%")
("input" :font-size "100%")
(".left" :text-align "left")
(".center" :text-align "center")
(".right" :text-align "right")
(".caps" :text-transform "uppercase")
(".invalid" :outline "solid 2px red")
(".main" :display "flex"
:flex-direction "column"
:align-items "center")
(".time" :display "flex"
:flex-direction "column"
:align-items "center"
:position "absolute"
:padding "0.25em"
:top 0
:right 0)
(".top" :width "100%"
:display "flex"
:flex-direction "column"
:align-items "center"
:margin-top "1em")
("#root" :display "flex"
:flex-direction "column"
:align-items "center"
:max-width "40em"
:margin "auto"
:padding "1em")
("#guess, #result" :font-size "150%"
:margin-top "1em")
("#start" :margin "1em"
:padding "0.25em 1em"
:font-size "150%"
:font-weight "bold")
("#letters" :margin "1em"
:text-align "center")
("#letters > div" :display "inline-block"
:padding "0.125em"
:font-weight "bold"
:font-size "150%"
:text-transform "uppercase")
("#time-title" :font-weight "bold")
("#time-left" :font-size "125%")
(".time > p" :padding "0.125em"
:margin 0)
(.invisible :display "hidden")
(.hidden :display "none"))))
;;; HTML
(defparameter *intro* (sp:with-html-string ("**Thirteen Letters** is a game where players compete to find the longest word that can be constructed from the given set of letters.
Enter a name and click **Start** to get started.
During each round, a set of thirteen letters will be shown. Type in the longest word you can find and hit Enter/Return to submit your guess. You may continue guessing until the timer in the upper-right counts down to zero.")))
(defmacro page ((&key title) &body body)
"Outputs an HTML page"
`(sp:with-html
(:doctype)
(:html
(:head
(:title ,title)
(:meta :name "viewport"
:content "width=device-width, initial-scale=1, shrink-to-fit=no"))
(:style (:raw *css*))
(:body ,@body))))
(defun make-index-html (&key web-socket-url)
"Outputs root HTML page"
(page (:title "(thirteen-letters)")
(:div :id "root"
(:h1 "(thirteen-letters)")
(:div :id "intro"
(:h2 "Welcome!")
(:raw *intro*)
(:p "Name: " (:input :id "name" :type "text"))
(:p :class "center"
(:button :id "start" "Start")))
(:div :id "main" :class "hidden main"
(:div :id "letters"
(dotimes (n 13)
(:div :id (format nil "l~d" n) "?")))
(:input :id "guess" :type "text"))
(:div :id "time" :class "hidden time"
(:p :id "time-title" "Time")
(:p :id "time-left"))
(:div :id "result" :class "hidden"
"Winner: "
(:span :id "winner")
" ("
(:span :id "winning-word" :class "caps")
")")
(:div :id "top" :class "top hidden"
(:h3 :class "center" "Leaderboard")
(:table (:tbody :id "tbody"))
(:p :class "center"
"(player count: "
(:span :id "player-count" "1")
")"))
(:div :id "news" :class "top")
(:div :id "debug"))
(:script (:raw (make-script :web-socket-url web-socket-url)))))
;;; Generate index.html
(defun write-index-html (&key (web-socket-url (or *web-socket-url-override* *web-socket-url*)))
(setf sp:*suppress-inserted-spaces* t)
(let ((*print-pretty* nil)
(sp:*html-style* :tree))
(with-open-file (out "index.html" :direction :output
:if-exists :supersede)
(setf sp:*html* out)
(make-index-html :web-socket-url web-socket-url))
(format t "Wrote index.html with WebSocket URL: ~a~%" web-socket-url)))
(write-index-html)
| 12,842 | Common Lisp | .lisp | 355 | 30.464789 | 226 | 0.603932 | jaredkrinke/thirteen-letters | 3 | 0 | 0 | AGPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 985e35026d7cc15ef2ab0ec28c741f49efd5fc95597ad03574ce383968bdedf2 | 18,797 | [
-1
] |
18,798 | 13l-web.asd | jaredkrinke_thirteen-letters/13l-web.asd | (defsystem #:13l-web
:depends-on (#:spinneret
#:spinneret/cl-markdown
#:parenscript
#:cl-css)
:serial t
:components ((:file "web")))
| 163 | Common Lisp | .asd | 7 | 18 | 31 | 0.589744 | jaredkrinke/thirteen-letters | 3 | 0 | 0 | AGPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | e57143336b359860b6e7315926f229b3d0cd8912c6a1486c13e4424ddbdcbd3c | 18,798 | [
-1
] |
18,799 | 13l-console.asd | jaredkrinke_thirteen-letters/13l-console.asd | (defsystem #:13l-console
:serial t
:components ((:file "shared")
(:file "console"))
:build-operation program-op
:build-pathname "thirteen-letters"
:entry-point "13lc:menu")
| 191 | Common Lisp | .asd | 7 | 23.714286 | 36 | 0.684783 | jaredkrinke/thirteen-letters | 3 | 0 | 0 | AGPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | c979b073909a5c43fe4769f958707185b14d60b8785199bd6c1c329ab28f057a | 18,799 | [
-1
] |
18,800 | 13l-server.asd | jaredkrinke_thirteen-letters/13l-server.asd | (defsystem #:13l-server
:depends-on (#:lparallel
#:hunchentoot
#:hunchensocket
#:spinneret
#:yason)
:serial t
:components ((:file "shared")
(:file "server"))
:build-operation program-op
:build-pathname "13l-server"
:entry-point "13ls:start-server")
| 301 | Common Lisp | .asd | 12 | 19.75 | 35 | 0.626298 | jaredkrinke/thirteen-letters | 3 | 0 | 0 | AGPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 032d75556cd7c778a39c3da8c35916f52377bf1a55e1ebff7d9739c61e83f909 | 18,800 | [
-1
] |
18,808 | .gitmodules | jaredkrinke_thirteen-letters/.gitmodules | [submodule "yawl"]
path = yawl
url = https://github.com/elasticdog/yawl.git
[submodule "scms"]
path = scms
url = https://github.com/jaredkrinke/scms.git
| 157 | Common Lisp | .l | 6 | 24.5 | 46 | 0.735099 | jaredkrinke/thirteen-letters | 3 | 0 | 0 | AGPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 1ed23ac3cc4535d0e5209d3bc2448ec5589176c38dd13a38bf3bde8acaaf4822 | 18,808 | [
-1
] |
18,828 | server.lisp | alessiostalla_treep/src/server/server.lisp | (defpackage :treep-server (:use :cl :treep-impl))
(in-package :treep-server)
(defvar *app* (make-instance 'ningle:app))
(setf (ningle:route *app* "/")
"Welcome to Treep!")
(setf (ningle:route *app* "/definition/:kind/:name")
#'(lambda (params)
;;TODO we should only find-symbol, not intern
(let ((kind (treep-impl:read-symbol-from-string (cdr (assoc :kind params))))
(name (treep-impl:read-symbol-from-string (cdr (assoc :name params)))))
(let ((definition (treep-impl:meaning name kind)))
(when definition
(setf (lack.response:response-headers ningle:*response*)
(append (lack.response:response-headers ningle:*response*)
(list :content-type "application/json")))
(json:encode-json-plist-to-string
(list :name (class-name definition)
:slots (mapcar #'(lambda (slot)
(let ((map (make-hash-table)))
(setf (gethash :name map) (closer-mop:slot-definition-name slot))
(unless (eq t (closer-mop:slot-definition-type slot))
(setf (gethash :type map) (closer-mop:slot-definition-type slot)))
(when (closer-mop:slot-definition-initform slot)
(setf (gethash :init-form map) (closer-mop:slot-definition-initform slot)))
map))
(let ((instance (make-instance definition)))
(remove-if #'(lambda (slot)
(and (typep instance 'form)
(transient-slot? instance slot)))
(closer-mop:class-slots definition)))))))))))
;(clack:clackup *app*)
| 1,502 | Common Lisp | .lisp | 31 | 41.580645 | 86 | 0.646898 | alessiostalla/treep | 3 | 0 | 5 | AGPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 4b62c051297202b399f0682fba846eeacaa7ddbb8fcde63d61764d8bba36eb7c | 18,828 | [
-1
] |
18,829 | object-system.lisp | alessiostalla_treep/src/level0/object-system.lisp | (in-package :treep-impl)
(defclass class-definition (definition)
((superclasses :initform (fset:seq) :initarg :superclasses :accessor class-definition-superclasses)
(slots :initform (fset:seq) :initarg :slots :accessor class-definition-slots)
(metaclass :initform 'standard-class :initarg :metaclass :accessor class-definition-metaclass)))
(defclass class-reference (form)
((class-name :initarg :class-name :reader referenced-class)))
(defclass slot-definition (definition) ())
(defclass generic-function-definition (definition)
((lambda-list :initarg :lambda-list :initform (fset:seq) :reader function-lambda-list)))
(defclass generic-function (form)
((lambda-list :initarg :lambda-list :initform (fset:seq) :reader function-lambda-list)
(methods :initarg :methods :initform (fset:seq) :reader generic-function-methods)))
(defclass method-definition (definition)
((lambda-list :initarg :lambda-list :initform (fset:seq) :reader method-lambda-list)
(expression :initarg :expression :reader method-expression :type form)))
(defclass specialized-function-argument (function-argument)
((specializer :initarg :specializer :reader argument-specializer)))
(defclass slot-access (form)
((object :initarg :object :reader accessed-object)
(slot-name :initarg :slot-name :reader accessed-slot-name)))
(defclass slot-read (slot-access) ())
(defclass slot-write (slot-access)
((new-value :initarg :new-value :reader slot-write-new-value)))
(defclass new-instance (form)
((class :initarg :class :reader new-instance-class)
(slot-values :initarg :slot-values :initform (fset:seq) :reader new-instance-slots)))
(defclass slot-value (form)
((name :initarg :name :reader slot-name)
(value :initarg :value :reader slot-initial-value)))
(defmethod definition-kind (transformer (definition class-definition))
+kind-class+)
(defmethod transform (transformer (form class-definition) environment)
(make-instance 'standard-class ;;TODO metaclass
:direct-superclasses (or (fset:convert 'list (class-definition-superclasses form)) (list (find-class 'standard-object)))
:direct-slots (fset:convert 'list (fset:image (lambda (def)
(list :name (lisp-symbol (definition-name def)) :initargs (list (lisp-symbol (definition-name def)))))
(class-definition-slots form))))) ;;TODO accessors, etc.
(defmethod definition-kind (transformer (definition generic-function-definition))
+kind-function+)
(defmethod compute-new-environment-for-definition (transformer (definition method-definition) environment)
(let ((gf (meaning (definition-name definition) +kind-function+ environment)))
(if gf
(unless (typep gf 'generic-function) ;;TODO check that lambda lists match!
(error "Not a generic function: ~A" gf)) ;;TODO proper conditions
(setf gf (transform transformer
(make-instance 'generic-function-definition
:name (definition-name definition)
:lambda-list (fset:image #'as-generic-argument (method-lambda-list definition)))
environment)))
(augment-environment environment
(definition-name definition)
+kind-function+
(transform transformer
(make-instance 'generic-function
:lambda-list (function-lambda-list gf)
;;TODO replace when specializers match!
:methods (fset:with-last (generic-function-methods gf) definition))
environment))))
(defgeneric as-generic-argument (argument))
(defmethod as-generic-argument ((argument function-argument))
argument)
(defmethod as-generic-argument ((argument specialized-function-argument))
(make-instance 'function-argument :name (function-argument-name argument)))
(defgeneric compute-argument-specializer (argument environment))
(defmethod compute-argument-specializer ((argument function-argument) environment)
(declare (ignore environment))
(find-class 't))
(defmethod compute-argument-specializer ((argument optional-function-argument) environment)
(declare (ignore environment))
nil)
(defmethod compute-argument-specializer ((argument rest-function-argument) environment)
(declare (ignore environment))
nil)
(defmethod compute-argument-specializer ((argument specialized-function-argument) environment)
(let ((specializer (argument-specializer argument)))
(typecase specializer
(symbol
(let ((class (meaning specializer +kind-class+ environment)))
(if class class (error "There is no class named ~A" (function-argument-name argument))))) ;;TODO proper condition
(cl:class specializer)
(t (error "Not a valid specializer: ~A" specializer))))) ;;TODO proper condition
;;Evaluation
(defmethod transform ((transformer simple-evaluator) (form class-reference) environment)
(let ((class (transform transformer (referenced-class form) environment)))
(typecase class
(cl:class class)
(symbol
(or (meaning class +kind-class+ environment)
(error "There is no class named ~A" class))) ;;TODO proper condition
(t (error "Not a class designator: ~A" class))))) ;;TODO proper condition
(defclass interpreted-generic-function (interpreted-function generic-function) () (:metaclass closer-mop:funcallable-standard-class))
(defmethod transform ((transformer simple-evaluator) (form generic-function-definition) environment)
(transform transformer (make-instance 'interpreted-generic-function :lambda-list (function-lambda-list form)) environment))
(defmethod transform ((transformer simple-evaluator) (form generic-function) environment)
(transform transformer (make-instance 'interpreted-generic-function
:lambda-list (function-lambda-list form)
:methods (generic-function-methods form))
environment))
(defmethod transform ((transformer simple-evaluator) (form generic-function) environment)
(let* ((lambda-list (check-function-lambda-list (function-lambda-list form)))
(lisp-lambda-list (to-lisp-lambda-list lambda-list transformer environment))
(gf (make-instance 'closer-mop:standard-generic-function :name (make-symbol "generic-function") :lambda-list lisp-lambda-list)) ;;TODO carry a meaningful name
(interpreted-function (make-instance 'interpreted-generic-function :lambda-list lambda-list)))
(fset:do-seq (m (generic-function-methods form))
;;TODO check lambda list matches here too?
(let* ((lambda-list (check-function-lambda-list (method-lambda-list m)))
(body (method-expression m))
(fn (make-interpreted-lambda-expression lambda-list body transformer environment)))
(closer-mop:ensure-method gf fn
:specializers (fset:convert 'list
(fset:remove nil
(fset:image
(lambda (arg) (compute-argument-specializer arg environment))
lambda-list))))))
(closer-mop:set-funcallable-instance-function interpreted-function gf)
interpreted-function))
(defmethod transform ((transformer simple-evaluator) (form new-instance) environment)
(let ((class (transform transformer (new-instance-class form) environment)))
(apply #'make-instance
(typecase class
(cl:class class)
(symbol (or (meaning class +kind-class+ environment) (error "Unknown class: ~A" class))) ;;TODO proper conditions!
(t (error "Not a class designator: ~A" class))) ;;TODO proper conditions!
(fset:convert 'list (fset:reduce #'fset:concat
(fset:image (lambda (slot) (fset:seq (slot-name slot) (slot-initial-value slot)))
(new-instance-slots form))
:initial-value (fset:seq))))))
(defmethod transform ((transformer simple-evaluator) (form slot-read) environment)
(cl:slot-value (transform transformer (accessed-object form) environment) (lisp-symbol (transform transformer (accessed-slot-name form) environment))))
(defmethod transform ((transformer simple-evaluator) (form slot-write) environment)
(setf (cl:slot-value (transform transformer (accessed-object form) environment) (lisp-symbol (transform transformer (accessed-slot-name form) environment)))
(transform transformer (slot-write-new-value form) environment)))
| 8,044 | Common Lisp | .lisp | 133 | 55.954887 | 160 | 0.748574 | alessiostalla/treep | 3 | 0 | 5 | AGPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 430b3b7d22f32a57ffaa3e00398ff105272e0b3ceb5360d717c286a4b67c9397 | 18,829 | [
-1
] |
18,830 | symbols-io.lisp | alessiostalla_treep/src/level0/symbols-io.lisp | (in-package :treep-impl)
(defconstant +root-symbol+ '||)
(defconstant +symbol-treep+ (import-lisp-symbol 'treep +root-symbol+))
(defvar *symbol-space* +symbol-treep+)
(defun intern (name &optional (space *symbol-space*))
(%intern name space))
(defun find-symbol (name &optional (space *symbol-space*) exclude)
(%find-symbol name space exclude))
(defun print-symbol (symbol &optional (stream *standard-output*))
(unless (eq (ignore-errors (find-symbol (symbol-name symbol))) symbol)
(let ((parent (symbol-parent symbol)))
(when (and parent (not (eq parent *symbol-space*)))
(print-symbol parent stream)
(princ ":" stream))))
(princ (symbol-name symbol) stream)
symbol)
(defun read-symbol (stream &optional (intern-function #'intern))
(let* ((separator #\:)
(symbol-space (if (eql (peek-char t stream) separator)
(progn (read-char stream) +root-symbol+)
*symbol-space*))
continue
(symbol-name (with-output-to-string (s)
(cl:loop
(let ((whitespace '(#\Space #\Newline #\Backspace #\Tab #\Linefeed #\Page #\Return #\Rubout))
(terminating-chars '(#\( #\) #\# #\[ #\]))
(ch (read-char stream nil)))
(cond
((eql ch separator)
(setf continue t)
(return))
((or (null ch) (member ch whitespace :test #'eql) (member ch terminating-chars :test #'eql))
(when ch (unread-char ch stream))
(return))
(t (princ ch s)))))))
(symbol (funcall intern-function symbol-name symbol-space)))
(if continue
(let ((*symbol-space* symbol))
(read-symbol stream intern-function))
symbol)))
(defun read-symbol-from-string (s)
(with-input-from-string (s s)
(read-symbol s)))
(defvar *read-symbol-syntax* nil)
(defvar *symbol-dispatch-macro-character* nil)
(defvar *symbol-dispatch-sub-character* nil)
(defmacro with-read-symbol-syntax ((&optional (dispatch-char #\#) (sub-char #\^)) &body body)
`(let ((*readtable* (copy-readtable))
(*symbol-dispatch-macro-character* ,dispatch-char)
(*symbol-dispatch-sub-character* ,sub-char))
,(if sub-char
`(set-dispatch-macro-character ,dispatch-char ,sub-char
(lambda (stream sub-char infix)
(declare (ignore sub-char infix))
(read-symbol stream)))
`(set-macro-character ,dispatch-char
(lambda (stream char)
(declare (ignore char))
(read-symbol stream))))
,@body))
| 2,372 | Common Lisp | .lisp | 60 | 35.183333 | 102 | 0.664785 | alessiostalla/treep | 3 | 0 | 5 | AGPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 42357bbd2ecd9d426718b08897b39709e62c552deab742aea53d39359ffbc4ec | 18,830 | [
-1
] |
18,831 | forms.lisp | alessiostalla_treep/src/level0/forms.lisp | (in-package :treep-impl)
(defconstant +kind-class+ (import-lisp-symbol 'class +symbol-treep+))
(defconstant +kind-function+ (import-lisp-symbol 'function +symbol-treep+))
(defconstant +kind-variable+ (import-lisp-symbol 'variable +symbol-treep+))
(defclass environment ()
((bindings :initform (fset:map) :initarg :bindings :accessor environment-bindings)))
(defun augment-environment (environment name kind meaning)
(flet ((compute-meanings ()
(fset:with (or (fset:@ (environment-bindings environment) name)
(fset:map))
kind
meaning)))
(make-instance 'environment :bindings
(fset:with (environment-bindings environment)
name
(compute-meanings)))))
(defclass form-class (closer-mop:standard-class)
((definition :initform nil :accessor form-class-definition)))
(defclass form-slot-definition ()
((slot-name :initarg :slot-name :initform nil :accessor slot-name)
(internal :initarg :internal :initform nil :accessor slot-internal?)))
(defclass direct-form-slot-definition (closer-mop:standard-direct-slot-definition form-slot-definition) ())
(defclass effective-form-slot-definition (closer-mop:standard-effective-slot-definition form-slot-definition) ())
(defmethod closer-mop:validate-superclass ((class form-class) (superclass closer-mop:standard-class))
t)
(defmethod closer-mop:direct-slot-definition-class ((class form-class) &rest initargs)
(declare (ignore initargs))
(find-class 'direct-form-slot-definition))
(defmethod closer-mop:effective-slot-definition-class ((class form-class) &rest initargs)
(declare (ignore initargs))
(find-class 'effective-form-slot-definition))
(defconstant +symbol-form+ (import-lisp-symbol 'form +symbol-treep+))
(defconstant +symbol-form-parent+ (import-lisp-symbol 'parent +symbol-form+))
(defclass form ()
((parent :accessor form-parent))
(:metaclass form-class))
(setf (get 'form 'symbol) +symbol-form+)
(defun slot (name class)
(or (find-if (lambda (def) (eq name (closer-mop:slot-definition-name def)))
(closer-mop:class-slots (if (symbolp class) (find-class class) class)))
(error "~A does not name a slot in ~A" name class)))
(closer-mop:finalize-inheritance (find-class 'form))
(let ((parent-slot (slot 'parent 'form)))
(setf (slot-name parent-slot) +symbol-form-parent+)
(setf (slot-internal? parent-slot) t))
(defmethod internal-slot? (form (slot cl:symbol))
(slot-internal? (slot slot (class-of form))))
(defmethod internal-slot? (form (slot closer-mop:slot-definition))
(declare (ignore form slot))
nil)
(defmethod internal-slot? (form (slot form-slot-definition))
(declare (ignore form))
(slot-internal? slot))
(defmethod internal-slot? ((form cl:class) (slot cl:symbol))
(slot-internal? (slot slot form)))
(defmethod internal-slot? ((form cl:symbol) slot)
;; TODO avoid make-instance, use prototype instead
(internal-slot? (make-instance form) slot))
(defgeneric init-subform (parent name child))
(defmethod init-subform ((parent form) (name (eql 'parent)) (child form))
nil)
(defmethod init-subform ((parent form) name child)
nil)
(defmethod init-subform ((parent form) name (child form))
(setf (form-parent child) parent)) ;;TODO check it doesn't already have a parent
(defmethod initialize-instance :after ((instance form) &key &allow-other-keys)
(cl:loop
:for slot :in (closer-mop:class-slots (class-of instance))
:do (let ((name (closer-mop:slot-definition-name slot)))
(if (slot-boundp instance name)
(init-subform instance name (cl:slot-value instance name)))))) ;;TODO lists of children
(defgeneric transform (transformer form environment))
#|TODO move/redo
(defclass constant (form)
((value :initarg :value :reader constant-value)))
(defclass variable-access (form)
((variable-name :initarg :name :reader accessed-variable-name)))
(defclass variable-read (variable-access) ())
(defclass variable-write (variable-access)
((form :initarg :form :reader variable-write-form)))
(defclass function-argument (form)
((name :initarg :name :reader function-argument-name :type symbol)))
(defclass optional-function-argument (function-argument)
((default-value :initarg :default-value :initform nil :reader function-argument-default-value)))
(defclass rest-function-argument (function-argument) ())
(defclass function (form)
((lambda-list :initarg :lambda-list :initform (fset:seq) :reader function-lambda-list)
(expression :initarg :expression :reader function-expression)))
(defclass variable (form)
((init-form :initarg :init-form :initform nil :reader variable-init-form)))
(defclass constant (form)
((value :initarg :value :reader constant-value)))
;; A macro is not like in Lisp, i.e., superficially like a function call.
;; It's a new form (class).
(defclass macro (form)
((expansion :initarg :expansion :reader macro-expansion)))
(defmethod transform (transformer (form macro) environment)
(let ((expanded (funcall (macro-expansion form) form environment)))
(transform transformer expanded environment)))
(defclass function-access (form)
((function-designator :initarg :function :reader accessed-function-designator)))
(defclass function-reference (function-access) ())
(defclass function-call (function-access)
((arguments :initarg :arguments :reader function-arguments)))
;;Environment and definitions
(defclass definition (form)
((name :initarg :name :reader definition-name)))
(defclass binding (form)
((definition :initarg :definition :reader binding-definition :type definition)
(body :initarg :body :reader binding-body)))
(defclass define (form)
((definition :initarg :definition :reader define-definition :type definition)))
;;TODO Should this inherit from variable?
(defclass variable-definition (definition)
((init-form :initarg :init-form :initform nil :reader variable-definition-init-form)
(mutable? :initarg :mutable :initform nil :reader mutable?)))
(defclass function-definition (definition)
((init-form :initarg :init-form :initform nil :reader function-definition-init-form)))
(defclass macro-definition (definition)
((slot-definitions :initarg :slot-definitions :reader macro-definition-slots)
(expander-function :initarg :expander-function :reader macro-definition-expander-function)))
(defgeneric definition-kind (transformer definition))
(defmethod definition-kind (transformer (definition variable-definition))
+kind-variable+)
(defmethod definition-kind (transformer (definition function-definition))
+kind-function+)
|#
(defun initial-bindings ()
(let ((map (fset:map)))
(setf map (fset:with map +symbol-form+ (fset:with (fset:map) +kind-class+ (find-class 'form))))
map))
(defun initial-environment ()
(make-instance 'environment :bindings (initial-bindings)))
(defvar *environment* (initial-environment))
(defun meaning (symbol kind &optional (environment *environment*))
(let ((meanings (fset:@ (environment-bindings environment) symbol)))
(when meanings
(fset:@ meanings kind))))
(defun copy-environment (&optional (environment *environment*))
(make-instance 'environment :bindings (environment-bindings environment)))
#|TODO
(defgeneric compute-new-environment-for-definition (transformer definition environment))
(defmethod compute-new-environment-for-definition (transformer (definition definition) environment)
(augment-environment environment
(definition-name definition)
(definition-kind transformer definition)
(transform transformer definition environment)))
(defmethod transform (transformer (form binding) environment)
(let ((def (binding-definition form)))
(transform transformer (binding-body form) (compute-new-environment-for-definition transformer def environment))))
(defmethod transform (transformer (form define) environment)
(let ((def (define-definition form)))
(setf (environment-bindings environment)
(environment-bindings (compute-new-environment-for-definition transformer def environment)))))
|#
| 8,038 | Common Lisp | .lisp | 155 | 48.832258 | 118 | 0.752871 | alessiostalla/treep | 3 | 0 | 5 | AGPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 0ab5b9a2d36aaf24064d0c43e2af69b4a5ea35c64daa9ba3d534e0567e06402c | 18,831 | [
-1
] |
18,832 | repl.lisp | alessiostalla_treep/src/level0/repl.lisp | (in-package :treep-impl)
(defconstant +symbol-repl+ (import-lisp-symbol 'repl +symbol-treep+))
(defconstant +symbol-repl-quit+ (import-lisp-symbol 'quit +symbol-repl+))
;;TODO expose to the REPL as just "quit"
(define-abstraction quit +symbol-repl-quit+)
(defun repl (&key (evaluator (make-instance 'simple-evaluator)) (printer (make-instance 'printer)) (symbol-space +symbol-repl+))
(let ((*symbol-space* symbol-space) (*environment* (copy-environment)))
(cl:loop
(let ((ss *symbol-space*) (*symbol-space* +root-symbol+))
(print-symbol ss))
(princ "> ")
(force-output)
(restart-case
(let ((form (read-form *standard-input* *environment*)))
(when (typep form 'quit) (return *environment*))
(transform printer (transform evaluator form *environment*) *environment*)
(terpri))
(ignore-and-continue () :report "Ignore the error.")
(quit () :report "Quit the Treep REPL." (return *environment*))))))
| 965 | Common Lisp | .lisp | 19 | 46.421053 | 128 | 0.675504 | alessiostalla/treep | 3 | 0 | 5 | AGPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | d82eb5129498902863612239c01925174e90f9852347b5f717f1ff07c5c58140 | 18,832 | [
-1
] |
18,833 | symbols.lisp | alessiostalla_treep/src/level0/symbols.lisp | (in-package :treep-impl)
(defclass symbol-space ()
((name :reader symbol-space-name :initarg :name :type symbol)
(contents :accessor symbol-space-contents :type fset:map :initform (fset:map))
(search-path :accessor symbol-space-search-path :initarg :search-path :type fset:seq :initform (fset:seq))))
(defun symbol (name &key parent)
(let ((symbol (make-symbol name)))
(when parent
(setf (getf (symbol-plist symbol) 'parent) parent))
symbol))
(defun import-lisp-symbol (symbol parent &key (name (string-downcase (cl:symbol-name symbol))))
(let ((existing-parent (symbol-parent symbol)))
(when (and existing-parent (not (eq existing-parent parent)))
(error "Symbol ~A already has a different parent: ~A" symbol existing-parent))) ;; TODO specific error, print symbols correctly
(setf (getf (symbol-plist symbol) 'parent) parent)
(%record-symbol symbol (ensure-symbol-space parent) name)
symbol)
(defun symbol-name (symbol)
(cl:symbol-name symbol))
(defun symbol-parent (symbol)
(getf (symbol-plist symbol) 'parent))
(defun symbol-space (symbol)
(getf (symbol-plist symbol) 'space))
(defun (setf symbol-space) (space symbol)
(setf (getf (symbol-plist symbol) 'space) space))
(defun symbol-properties (symbol)
(or (getf (symbol-plist symbol) 'properties) (fset:map)))
(defun (setf symbol-properties) (properties symbol)
(setf (getf (symbol-plist symbol) 'properties) properties))
(defun ensure-symbol-space (symbol)
(or (symbol-space symbol)
(setf (symbol-space symbol) (make-instance 'symbol-space :name symbol))))
(deftype symbol () 'cl:symbol)
(defun %record-symbol (symbol space &optional (name (symbol-name symbol)))
;; TODO check if another symbol already exists under the same name
(setf (symbol-space symbol) ;;TODO make this the default, but optional
(make-instance 'symbol-space :name symbol :search-path (fset:seq space)))
(setf (symbol-space-contents space)
(fset:with (symbol-space-contents space) name symbol))
symbol)
(defun %intern (name space)
(let ((the-name (string name))
(space (typecase space
(symbol-space space)
(symbol (ensure-symbol-space space))
(t (error "Not a symbol space designator: ~S" space))))) ;TODO dedicated condition
(or (%find-symbol the-name space)
(%record-symbol (symbol the-name :parent (symbol-space-name space)) space))))
(defun %find-symbol (name space &optional exclude)
(let ((the-name (string name))
(space (typecase space
(symbol-space space)
(symbol (or (symbol-space space) (return-from %find-symbol)))
(t (error "Not a symbol space designator: ~S" space))))) ;TODO dedicated condition
(let ((symbol (fset:@ (symbol-space-contents space) the-name)))
(if symbol
symbol
(fset:do-seq (s (symbol-space-search-path space))
(unless (member s exclude)
(push s exclude)
(let ((symbol (%find-symbol name s exclude)))
(when symbol (return-from %find-symbol symbol)))))))))
(defun symbol? (object)
(typep object 'cl:symbol))
| 3,018 | Common Lisp | .lisp | 64 | 43.75 | 133 | 0.714723 | alessiostalla/treep | 3 | 0 | 5 | AGPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 64dc99515bbd542342e6806d85c99c55417b78ecaea3ec0aeed2c52b8e8bf0b4 | 18,833 | [
-1
] |
18,834 | abstractions.lisp | alessiostalla_treep/src/level0/abstractions.lisp | (in-package :treep-impl)
(defmacro define-abstraction (name symbol &optional superclasses slots)
`(progn
(defclass ,name ,(or superclasses '(form)) ,slots (:metaclass form-class))
(setf *environment* (augment-environment *environment* ,symbol +kind-class+ (cl:find-class ',name)))
(setf (get ',name 'symbol) ,symbol)
,@(when slots
`((closer-mop:finalize-inheritance (find-class ',name))
,@(remove-if #'null
(mapcar (lambda (slot)
(when (listp slot)
(let ((slot-name (getf (cdr slot) :slot-name)))
(when slot-name
`(setf (slot-name (slot ',(car slot) ',name)) ,slot-name)))))
slots))))
',name))
;;Basic forms
(defconstant +symbol-abstraction+ (import-lisp-symbol 'abstraction +symbol-treep+))
(defconstant +symbol-abstraction-direct-superclasses+ (import-lisp-symbol 'direct-superclasses +symbol-abstraction+))
(defconstant +symbol-abstraction-slot+ (import-lisp-symbol 'slot +symbol-abstraction+))
(defconstant +symbol-abstraction-slots+ (import-lisp-symbol 'slots +symbol-abstraction+))
(defconstant +symbol-name+ (import-lisp-symbol 'name +symbol-treep+))
(defconstant +symbol-namespace+ (import-lisp-symbol 'namespace +symbol-treep+))
(defconstant +symbol-namespace-search-path+ (import-lisp-symbol 'search-path +symbol-namespace+))
(defconstant +symbol-quote+ (import-lisp-symbol 'quote +symbol-treep+))
(defconstant +symbol-seq+ (import-lisp-symbol 'seq +symbol-treep+))
(defconstant +symbol-seq-elements+ (import-lisp-symbol 'elements +symbol-seq+))
(defconstant +symbol-with+ (import-lisp-symbol 'with +symbol-treep+))
(defconstant +symbol-with-value+ (import-lisp-symbol 'value +symbol-with+))
(define-abstraction quote +symbol-quote+ ()
((form :initarg :form :reader quoted-form)))
(defmethod transform (transformer (form quote) environment)
(declare (ignore transformer))
(values (quoted-form form) environment))
(define-abstraction seq +symbol-seq+ ()
((elements :initarg :elements :accessor seq-elements :initform (fset:seq) :slot-name +symbol-seq-elements+)))
(define-abstraction slot-definition +symbol-abstraction-slot+ ()
((name :initarg :name :accessor slot-definition-name :slot-name +symbol-name+)))
(define-abstraction abstraction-definition +symbol-abstraction+ ()
((name :initarg :name :accessor abstraction-definition-name :slot-name +symbol-name+)
(direct-superclasses :initarg :direct-superclasses :accessor abstraction-definition-direct-superclasses :initform (make-instance 'seq)
:slot-name +symbol-abstraction-direct-superclasses+)
(slots :initarg :slots :accessor abstraction-definition-slots :initform (make-instance 'seq) :slot-name +symbol-abstraction-slots+)))
(define-abstraction named-child +symbol-with+ ()
((name :initarg :name :accessor named-child-name :slot-name +symbol-name+)
(value :initarg :value :accessor named-child-value :slot-name +symbol-with-value+)))
(define-abstraction namespace +symbol-namespace+ ()
((name :reader namespace-name :slot-name +symbol-name+)
(search-path :reader namespace-search-path :slot-name +symbol-namespace-search-path+)))
#| TODO Common forms
(defclass conditional (form)
((condition :initarg :condition :reader conditional-if)
(then :initarg :then :reader conditional-then :type form :initform nil)
(else :initarg :else :reader conditional-else :type form :initform nil)))
(defclass loop (form)
((name :initarg :name :reader loop-name :initform nil)
(body :initarg :body :reader loop-body)))
(defclass loop-break (form)
((loop-name :initarg :loop-name :reader loop-name :initform nil)
(return-form :initarg :return :reader return-form :initform nil)))
|#
| 4,037 | Common Lisp | .lisp | 61 | 63.016393 | 137 | 0.671378 | alessiostalla/treep | 3 | 0 | 5 | AGPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 9a5dbc7cc3df0f19dc721ad4d66903023f788f3f57707917e023e3377934c1cf | 18,834 | [
-1
] |
18,835 | lisp.lisp | alessiostalla_treep/src/level0/lisp.lisp | (in-package :treep-impl)
(defclass lisp (form)
((expression :initarg :expression :initform nil :reader lisp-expression)
(variables :initarg :variables :initform (fset:seq) :reader lisp-variables)))
(defmethod transform ((transformer simple-evaluator) (form lisp) environment)
(common-lisp:eval `(let ,(fset:convert
'list
(fset:image
(lambda (v)
(list (fset:@ v 0)
(transform transformer (make-instance 'variable-read :name (fset:@ v 1)) environment)))
(lisp-variables form)))
,(lisp-expression form))))
(defun import-lisp-package (package &key
(space (intern (string-downcase (package-name package)) *symbol-space*))
(environment *environment*))
(do-symbols (s package)
(setf environment (import-lisp-symbol s :space space :environment environment)))
environment)
(defun import-lisp-symbol (symbol &key
(space *symbol-space*)
(into (intern (string-downcase (cl:symbol-name symbol)) space))
(environment *environment*))
(when (fboundp symbol)
(let* ((rest (symbol "args"))
(function (make-instance 'function
:lambda-list (fset:seq (make-instance 'rest-function-argument :name rest))
:expression (make-instance 'lisp
:expression `(apply ',symbol (fset:convert 'list args))
:variables (fset:seq (fset:seq 'args rest))))))
;;TODO handle more specific lambda lists if possible
(setf environment (augment-environment environment into +kind-function+ function))))
;;TODO handle variables
(let ((class (find-class symbol nil)))
(when class
(setf environment (augment-environment environment into +kind-class+ class)))) ;;TODO handle redefinition through indirection?
environment)
(defconstant +lisp-symbol+ (intern "lisp-symbol" +symbol-treep+))
(defun lisp-symbol (symbol)
(or (fset:@ (symbol-properties symbol) +lisp-symbol+)
(setf (fset:@ (symbol-properties symbol) +lisp-symbol+)
(let ((parent (symbol-parent symbol)))
(if (and parent (not (eq parent +root-symbol+)))
(if (and (or (null (symbol-parent parent)) (eq (symbol-parent parent) +root-symbol+))
(find-package (symbol-name parent)))
(cl:intern (symbol-name symbol) (symbol-name parent))
(cl:make-symbol (symbol-name symbol)))
(cl:intern (symbol-name symbol) (find-package :keyword)))))))
| 2,397 | Common Lisp | .lisp | 48 | 43.625 | 132 | 0.67563 | alessiostalla/treep | 3 | 0 | 5 | AGPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 60cf80263ee510214cbdd7d102072c6b9b3b2cb6187a0ed89b35a6896cf9f370 | 18,835 | [
-1
] |
18,836 | printer.lisp | alessiostalla_treep/src/level0/printer.lisp | (in-package :treep-impl)
(defclass printer ()
((stream :initarg :stream :initform *standard-output* :accessor printer-stream)))
(defmethod transform ((transformer printer) (object form) environment)
(let ((name (class-name (class-of object)))
(stream (printer-stream transformer)))
(princ "(" stream)
(print-symbol (etypecase name
(symbol name)
(cl:symbol (get name 'symbol)))
stream)
(dolist (slot (remove-if (lambda (slot) (internal-slot? object slot))
(closer-mop:class-slots (class-of object))))
(princ " " stream)
(transform transformer (cl:slot-value object (closer-mop:slot-definition-name slot)) environment))
(princ ")" stream)))
(defmethod transform ((transformer printer) (object seq) environment)
(let ((stream (printer-stream transformer)))
(princ "(" stream)
(print-symbol +symbol-seq+ stream)
(fset:do-seq (el (seq-elements object))
(princ " " stream)
(transform transformer el environment))
(princ ")" stream)))
(defmethod transform ((transformer printer) (object cl:symbol) environment)
(declare (ignore environment))
(print-symbol object (printer-stream transformer)))
(defmethod transform ((transformer printer) (object form-class) environment)
(if (form-class-definition object)
(transform transformer (form-class-definition object) environment)
(call-next-method)))
(defmethod transform ((transformer printer) object environment)
(declare (ignore environment))
(print-object object (printer-stream transformer)))
| 1,549 | Common Lisp | .lisp | 34 | 41.176471 | 104 | 0.71438 | alessiostalla/treep | 3 | 0 | 5 | AGPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 532618ef2375df143540b4d362371a0ffce2ef264f92155b19bd4be45bfe99c9 | 18,836 | [
-1
] |
18,837 | level1-boot.lisp | alessiostalla_treep/src/level0/level1-boot.lisp | (in-package :treep-impl)
(setf *environment* (import-lisp-package (find-package :common-lisp)))
(setf *environment* (import-lisp-package (find-package :treep-impl) :space +symbol-treep+))
(setf *environment* (import-lisp-package (find-package :closer-mop) :space (intern "mop" +symbol-treep+)))
(setf *environment* (import-lisp-package (find-package :fset) :space (intern "collections" +symbol-treep+)))
(defclass namespace (form)
((symbol :initarg :symbol :reader namespace-symbol)))
(defmethod transform ((transformer simple-evaluator) (form namespace) environment)
(let ((ns (namespace-symbol form)))
(unless (symbol? ns)
(error "Not a symbol: ~A" ns))
(setf *symbol-space* ns)))
| 704 | Common Lisp | .lisp | 12 | 55.916667 | 108 | 0.722787 | alessiostalla/treep | 3 | 0 | 5 | AGPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 8cf4cf2c1e6bceffb3bd0534646f49296228e8eca6f38cb11441f233f7df4dd2 | 18,837 | [
-1
] |
18,838 | reader.lisp | alessiostalla_treep/src/level0/reader.lisp | (in-package :treep-impl)
(define-condition premature-end-of-form (error) ())
(defun read-form (stream environment)
(let ((ch (peek-char t stream)))
(cond
((char= ch #\()
(read-complex-form stream environment)) ;;TODO intern function...
((char= ch #\))
(read-char stream)
(error "Not inside a form")) ;;TODO more specific condition, better message
((digit-char-p ch)
(cl:read stream))
((char= ch #\")
(cl:read stream))
;; ((and (or (char= ch #\+) (char= ch #\-) (char= ch #\.))
(t (read-symbol stream)))))
(defun whitespace? (ch)
(or (char= ch #\Space) (char= ch #\Tab) (char= ch #\Newline)))
(defun consume-whitespace (stream)
(cl:loop :while (whitespace? (peek-char t stream)) :do (read-char stream)))
(defgeneric read-form-instance (form stream environment))
(defmethod read-form-instance (form stream environment)
(let ((slots (remove-if (lambda (slot) (internal-slot? form slot))
(closer-mop:class-slots (class-of form)))))
(cl:loop
:while slots
:do (progn
(consume-whitespace stream)
(when (char= (peek-char t stream) #\))
(return))
;; TODO give the form a chance to read the slot, e.g. in a different namespace
(let* ((subform (read-form stream environment))
(slot (if (typep subform 'named-child)
(or (find (named-child-name subform) slots :key #'slot-name)
(error "No slot named ~A in ~A" (named-child-name subform) (class-of form)))
(car slots)))
(slot-name (closer-mop:slot-definition-name slot))
(value (if (typep subform 'named-child) (named-child-value subform) subform)))
(setf (cl:slot-value form slot-name) value)
(init-subform form slot-name value)
(setf slots (remove slot slots))))))
(consume-whitespace stream)
(if (char= (peek-char t stream) #\))
(read-char stream)
(error "No more child nodes expected in ~A" form))
form)
(defmethod read-form-instance ((form seq) stream environment)
(let ((result (fset:seq)))
(cl:loop
(if (char= (peek-char t stream) #\))
(progn (read-char stream)
(return))
(setf result (fset:with-last result (read-form stream environment)))))
(setf (seq-elements form) result)
form))
(defun read-complex-form (stream environment &optional (intern-function #'intern))
(unless (char= (read-char stream) #\()
(error "Not a complex form!"))
(when (char= (peek-char t stream) #\))
(error "Symbol required"))
(let* ((class-name (read-symbol stream intern-function))
(class (or (meaning class-name +kind-class+ environment) (error "Abstraction ~A is unknown" class-name)))
(form (make-instance class)))
(read-form-instance form stream environment)))
| 2,731 | Common Lisp | .lisp | 64 | 37.921875 | 107 | 0.651373 | alessiostalla/treep | 3 | 0 | 5 | AGPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | bbef1435f8915773bc247b1466be48f25067fd09abb1a7bceff824c2a4b1215b | 18,838 | [
-1
] |
18,839 | loader.lisp | alessiostalla_treep/src/level0/loader.lisp | (in-package :treep-impl)
(defun load (stream &key (evaluator (make-instance 'simple-evaluator)) (intern-function #'intern))
(let ((*symbol-space* *symbol-space*)
(environment (copy-environment)) ;So we don't side-effect it
(result nil))
(cl:loop
(unless (peek-char t stream nil nil)
(return))
(multiple-value-setq (result environment) (transform evaluator (read-form stream environment) environment)))
(values environment result)))
(defun load-file (file &key (evaluator (make-instance 'simple-evaluator)) (intern-function #'intern))
(with-open-file (f file)
(load f :evaluator evaluator :intern-function intern-function)))
| 661 | Common Lisp | .lisp | 13 | 47 | 113 | 0.721362 | alessiostalla/treep | 3 | 0 | 5 | AGPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 7a173a2aebc7221e8ee4e0dda356e5a67cb00836da0f49e1cf89f50cfe385d69 | 18,839 | [
-1
] |
18,840 | evaluator.lisp | alessiostalla_treep/src/level0/evaluator.lisp | (in-package :treep-impl)
(defclass simple-evaluator () ())
(defun eval (form &optional (environment *environment*))
(multiple-value-bind (result env)
(transform (make-instance 'simple-evaluator) form environment)
(when (eq environment *environment*) ;;Convenience for top-level eval
(setf *environment* env))
(values result env)))
(defmethod transform ((transformer simple-evaluator) form environment)
(values form environment)) ;Lisp objects are self-evaluating
(defmethod transform ((transformer simple-evaluator) (form seq) environment)
(values
(fset:image (lambda (f) (transform transformer f environment)) (seq-elements form))
environment))
(defun resolve-class (designator environment)
(typecase designator
(symbol (or (meaning designator +kind-class+ environment) (error "~A is not the name of a class" designator)))
(cl:symbol (find-class designator))
(t (error "Not a class designator: ~A" designator))))
(defmethod transform ((transformer simple-evaluator) (form abstraction-definition) environment)
(let* ((class-name (or (abstraction-definition-name form) (error "The name of an abstraction definition is required")))
(direct-superclasses (or (fset:convert 'list ;; TODO compute these in a different phase/transformer
(fset:image (lambda (c) (resolve-class c environment))
(seq-elements (abstraction-definition-direct-superclasses form))))
(list (find-class 'form))))
;; TODO is this the proper MOP incantation?
(class (make-instance 'form-class :name class-name :direct-superclasses direct-superclasses
;TODO slots
)))
(setf (form-class-definition class) form)
(values class (augment-environment environment class-name +kind-class+ class))))
(defmethod transform ((transformer simple-evaluator) (form namespace) environment)
(values
(if (slot-boundp form 'name)
(if (slot-boundp form 'search-path)
(let ((ns (namespace-name form)))
(setf (symbol-space-search-path (ensure-symbol-space ns))
(the fset:seq (transform transformer (namespace-search-path form) environment)))
ns)
(setf *symbol-space* (namespace-name form)))
*symbol-space*)
environment))
#|TODO move/redo
(defclass box ()
((value :initarg :value :accessor box-value)))
(defclass interpreted-function (function closer-mop:funcallable-standard-object) () (:metaclass closer-mop:funcallable-standard-class))
(defmethod transform ((transformer simple-evaluator) (form variable-definition) environment)
(let ((value (transform transformer (variable-definition-init-form form) environment)))
(make-instance 'box :value value)))
(defmethod transform ((transformer simple-evaluator) (form function-definition) environment)
(let ((function (transform transformer (function-definition-init-form form) environment)))
(typecase function
(interpreted-function function)
(function (transform transformer function environment))
(t (error "Not a function: ~S" function))))) ;TODO specific condition
(defmethod transform ((transformer simple-evaluator) (form variable-read) environment)
(let* ((variable (accessed-variable-name form))
(meaning (meaning variable +kind-variable+ environment)))
(if meaning
(if (typep meaning 'box) (box-value meaning) meaning)
(error (format nil "Unknown variable: ~A" (with-output-to-string (out) (print-symbol variable out))))))) ;TODO proper condition class
(defmethod transform ((transformer simple-evaluator) (form variable-write) environment)
(let* ((variable (accessed-variable-name form))
(meaning (meaning variable +kind-variable+ environment)))
(if meaning
(if (typep meaning 'box)
(setf (box-value meaning) (transform transformer (variable-write-form form) environment))
(error (format nil "Not a variable: ~A" (with-output-to-string (out) (print-symbol variable out))))) ;TODO proper condition class
(error (format nil "Unknown variable: ~A" (with-output-to-string (out) (print-symbol variable out))))))) ;TODO proper condition class
(defun check-function-lambda-list (ll)
(let (found-optional found-rest)
(fset:do-seq (arg ll)
(when found-rest
(error "No further arguments allowed after the rest argument: ~A" arg)) ;TODO specific condition class
(etypecase arg
(optional-function-argument (setf found-optional t))
(rest-function-argument (setf found-rest t))
(function-argument
(when found-optional
(error "No further regular arguments allowed after first optional argument: ~A" arg))))) ;TODO specific condition class
ll))
(defun to-lisp-lambda-list (lambda-list transformer environment)
(let ((result (list)) (symbols (list)) &optional-p rest-var)
(fset:do-seq (arg lambda-list)
(let ((symbol (make-symbol (symbol-name (function-argument-name arg)))))
(when (typep arg 'optional-function-argument)
(when (not &optional-p)
(push '&optional result)
(setf &optional-p t))
(when (function-argument-default-value arg)
(push (list symbol`(transform ,transformer ,(function-argument-default-value arg) ,environment))
result)
(push symbol symbols)
(return)))
(when (typep arg 'rest-function-argument)
(push '&rest result)
(setf rest-var symbol))
(push symbol result)
(push symbol symbols)))
(values
(nreverse result)
(nreverse symbols)
rest-var)))
(defmethod transform ((transformer simple-evaluator) (form interpreted-function) environment)
(declare (ignorable transformer environment))
form)
(defun make-interpreted-lambda-expression (lambda-list body transformer environment)
(multiple-value-bind (lisp-args variables rest-var)
(to-lisp-lambda-list lambda-list transformer environment)
`(lambda ,lisp-args
;;TODO declare args ignorable?
(transform ,transformer ,body
(let ((env ,environment))
,@(cl:loop :for i :from 0 :to (1- (fset:size lambda-list))
:collect `(setf env (augment-environment
env ,(function-argument-name (fset:@ lambda-list i)) +kind-variable+
(make-instance 'box :value ,(let ((var (nth i variables)))
(if (eq var rest-var)
`(fset:convert 'fset:seq ,var)
var)))))) ;TODO should they be constant?
env)))))
(defmethod transform ((transformer simple-evaluator) (form function) environment)
(let* ((lambda-list (check-function-lambda-list (function-lambda-list form)))
(body (function-expression form))
(fn (make-interpreted-lambda-expression lambda-list body transformer environment))
(interpreted-function (make-instance 'interpreted-function :lambda-list lambda-list)))
(closer-mop:set-funcallable-instance-function interpreted-function (compile nil fn))
interpreted-function))
(defun resolve-function (transformer function-designator environment)
(flet ((to-lisp-function (designator)
(typecase designator
((or interpreted-function cl:function closer-mop:funcallable-standard-object) designator)
(function (transform transformer designator environment))
(t (error "Not a function designator: ~S" designator))))) ;TODO proper condition class
(typecase function-designator
(symbol (let ((meaning (meaning function-designator +kind-function+ environment)))
(unless meaning
(error (format nil "Unknown function: ~A" (with-output-to-string (out) (print-symbol function-designator out))))) ;TODO proper condition class
(to-lisp-function meaning)))
(t (to-lisp-function (transform transformer function-designator environment))))))
(defmethod transform ((transformer simple-evaluator) (form function-access) environment)
(resolve-function transformer (accessed-function-designator form) environment))
(defmethod transform ((transformer simple-evaluator) (form function-call) environment)
(let ((lisp-function (resolve-function transformer (accessed-function-designator form) environment)))
(apply lisp-function
(fset:convert 'list (fset:image (lambda (a) (transform transformer a environment)) (function-arguments form))))))
(defmethod transform ((transformer simple-evaluator) (form conditional) environment)
(if (transform transformer (conditional-if form) environment)
(transform transformer (conditional-then form) environment)
(transform transformer (conditional-else form) environment)))
(defmethod transform ((transformer simple-evaluator) (form loop) environment)
(catch (loop-name form)
(cl:loop (transform transformer (loop-body form) environment))))
(defmethod transform ((transformer simple-evaluator) (form loop-break) environment)
(throw (loop-name form) (transform transformer (return-form form) environment)))
|#
| 8,711 | Common Lisp | .lisp | 156 | 51.198718 | 146 | 0.734498 | alessiostalla/treep | 3 | 0 | 5 | AGPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 490262795e2a0a773898903cd41ceeb7d0bf34523661ca5464c7262c4fe8c935 | 18,840 | [
-1
] |
18,841 | packages.lisp | alessiostalla_treep/src/level0/packages.lisp | (defpackage treep-impl
(:use :cl)
(:shadow cl:class cl:eval cl:find-symbol cl:function cl:generic-function cl:intern cl:load cl:loop cl:quote cl:read cl:slot-value cl:symbol cl:symbol-name cl:variable)
(:export #:binding
#:class #:class-definition #:class-reference #:conditional
#:environment #:*environment*
#:find-symbol #:form #:form-parent #:function #:function-argument #:function-call
#:intern #:internal-slot?
#:+kind-class+ #:+kind-function+ #:+kind-variable+
#:lisp-symbol #:load #:load-file
#:meaning #:method-definition
#:new-instance
#:quote
#:read-form #:read-symbol #:read-symbol-from-string #:+root-symbol+
#:seq #:sexp-->form #:simple-evaluator #:slot-definition #:slot-read #:slot-write #:specialized-function-argument #:symbol #:+symbol-treep+
#:transform
#:variable-access #:variable-definition
#:variable-read #:variable-write
#:with-read-symbol-syntax))
| 943 | Common Lisp | .lisp | 19 | 45.105263 | 169 | 0.695887 | alessiostalla/treep | 3 | 0 | 5 | AGPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | f4d298ccdeebfc144470f565b2cb6e9336d5945f2b194f39683a06b84e396263 | 18,841 | [
-1
] |
18,842 | s-expressions.lisp | alessiostalla_treep/src/level0/s-expressions.lisp | (in-package :treep-impl)
;;TODO is this still needed/useful?
(defgeneric form-template (form))
(defmethod form-template ((form form))
(let ((class (class-of form)))
`(,(class-name class) ,@(remove-if (lambda (x) (transient-slot? form x))
(closer-mop:class-slots class)))))
(defun sexp-->form (sexp)
(if (consp sexp)
(cond
((eq (car sexp) 'list)
(fset:convert 'fset:seq (mapcar #'sexp-->form (cdr sexp))))
((symbolp (car sexp)) (translate-complex-form sexp (find-class (car sexp))))
((symbol? (car sexp)) (translate-complex-form sexp (meaning (car sexp) +kind-class+)))
(t (fset:convert 'fset:seq (mapcar #'sexp-->form sexp))))
sexp))
(defun translate-complex-form (sexp form-class)
(unless (closer-mop:class-finalized-p form-class)
(closer-mop:finalize-inheritance form-class))
(let* ((template (form-template (closer-mop:class-prototype form-class)))
(slot-map (list))
(compiled-template (mapcar (lambda (x)
(if (typep x 'closer-mop:slot-definition)
(let* ((slot-name (closer-mop:slot-definition-name x))
(sym (make-symbol (format nil "?~A" slot-name))))
(push (cons sym slot-name) slot-map)
sym)
x))
template))
(matching-sexp (mapcar (lambda (x) (if (consp x) (sexp-->form x) x))
(ensure-list-length sexp (length compiled-template))))
(unification (cl-unification:unify compiled-template matching-sexp))
(result (make-instance form-class)))
(map nil (lambda (f)
(map nil (lambda (b)
(setf (cl:slot-value result (cdr (assoc (car b) slot-map))) (cdr b)))
(cl-unification::frame-bindings f)))
(cl-unification::environment-frames unification))
result))
(defun ensure-list-length (list length &optional fill-with)
(let ((diff (- length (length list))))
(if (> diff 0)
(append list (make-list diff :initial-element fill-with))
list)))
(defclass sexp-transformer () ())
(defmethod transform ((transformer sexp-transformer) form environment)
form)
(defmethod transform ((transformer sexp-transformer) (form list) environment)
`(list ,@(mapcar (lambda (form) (transform transformer form environment)) form)))
(defmethod transform ((transformer sexp-transformer) (form fset:seq) environment)
`(list ,@(fset:convert 'list (fset:image (lambda (form) (transform transformer form environment)) form))))
(defmethod transform ((transformer sexp-transformer) (form form) environment)
(let ((template (form-template form)))
(mapcar (lambda (x)
(if (typep x 'closer-mop:slot-definition)
(if (slot-boundp form (closer-mop:slot-definition-name x))
(transform transformer (cl:slot-value form (closer-mop:slot-definition-name x)) environment)
nil)
x))
template)))
(defmethod print-object ((object form) stream)
(print `(sexp-->form ',(transform (make-instance 'sexp-transformer) object *environment*)) stream))
(defmethod cl-unification::occurs-in-p ((var cl:symbol) (pat form) env)
nil) ;To avoid WARNING: Occurrence test unimplemented for pattern...
(defmethod cl-unification::occurs-in-p ((var cl:symbol) (pat symbol) env)
nil) ;To avoid WARNING: Occurrence test unimplemented for pattern...
(defmethod cl-unification::occurs-in-p ((var cl:symbol) (pat fset:seq) env)
(fset:find var pat))
(defmethod cl-unification::occurs-in-p ((var cl:symbol) (pat fset:wb-seq) env)
(fset:find var pat))
| 3,391 | Common Lisp | .lisp | 70 | 44.3 | 108 | 0.692029 | alessiostalla/treep | 3 | 0 | 5 | AGPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | ae9d8a3903ec780a42405b2bf83e2907e60aa3d3b59c6579c5382c95769b64f6 | 18,842 | [
-1
] |
18,843 | object-system.lisp | alessiostalla_treep/tests/object-system.lisp | (defpackage treep/tests/object-system
(:use :cl
:treep-impl
:rove)
(:shadowing-import-from :treep-impl #:class #:find-symbol #:function #:intern #:load #:quote #:symbol))
(in-package :treep/tests/object-system)
;; NOTE: To run this test file, execute `(asdf:test-system :treep)' in your Lisp.
(deftest classes-and-slots
(testing "Empty class definition"
(let* ((name (intern "x" (intern "treep/tests/object-system" +root-symbol+)))
(form (make-instance 'binding
:definition (make-instance 'class-definition :name name)
:body (make-instance 'class-reference :class-name name)))
(result (transform (make-instance 'simple-evaluator) form *environment*)))
(ok (typep result 'cl:class))
(ok (equal (closer-mop:class-direct-superclasses result) (list (find-class 'standard-object))))
(ok (typep (make-instance result) 'cl:standard-object))))
(testing "Class definition with one slot"
(let* ((name (intern "x" (intern "treep/tests/object-system" +root-symbol+)))
(form (make-instance 'binding
:definition (make-instance 'class-definition
:name name
:slots (fset:seq (make-instance 'slot-definition :name name)))
:body (make-instance 'class-reference :class-name name)))
(result (make-instance (transform (make-instance 'simple-evaluator) form *environment*))))
(ok (not (slot-boundp result (lisp-symbol name))))
(ok (equal (list (lisp-symbol name)) (mapcar #'closer-mop:slot-definition-name (closer-mop:class-slots (class-of result)))))))
(testing "Reading and writing slots"
(let* ((name (intern "x" (intern "treep/tests/object-system" +root-symbol+)))
(form (make-instance 'binding
:definition (make-instance 'class-definition
:name name
:slots (fset:seq (make-instance 'slot-definition :name name)))
:body (make-instance 'binding
:definition (make-instance 'variable-definition
:name name
:init-form (make-instance 'new-instance
:class (make-instance 'class-reference :class-name name)))
:body (fset:seq
(make-instance 'slot-write :object (make-instance 'variable-read :name name) :slot-name name :new-value 42)
(make-instance 'slot-read :object (make-instance 'variable-read :name name) :slot-name name)))))
(result (transform (make-instance 'simple-evaluator) form *environment*)))
(ok (= result 42)))))
(deftest methods
(testing "Simple method on symbol, implicit gf declaration"
(let* ((name (intern "m" +root-symbol+))
(form (make-instance 'binding
:definition (make-instance 'method-definition
:name name
:lambda-list (fset:seq (make-instance 'specialized-function-argument
:name name
:specializer (find-class 'symbol)))
:expression (make-instance 'variable-read :name name))
:body (make-instance 'function-call :function name :arguments (fset:seq name))))
(result (transform (make-instance 'simple-evaluator) form *environment*)))
(ok (eq name result)))))
| 3,115 | Common Lisp | .lisp | 56 | 48.267857 | 132 | 0.66623 | alessiostalla/treep | 3 | 0 | 5 | AGPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 2723c0288532dc29bf3eb40548db5a7ae532ce14a026fbdfd3d104ea8870c1c4 | 18,843 | [
-1
] |
18,844 | main.lisp | alessiostalla_treep/tests/main.lisp | (defpackage treep/tests/main
(:use :cl
:treep-impl
:rove)
(:shadowing-import-from :treep-impl class find-symbol function intern load quote symbol))
(in-package :treep/tests/main)
;; NOTE: To run this test file, execute `(asdf:test-system :treep)' in your Lisp.
(deftest smoke-test
(testing "(= 1 1) should eval to true"
(ok (= 1 1))))
(deftest symbols-test
(testing "We can find imported symbols"
(ok (eq treep-impl::+symbol-treep+ (find-symbol "treep" treep-impl::+root-symbol+)))
(ok (eq treep-impl::+symbol-seq+ (find-symbol "seq" treep-impl::+symbol-treep+))))
(testing "Symbol identity persists through file compilation"
(ok (eq (load-time-value (intern "test" treep-impl::+root-symbol+)) (intern "test" treep-impl::+root-symbol+)))
;; Note compiling then loading a compiled file doesn't preserve the identity of uninterned symbols, so if we want to generate
;; Lisp s-expressions and dump those to a file to file-compile it, a strategy is needed to replace literal symbols with calls to intern.
(ok (not (eq '#.(intern "test" treep-impl::+root-symbol+) (intern "test" treep-impl::+root-symbol+)))))
(testing "The default search path of a symbol includes its parent"
(ok (eq treep-impl::+symbol-seq+ (find-symbol "seq" treep-impl::+symbol-repl+)))))
#|
(deftest forms-test
(testing "Nested forms have the enclosing form as parent"
(let* ((def (make-instance 'variable-definition))
(var (intern "a" +root-symbol+))
(form (make-instance 'binding :name var :definition def)))
(ok (eq (form-parent def) form)))))
|#
(deftest evaluator/basic
(testing "Lisp objects (e.g., numbers) should eval to themselves"
(ok (= 1 (transform (make-instance 'simple-evaluator) 1 *environment*))))
#|
(testing "(binding ((var a)) a) should eval to nil"
(let* ((var (intern "a" +root-symbol+))
(form (make-instance 'binding :definition (make-instance 'variable-definition :name var)
:body (make-instance 'variable-read :name var)))
(result (transform (make-instance 'simple-evaluator) form *environment*)))
(ok (null result))))
(testing "(binding ((var a 1)) a) should eval to 1"
(let* ((var (intern "a" +root-symbol+))
(value 1)
(form (make-instance 'binding :definition (make-instance 'variable-definition :name var :init-form value)
:body (make-instance 'variable-read :name var)))
(result (transform (make-instance 'simple-evaluator) form *environment*)))
(ok (= value result))))
(testing "(if t 1) should eval to 1"
(let* ((value 1)
(form (make-instance 'conditional :condition t :then value))
(result (transform (make-instance 'simple-evaluator) form *environment*)))
(ok (= value result))))|#
)
#|
(deftest evaluator+reader
(testing "Evaluating the form (binding (variable-definition a 1) (variable-read a)) should eval to 1"
(with-read-symbol-syntax ()
(let* ((form (with-input-from-string (s "(binding (variable-definition a 1) (variable-read a))") (read-form s *environment*)))
(result (transform (make-instance 'simple-evaluator) form *environment*)))
(ok (= 1 result)))))
(testing "Evaluating the form (binding (function-definition f (function [(function-argument x)] (variable-read x))) (function-call f [1])) should eval to 1"
(with-read-symbol-syntax ()
(let* ((form (with-input-from-string (s "(binding (function-definition f (function [(function-argument x)] (variable-read x))) (function-call f [1]))") (read-form s *environment*))))
(ok (typep form 'standard-object))
(ok (= 1 (transform (make-instance 'simple-evaluator) form *environment*)))))))
(deftest evaluator-function-call-protocol
(testing "An optional function argument with no default, which is not provided, evaluates to nil"
(with-read-symbol-syntax ()
(let* ((*package* (find-package :treep-impl))
(form (sexp-->form (read-from-string "(binding (function-definition #^f (function ((optional-function-argument #^x)) (variable-read #^x))) (function-call #^f))")))
(result (transform (make-instance 'simple-evaluator) form *environment*)))
(ok (null result)))))
(testing "An optional function argument which is not provided evaluates to its default value"
(with-read-symbol-syntax ()
(let* ((*package* (find-package :treep-impl))
(form (sexp-->form (read-from-string "(binding (function-definition #^f (function ((optional-function-argument #^x 1)) (variable-read #^x))) (function-call #^f))")))
(result (transform (make-instance 'simple-evaluator) form *environment*)))
(ok (= 1 result)))))
(testing "A rest function argument accumulates all the remaining arguments into a list"
(with-read-symbol-syntax ()
(let* ((*package* (find-package :treep-impl))
(form (sexp-->form (read-from-string "(binding (function-definition #^f (function ((rest-function-argument #^x)) (variable-read #^x))) (function-call #^f (1 2 3)))")))
(result (transform (make-instance 'simple-evaluator) form *environment*)))
(ok (typep result 'fset:seq))
(ok (= (fset:size result) 3))
(ok (= (fset:@ result 0) 1))))))
|#
| 5,132 | Common Lisp | .lisp | 86 | 55.465116 | 188 | 0.682811 | alessiostalla/treep | 3 | 0 | 5 | AGPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 6af915e9141b84e6c6d4f4e5077f848ae95e22743b87c86406a5edb3d5b7a9e5 | 18,844 | [
-1
] |
18,845 | treep.asd | alessiostalla_treep/treep.asd | (defsystem "treep"
:version "0.1.0"
:author "Alessio Stalla"
:license "AGPL"
:depends-on ("closer-mop" "fset")
:components ((:module "src/level0"
:components
((:file "packages")
(:file "symbols") (:file "symbols-io")
(:file "forms") (:file "abstractions")
(:file "reader")
(:file "printer")
(:file "evaluator")
(:file "loader")
(:file "repl")
;;TODO (:file "lisp") (:file "object-system") (:file "level1-boot")
)))
:description "The Treep language"
:in-order-to ((test-op (test-op "treep/tests"))))
(defsystem "treep/tests"
:author "Alessio Stalla"
:license "AGPL"
:depends-on ("treep" "rove")
:components ((:module "tests"
:components
((:file "main")))) ;TODO (:file "object-system"))))
:description "Test system for treep"
:perform (test-op (op c) (symbol-call :rove :run c)))
(defsystem "treep/server"
:version "0.1.0"
:author "Alessio Stalla"
:license "AGPL"
:depends-on ("treep" "ningle" "cl-json")
:components ((:module "src/server"
:components
((:file "server"))))
:description "HTTP access to the running Treep image")
| 1,190 | Common Lisp | .asd | 37 | 26.756757 | 70 | 0.596872 | alessiostalla/treep | 3 | 0 | 5 | AGPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 548b0e898a03a7b43d36ab90f4c95233c9d5dd5dee293ceff3031e72a1d42a64 | 18,845 | [
-1
] |
18,862 | ci.yml | alessiostalla_treep/.github/workflows/ci.yml | name: CI
# Github Actions allows for running jobs on a wide variety of events
on:
push: # Commits pushed to Github
pull_request: # Pull request is update
workflow_dispatch: # Manually dispatched from Github's UI
jobs:
test:
name: ${{ matrix.lisp }} on ${{ matrix.os }}
runs-on: ${{ matrix.os }}
strategy:
# Each combination of lisp and os are tested
matrix:
lisp: [sbcl-bin]
os: [ubuntu-latest]
steps:
- name: windows specific settings
if: matrix.os == 'windows-latest'
run: |
git config --global core.autocrlf false
echo "name=ROSWELL_INSTALL_DIR::$HOME/ros" >> $GITHUB_ENV
echo "$HOME/ros/bin" >> $GITHUB_PATH
- uses: actions/checkout@v1
- name: Install Roswell
env:
LISP: ${{ matrix.lisp }}
shell: bash
run: curl -L https://raw.githubusercontent.com/roswell/roswell/master/scripts/install-for-ci.sh | sh
- name: Install Test Framework
shell: bash
run: ros install rove # for [run-] rove
- name: Run tests
shell: bash
run: ~/.roswell/bin/rove treep.asd | 1,152 | Common Lisp | .l | 34 | 27.117647 | 108 | 0.61828 | alessiostalla/treep | 3 | 0 | 5 | AGPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 4e3d2f821da9b8b92453169226db29c761f70b7dc2659d83d8029741d005f622 | 18,862 | [
-1
] |
18,865 | test-load-1.treep | alessiostalla_treep/tests/test-load-1.treep | (install-definition! #^x (variable-definition 42))
(install-definition! #^y (variable-definition #^y))
(install-definition! #^z (variable-definition (quote (variable-read #^z))))
(install-definition! #^k (variable-definition (variable-read #^x))) | 246 | Common Lisp | .l | 4 | 60.75 | 75 | 0.73251 | alessiostalla/treep | 3 | 0 | 5 | AGPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 741460192064a52c99a6e6c6eee181a0e30410a88e44345f4c68a70175884b1e | 18,865 | [
-1
] |
18,880 | package.lisp | glv2_cl-lzlib/src/package.lisp | ;;; This file is part of cl-lzlib
;;; Copyright 2019-2022 Guillaume LE VAILLANT
;;; Distributed under the GNU GPL v3 or later.
;;; See the file LICENSE for terms of use and distribution.
(defpackage :lzlib
(:use :cl :trivial-gray-streams)
(:export #:compress-stream
#:compress-file
#:compress-buffer
#:decompress-stream
#:decompress-file
#:decompress-buffer
#:lzlib-error
#:make-compressing-stream
#:make-decompressing-stream
#:with-compressing-stream
#:with-decompressing-stream))
| 597 | Common Lisp | .lisp | 17 | 27.352941 | 59 | 0.632124 | glv2/cl-lzlib | 3 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 9fc9687316414f076aee615c38f0ba27e4aa7c65cfc78f6ca15bb65880ad4710 | 18,880 | [
-1
] |
18,881 | lzlib.lisp | glv2_cl-lzlib/src/lzlib.lisp | ;;; This file is part of cl-lzlib
;;; Copyright 2019 Guillaume LE VAILLANT
;;; Distributed under the GNU GPL v3 or later.
;;; See the file LICENSE for terms of use and distribution.
(in-package :lzlib)
(deftype i32 () '(signed-byte 32))
(deftype u32 () '(unsigned-byte 32))
(deftype u64 () '(unsigned-byte 64))
(cffi:define-foreign-library lzlib
(:unix (:or "liblz.so"
"liblz.so.1"))
(t (:default "liblz")))
(cffi:use-foreign-library lzlib)
;;;
;;; Library version
;;;
(declaim (ftype (function () t) lz-version))
(cffi:defcfun ("LZ_version" lz-version) :string
"Returns the library version as a string.")
;;;
;;; Errors
;;;
(defconstant +lz-ok+ 0
"The value of this constant is 0 and is used to indicate that there is no
error.")
(defconstant +lz-bad-argument+ 1
"At least one of the arguments passed to the library function was invalid.")
(defconstant +lz-mem-error+ 2
"No memory available. The system cannot allocate more virtual memory because
its capacity is full.")
(defconstant +lz-sequence-error+ 3
"A library function was called in the wrong order. For example
'LZ_compress_restart_member' was called before 'LZ_compress_member_finished'
indicates that the current member is finished.")
(defconstant +lz-header-error+ 4
"An invalid member header (one with the wrong magic bytes) was read. If this
happens at the end of the data stream it may indicate trailing data.")
(defconstant +lz-unexpected-eof+ 5
"The end of the data stream was reached in the middle of a member.")
(defconstant +lz-data-error+ 6
"The data stream is corrupt. If 'LZ_decompress_member_position' is 6 or less,
it indicates either a format version not supported, an invalid dictionary size,
a corrupt header in a multimember data stream, or trailing data too similar to
a valid lzip header. Lziprecover can be used to remove conflicting trailing data
from a file.")
(defconstant +lz-library-error+ 7
"A bug was detected in the library.")
(declaim (ftype (function (i32) t) lz-strerror))
(cffi:defcfun ("LZ_strerror" lz-strerror) :string
"Returns the standard error message for a given error code. The messages are
fairly short; there are no multi-line messages or embedded newlines. This
function makes it easy for your program to report informative error messages
about the failure of a library call. The value of lz_errno normally comes from
a call to 'LZ_(de)compress_errno'."
(lz-errno :int))
;;;
;;; Parameter limits
;;;
(declaim (ftype (function () i32) lz-min-dictionary-bits))
(cffi:defcfun ("LZ_min_dictionary_bits" lz-min-dictionary-bits) :int
"Returns the base 2 logarithm of the smallest valid dictionary size.")
(declaim (ftype (function () i32) lz-min-dictionary-size))
(cffi:defcfun ("LZ_min_dictionary_size" lz-min-dictionary-size) :int
"Returns the smallest valid dictionary size.")
(declaim (ftype (function () i32) lz-max-dictionary-bits))
(cffi:defcfun ("LZ_max_dictionary_bits" lz-max-dictionary-bits) :int
"Returns the base 2 logarithm of the largest valid dictionary size.")
(declaim (ftype (function () i32) lz-max-dictionary-size))
(cffi:defcfun ("LZ_max_dictionary_size" lz-max-dictionary-size) :int
"Returns the largest valid dictionary size.")
(declaim (ftype (function () i32) lz-min-match-len-limit))
(cffi:defcfun ("LZ_min_match_len_limit" lz-min-match-len-limit) :int
"Returns the smallest valid match length limit.")
(declaim (ftype (function () i32) lz-max-match-len-limit))
(cffi:defcfun ("LZ_max_match_len_limit" lz-max-match-len-limit) :int
"Returns the largest valid match length limit.")
;;;
;;; Compression functions
;;;
;;; These are the functions used to compress data. In case of error, all of them
;;; return -1 or 0, for signed and unsigned return values respectively, except
;;; 'LZ_compress_open' whose return value must be verified by calling
;;; 'LZ_compress_errno' before using it.
;;;
(declaim (ftype (function (i32 i32 u64) t) lz-compress-open))
(cffi:defcfun ("LZ_compress_open" lz-compress-open) :pointer
"Initializes the internal stream state for compression and returns a pointer
that can only be used as the encoder argument for the other LZ_compress
functions, or a null pointer if the encoder could not be allocated. The returned
pointer must be verified by calling 'LZ_compress_errno' before using it. If
'LZ_compress_errno' does not return 'LZ_ok', the returned pointer must not be
used and should be freed with 'LZ_compress_close' to avoid memory leaks.
dictionary_size sets the dictionary size to be used, in bytes. Valid values
range from 4 KiB to 512 MiB. Note that dictionary sizes are quantized. If the
specified size does not match one of the valid sizes, it will be rounded upwards
by adding up to (dictionary_size / 8) to it. match_len_limit sets the match
length limit in bytes. Valid values range from 5 to 273. Larger values usually
give better compression ratios but longer compression times. If dictionary_size
is 65535 and match_len_limit is 16, the fast variant of LZMA is chosen, which
produces identical compressed output as lzip -0. (The dictionary size used will
be rounded upwards to 64 KiB). member_size sets the member size limit in bytes.
Valid values range from 100 kB to 2 PiB. Small member size may degrade
compression ratio, so use it only when needed. To produce a single-member data
stream, give member_size a value larger than the amount of data to be produced.
Values larger than 2 PiB will be reduced to 2 PiB to prevent the uncompressed
size of the member from overflowing."
(dictionary-size :int)
(match-len-limit :int)
(member-size :unsigned-long-long))
(declaim (ftype (function (t) i32) lz-compress-close))
(cffi:defcfun ("LZ_compress_close" lz-compress-close) :int
"Frees all dynamically allocated data structures for this stream. This
function discards any unprocessed input and does not flush any pending output.
After a call to 'LZ_compress_close', encoder can no longer be used as an
argument to any LZ_compress function."
(encoder :pointer))
(declaim (ftype (function (t) i32) lz-compress-finish))
(cffi:defcfun ("LZ_compress_finish" lz-compress-finish) :int
"Use this function to tell 'lzlib' that all the data for this member have
already been written (with the 'LZ_compress_write' function). It is safe to call
'LZ_compress_finish' as many times as needed. After all the produced compressed
data have been read with 'LZ_compress_read' and 'LZ_compress_member_finished'
returns 1, a new member can be started with 'LZ_compress_restart_member'."
(encoder :pointer))
(declaim (ftype (function (t u64) i32) lz-compress-restart-member))
(cffi:defcfun ("LZ_compress_restart_member" lz-compress-restart-member) :int
"Use this function to start a new member in a multimember data stream. Call
this function only after 'LZ_compress_member_finished' indicates that the
current member has been fully read (with the 'LZ_compress_read' function)."
(encoder :pointer)
(member-size :unsigned-long-long))
(declaim (ftype (function (t) i32) lz-compress-sync-flush))
(cffi:defcfun ("LZ_compress_sync_flush" lz-compress-sync-flush) :int
"Use this function to make available to 'LZ_compress_read' all the data
already written with the 'LZ_compress_write' function. First call
'LZ_compress_sync_flush'. Then call 'LZ_compress_read' until it returns 0.
Repeated use of 'LZ_compress_sync_flush' may degrade compression ratio, so use
it only when needed."
(encoder :pointer))
(declaim (ftype (function (t t i32) i32) lz-compress-read))
(cffi:defcfun ("LZ_compress_read" lz-compress-read) :int
"The 'LZ_compress_read' function reads up to size bytes from the stream
pointed to by encoder, storing the results in buffer. The return value is the
number of bytes actually read. This might be less than size; for example, if
there aren't that many bytes left in the stream or if more bytes have to be yet
written with the 'LZ_compress_write' function. Note that reading less than size
bytes is not an error."
(encoder :pointer)
(buffer :pointer)
(size :int))
(declaim (ftype (function (t t i32) i32) lz-compress-write))
(cffi:defcfun ("LZ_compress_write" lz-compress-write) :int
"The 'LZ_compress_write' function writes up to size bytes from buffer to the
stream pointed to by encoder. The return value is the number of bytes actually
written. This might be less than size. Note that writing less than size bytes is
not an error."
(encoder :pointer)
(buffer :pointer)
(size :int))
(declaim (ftype (function (t) i32) lz-compress-write-size))
(cffi:defcfun ("LZ_compress_write_size" lz-compress-write-size) :int
"The 'LZ_compress_write_size' function returns the maximum number of bytes
that can be immediately written through the 'LZ_compress_write' function. It is
guaranteed that an immediate call to 'LZ_compress_write' will accept a size up
to the returned number of bytes."
(encoder :pointer))
(declaim (ftype (function (t) i32) lz-compress-errno))
(cffi:defcfun ("LZ_compress_errno" lz-compress-errno) :int
"Returns the current error code for encoder."
(encoder :pointer))
(declaim (ftype (function (t) i32) lz-compress-finished))
(cffi:defcfun ("LZ_compress_finished" lz-compress-finished) :int
"Returns 1 if all the data have been read and 'LZ_compress_close' can be
safely called. Otherwise it returns 0. 'LZ_compress_finished' implies
'LZ_compress_member_finished'."
(encoder :pointer))
(declaim (ftype (function (t) i32) lz-compress-member-finished))
(cffi:defcfun ("LZ_compress_member_finished" lz-compress-member-finished) :int
"Returns 1 if the current member, in a multimember data stream, has been fully
read and 'LZ_compress_restart_member' can be safely called. Otherwise it returns
0."
(encoder :pointer))
(declaim (ftype (function (t) u64) lz-compress-data-position))
(cffi:defcfun ("LZ_compress_data_position" lz-compress-data-position) :unsigned-long-long
"Returns the number of input bytes already compressed in the current member."
(encoder :pointer))
(declaim (ftype (function (t) u64) lz-compress-member-position))
(cffi:defcfun ("LZ_compress_member_position" lz-compress-member-position) :unsigned-long-long
"Returns the number of compressed bytes already produced, but perhaps not yet
read, in the current member."
(encoder :pointer))
(declaim (ftype (function (t) u64) lz-compress-total-in-size))
(cffi:defcfun ("LZ_compress_total_in_size" lz-compress-total-in-size) :unsigned-long-long
"Returns the total number of input bytes already compressed."
(encoder :pointer))
(declaim (ftype (function (t) u64) lz-compress-total-out-size))
(cffi:defcfun ("LZ_compress_total_out_size" lz-compress-total-out-size) :unsigned-long-long
"Returns the total number of compressed bytes already produced, but perhaps
not yet read."
(encoder :pointer))
;;;
;;; Decompression functions
;;;
;;; These are the functions used to decompress data. In case of error, all of
;;; them return -1 or 0, for signed and unsigned return values respectively,
;;; except 'LZ_decompress_open' whose return value must be verified by calling
;;; 'LZ_decompress_errno' before using it.
;;;
(declaim (ftype (function () t) lz-decompress-open))
(cffi:defcfun ("LZ_decompress_open" lz-decompress-open) :pointer
"Initializes the internal stream state for decompression and returns a pointer
that can only be used as the decoder argument for the other LZ_decompress
functions, or a null pointer if the decoder could not be allocated. The returned
pointer must be verified by calling 'LZ_decompress_errno' before using it. If
'LZ_decompress_errno' does not return 'LZ_ok', the returned pointer must not be
used and should be freed with 'LZ_decompress_close' to avoid memory leaks.")
(declaim (ftype (function (t) i32) lz-decompress-close))
(cffi:defcfun ("LZ_decompress_close" lz-decompress-close) :int
"Frees all dynamically allocated data structures for this stream. This
function discards any unprocessed input and does not flush any pending output.
After a call to 'LZ_decompress_close', decoder can no longer be used as an
argument to any LZ_decompress function."
(decoder :pointer))
(declaim (ftype (function (t) i32) lz-decompress-finish))
(cffi:defcfun ("LZ_decompress_finish" lz-decompress-finish) :int
"Use this function to tell 'lzlib' that all the data for this stream have
already been written (with the 'LZ_decompress_write' function). It is safe to
call 'LZ_decompress_finish' as many times as needed."
(decoder :pointer))
(declaim (ftype (function (t) i32) lz-decompress-reset))
(cffi:defcfun ("LZ_decompress_reset" lz-decompress-reset) :int
"Resets the internal state of decoder as it was just after opening it with the
'LZ_decompress_open' function. Data stored in the internal buffers is discarded.
Position counters are set to 0."
(decoder :pointer))
(declaim (ftype (function (t) i32) lz-decompress-sync-to-member))
(cffi:defcfun ("LZ_decompress_sync_to_member" lz-decompress-sync-to-member) :int
"Resets the error state of decoder and enters a search state that lasts until
a new member header (or the end of the stream) is found. After a successful call
to 'LZ_decompress_sync_to_member', data written with 'LZ_decompress_write' will
be consumed and 'LZ_decompress_read' will return 0 until a header is found. This
function is useful to discard any data preceding the first member, or to discard
the rest of the current member, for example in case of a data error. If the
decoder is already at the beginning of a member, this function does nothing."
(decoder :pointer))
(declaim (ftype (function (t t i32) i32) lz-decompress-read))
(cffi:defcfun ("LZ_decompress_read" lz-decompress-read) :int
"The 'LZ_decompress_read' function reads up to size bytes from the stream
pointed to by decoder, storing the results in buffer. The return value is the
number of bytes actually read. This might be less than size; for example, if
there aren't that many bytes left in the stream or if more bytes have to be yet
written with the 'LZ_decompress_write' function. Note that reading less than
size bytes is not an error. In case of decompression error caused by corrupt or
truncated data, 'LZ_decompress_read' does not signal the error immediately to
the application, but waits until all decoded bytes have been read. This allows
tools like tarlz to recover as much data as possible from each damaged member."
(decoder :pointer)
(buffer :pointer)
(size :int))
(declaim (ftype (function (t t i32) i32) lz-decompress-write))
(cffi:defcfun ("LZ_decompress_write" lz-decompress-write) :int
"The 'LZ_decompress_write' function writes up to size bytes from buffer to the
stream pointed to by decoder. The return value is the number of bytes actually
written. This might be less than size. Note that writing less than size bytes is
not an error."
(decoder :pointer)
(buffer :pointer)
(size :int))
(declaim (ftype (function (t) i32) lz-decompress-write-size))
(cffi:defcfun ("LZ_decompress_write_size" lz-decompress-write-size) :int
"The 'LZ_decompress_write_size' function returns the maximum number of bytes
that can be immediately written through the 'LZ_decompress_write' function. It
is guaranteed that an immediate call to 'LZ_decompress_write' will accept a size
up to the returned number of bytes."
(decoder :pointer))
(declaim (ftype (function (t) i32) lz-decompress-errno))
(cffi:defcfun ("LZ_decompress_errno" lz-decompress-errno) :int
"Returns the current error code for decoder."
(decoder :pointer))
(declaim (ftype (function (t) i32) lz-decompress-finished))
(cffi:defcfun ("LZ_decompress_finished" lz-decompress-finished) :int
"Returns 1 if all the data have been read and 'LZ_decompress_close' can be
safely called. Otherwise it returns 0."
(decoder :pointer))
(declaim (ftype (function (t) i32) lz-decompress-member-finished))
(cffi:defcfun ("LZ_decompress_member_finished" lz-decompress-member-finished) :int
"Returns 1 if the previous call to 'LZ_decompress_read' finished reading the
current member, indicating that final values for member are available through
'LZ_decompress_data_crc', 'LZ_decompress_data_position', and
'LZ_decompress_member_position'. Otherwise it returns 0."
(decoder :pointer))
(declaim (ftype (function (t) i32) lz-decompress-member-version))
(cffi:defcfun ("LZ_decompress_member_version" lz-decompress-member-version) :int
"Returns the version of current member from member header."
(decoder :pointer))
(declaim (ftype (function (t) i32) lz-decompress-dictionary-size))
(cffi:defcfun ("LZ_decompress_dictionary_size" lz-decompress-dictionary-size) :int
"Returns the dictionary size of current member from member header."
(decoder :pointer))
(declaim (ftype (function (t) u32) lz-decompress-data-crc))
(cffi:defcfun ("LZ_decompress_data_crc" lz-decompress-data-crc) :unsigned-int
"Returns the 32 bit Cyclic Redundancy Check of the data decompressed from the
current member. The returned value is valid only when
'LZ_decompress_member_finished' returns 1."
(decoder :pointer))
(declaim (ftype (function (t) u64) lz-decompress-data-position))
(cffi:defcfun ("LZ_decompress_data_position" lz-decompress-data-position) :unsigned-long-long
"Returns the number of decompressed bytes already produced, but perhaps not
yet read, in the current member."
(decoder :pointer))
(declaim (ftype (function (t) u64) lz-decompress-member-position))
(cffi:defcfun ("LZ_decompress_member_position" lz-decompress-member-position) :unsigned-long-long
"Returns the number of input bytes already decompressed in the current
member."
(decoder :pointer))
(declaim (ftype (function (t) u64) lz-decompress-total-in-size))
(cffi:defcfun ("LZ_decompress_total_in_size" lz-decompress-total-in-size) :unsigned-long-long
"Returns the total number of input bytes already decompressed."
(decoder :pointer))
(declaim (ftype (function (t) u64) lz-decompress-total-out-size))
(cffi:defcfun ("LZ_decompress_total_out_size" lz-decompress-total-out-size) :unsigned-long-long
"Returns the total number of decompressed bytes already produced, but perhaps
not yet read."
(decoder :pointer))
| 18,104 | Common Lisp | .lisp | 324 | 54.049383 | 97 | 0.770546 | glv2/cl-lzlib | 3 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 0ae53a7058353f92d32efdad6bad5ecc829ff952827802c5c772225746e516e1 | 18,881 | [
-1
] |
18,882 | lzip.lisp | glv2_cl-lzlib/src/lzip.lisp | ;;; This file is part of cl-lzlib
;;; Copyright 2019-2022 Guillaume LE VAILLANT
;;; Distributed under the GNU GPL v3 or later.
;;; See the file LICENSE for terms of use and distribution.
(in-package :lzlib)
(deftype u8 () '(unsigned-byte 8))
(defconstant +buffer-size+ 65536)
;;;
;;; Errors
;;;
(define-condition lzlib-error (simple-error)
())
(defmacro lz-error (message &rest args)
`(error 'lzlib-error
:format-control ,message
:format-arguments (list ,@args)))
;;;
;;; Compression Gray streams
;;;
(defclass compressing-stream (fundamental-binary-output-stream)
((output-stream :accessor output-stream)
(encoder :accessor encoder)
(member-size :accessor member-size)
(buffer :accessor buffer)))
(defmethod stream-element-type ((stream compressing-stream))
'(unsigned-byte 8))
(defun compress-and-write (stream)
(with-slots (output-stream encoder buffer buffer-end) stream
(cffi:with-pointer-to-vector-data (ffi-buffer buffer)
(do ((n (lz-compress-read encoder ffi-buffer +buffer-size+)
(lz-compress-read encoder ffi-buffer +buffer-size+)))
((zerop n))
(if (minusp n)
(lz-error "LZ-COMPRESS-READ error: ~a."
(lz-strerror (lz-compress-errno encoder)))
(write-sequence buffer output-stream :end n))))))
(defmethod stream-write-byte ((stream compressing-stream) byte)
(with-slots (encoder member-size buffer) stream
(cffi:with-pointer-to-vector-data (ffi-buffer buffer)
(setf (aref buffer 0) byte)
(when (= (lz-compress-member-finished encoder) 1)
(when (minusp (lz-compress-restart-member encoder member-size))
(lz-error "LZ-COMPRESS-RESTART-MEMBER error: ~a."
(lz-strerror (lz-compress-errno encoder)))))
(unless (= (lz-compress-write encoder ffi-buffer 1) 1)
(lz-error "Library error (LZ-COMPRESS-WRITE)."))))
(compress-and-write stream)
byte)
(defmethod stream-write-sequence ((stream compressing-stream) seq start end
&key &allow-other-keys)
(with-slots (encoder member-size buffer) stream
(cffi:with-pointer-to-vector-data (ffi-buffer buffer)
(do ((n (min (lz-compress-write-size encoder)
(- end start)
+buffer-size+)
(min (lz-compress-write-size encoder)
(- end start)
+buffer-size+)))
((zerop n))
(replace buffer seq :end1 n :start2 start)
(when (= (lz-compress-member-finished encoder) 1)
(when (minusp (lz-compress-restart-member encoder member-size))
(lz-error "LZ-COMPRESS-RESTART-MEMBER error: ~a."
(lz-strerror (lz-compress-errno encoder)))))
(unless (= (lz-compress-write encoder ffi-buffer n) n)
(lz-error "Library error (LZ-COMPRESS-WRITE)."))
(incf start n)
(compress-and-write stream))))
start)
(defmethod stream-finish-output ((stream compressing-stream))
(with-slots (output-stream encoder buffer) stream
(lz-compress-finish encoder)
(compress-and-write stream)
(finish-output output-stream))
nil)
(defmethod close ((stream compressing-stream) &key &allow-other-keys)
(when (open-stream-p stream)
(finish-output stream)
(with-slots (encoder buffer) stream
(lz-compress-close encoder)
(setf encoder nil)
(setf buffer nil)))
t)
(defun lzma-options (level dictionary-size match-len-limit)
"Get the LZMA parameters matching the given arguments."
(cond
((and dictionary-size (not match-len-limit))
(lz-error "MATCH-LEN-LIMIT is not set."))
((and match-len-limit (not dictionary-size))
(lz-error "DICTIONARY-SIZE is not set."))
((and dictionary-size match-len-limit)
(let ((min-dictionary-size (lz-min-dictionary-size))
(max-dictionary-size (lz-max-dictionary-size))
(min-match-len-limit (lz-min-match-len-limit))
(max-match-len-limit (lz-max-match-len-limit)))
(cond
((not (and (integerp dictionary-size)
(<= min-dictionary-size
dictionary-size
max-dictionary-size)))
(lz-error "DICTIONARY-SIZE must be between ~d and ~d."
min-dictionary-size
max-dictionary-size))
((not (and (integerp match-len-limit)
(<= min-match-len-limit
match-len-limit
max-match-len-limit)))
(lz-error "MATCH-LEN-LIMIT must be between ~d and ~d."
min-match-len-limit
max-match-len-limit))
(t
(list dictionary-size match-len-limit)))))
(level
(case level
((0) '(65535 16))
((1) '(1048576 5))
((2) '(1572864 6))
((3) '(2097152 8))
((4) '(3145728 12))
((5) '(4194304 20))
((6) '(8388608 36))
((7) '(16777216 68))
((8) '(25165824 132))
((9) '(33554432 273))
(t (lz-error "LEVEL must be between 0 and 9."))))
(t
(lz-error "Either LEVEL or DICTIONARY-SIZE and MATCH-LEN-LIMIT must be set."))))
(defun make-compressing-stream (output-stream
&key
(level 6) (member-size 2251799813685248)
dictionary-size match-len-limit)
"Return a stream that will compress the bytes written to it at the given
compression LEVEL and write them to the OUTPUT-STREAM."
(let ((stream (make-instance 'compressing-stream)))
(setf (output-stream stream) output-stream)
(unless (and (integerp member-size)
(<= 100000 member-size 2251799813685248))
(lz-error "MEMBER-SIZE must be bewteen 100000 and 2251799813685248."))
(setf (member-size stream) member-size)
(with-slots (encoder member-size buffer) stream
(destructuring-bind (dictionary-size match-len-limit)
(lzma-options level dictionary-size match-len-limit)
(setf encoder (lz-compress-open dictionary-size
match-len-limit
member-size))
(case (if (cffi:null-pointer-p encoder)
+lz-mem-error+
(lz-compress-errno encoder))
((#.+lz-ok+)
t)
((#.+lz-mem-error+)
(lz-compress-close encoder)
(lz-error "Not enough memory. Try a smaller dictionary size."))
(t
(lz-compress-close encoder)
(lz-error "Invalid argument to encoder."))))
(setf buffer (cffi:make-shareable-byte-vector +buffer-size+)))
stream))
(defmacro with-compressing-stream ((stream output-stream
&key
(level 6) (member-size 2251799813685248)
dictionary-size match-len-limit)
&body body)
"Within BODY, STREAM is bound to a compressing stream for the given
compression LEVEL and OUTPUT-STREAM. The result of the last form of BODY is
returned."
`(with-open-stream (,stream (make-compressing-stream
,output-stream
:level ,level
:member-size ,member-size
:dictionary-size ,dictionary-size
:match-len-limit ,match-len-limit))
,@body))
;;;
;;; Decompression Gray streams
;;;
(defclass decompressing-stream (fundamental-binary-input-stream)
((input-stream :accessor input-stream)
(decoder :accessor decoder)
(ignore-trailing :accessor ignore-trailing)
(loose-trailing :accessor loose-trailing)
(first-member :accessor first-member)
(buffer :accessor buffer)
(output :accessor output)
(output-index :accessor output-index)))
(defmethod stream-element-type ((stream decompressing-stream))
'(unsigned-byte 8))
(defun process-decompression-error (stream)
(with-slots (decoder first-member ignore-trailing loose-trailing) stream
(let ((member-pos (lz-decompress-member-position decoder))
(pos (lz-decompress-total-in-size decoder)))
(case (lz-decompress-errno decoder)
((#.+lz-library-error+)
(lz-error "Library error (LZ-DECOMPRESS-READ)."))
((#.+lz-header-error+)
(cond
(first-member
(lz-error "Bad magic number (file not in lzip format)."))
((not ignore-trailing)
(lz-error "Trailing data not allowed."))
(t
t)))
((#.+lz-mem-error+)
(lz-error "Not enough memory."))
((#.+lz-unexpected-eof+)
(cond
((> member-pos 6)
(lz-error "File ends unexpectedly at position ~d." pos))
(first-member
(lz-error "File ends unexpectedly at member header."))
(t
(lz-error "Truncated header in multimember file."))))
((#.+lz-data-error+)
(cond
((> member-pos 6)
(lz-error "Decoder error at position ~d." pos))
((= member-pos 4)
(lz-error "Version ~d member format not supported."
(lz-decompress-member-version decoder)))
((= member-pos 5)
(lz-error "Invalid dictionary size in member header."))
(first-member
(lz-error "Bad version or dictionary size in member header."))
((not loose-trailing)
(lz-error "Corrupt header in multimember file."))
((not ignore-trailing)
(lz-error "Trailing data not allowed."))
(t
t)))
(t
(lz-error "Decoder error at position ~d." pos))))))
(defun read-and-decompress (stream)
(with-slots (input-stream decoder first-member buffer output output-index)
stream
(cffi:with-pointer-to-vector-data (ffi-buffer buffer)
(let ((size (min (lz-decompress-write-size decoder) +buffer-size+)))
(when (plusp size)
(let ((n (read-sequence buffer input-stream :end size)))
(when (and (plusp n)
(/= (lz-decompress-write decoder ffi-buffer n) n))
(lz-error "Library error (LZ-DECOMPRESS-WRITE)."))
(when (< n size)
(lz-decompress-finish decoder)))))
(let* ((size (- +buffer-size+ output-index))
(n (lz-decompress-read decoder ffi-buffer size)))
(unless (or (minusp n) (and (zerop n) first-member))
(setf first-member
(when first-member
(zerop (lz-decompress-member-finished decoder))))
(replace output buffer :start1 output-index :end2 n)
(incf output-index n))
(when (minusp n)
(process-decompression-error stream))))
output-index))
(defmethod stream-listen ((stream decompressing-stream))
(with-slots (input-stream output-index) stream
(or (plusp output-index)
(listen input-stream))))
(defmethod stream-read-byte ((stream decompressing-stream))
(let ((available (read-and-decompress stream)))
(if (plusp available)
(with-slots (output output-index) stream
(let ((byte (aref output 0)))
(replace output output :start2 1 :end2 output-index)
(decf output-index)
byte))
:eof)))
(defmethod stream-read-sequence ((stream decompressing-stream) seq start end
&key &allow-other-keys)
(do ((available (read-and-decompress stream) (read-and-decompress stream)))
((or (= start end) (zerop available)))
(with-slots (output output-index) stream
(let ((n (min (- end start) output-index)))
(replace seq output :start1 start :end2 n)
(incf start n)
(replace output output :start2 n :end2 output-index)
(decf output-index n))))
start)
(defmethod close ((stream decompressing-stream) &key &allow-other-keys)
(when (open-stream-p stream)
(with-slots (decoder buffer output output-index) stream
(lz-decompress-close decoder)
(setf decoder nil)
(setf buffer nil)
(setf output nil)
(setf output-index nil)))
t)
(defun make-decompressing-stream (input-stream
&key (ignore-trailing t) loose-trailing)
"Return a stream that will supply the bytes resulting from the decompression
of the data read from the INPUT-STREAM."
(let ((stream (make-instance 'decompressing-stream)))
(setf (input-stream stream) input-stream)
(setf (ignore-trailing stream) ignore-trailing)
(setf (loose-trailing stream) loose-trailing)
(with-slots (decoder first-member buffer output output-index)
stream
(setf decoder (lz-decompress-open))
(case (if (cffi:null-pointer-p decoder)
+lz-mem-error+
(lz-decompress-errno decoder))
((#.+lz-ok+)
t)
(t
(lz-decompress-close decoder)
(lz-error "Not enough memory.")))
(setf first-member t)
(setf buffer (cffi:make-shareable-byte-vector +buffer-size+))
(setf output (make-array +buffer-size+ :element-type 'u8))
(setf output-index 0))
stream))
(defmacro with-decompressing-stream ((stream input-stream
&key (ignore-trailing t) loose-trailing)
&body body)
"Within BODY, STREAM is bound to a decompressing stream for the given
INPUT-STREAM. The result of the last form of BODY is returned."
`(with-open-stream (,stream (make-decompressing-stream
,input-stream
:ignore-trailing ,ignore-trailing
:loose-trailing ,loose-trailing))
,@body))
;;;
;;; Compression functions
;;;
(defun compress-stream-1 (input output
&key
(level 6) (member-size 2251799813685248)
dictionary-size match-len-limit)
"Read the data from the INPUT octet stream, compress it, and write the result
to the OUTPUT octet stream."
(with-compressing-stream (stream output
:level level
:member-size member-size
:dictionary-size dictionary-size
:match-len-limit match-len-limit)
(let ((buffer (make-array +buffer-size+ :element-type 'u8)))
(do ((n (read-sequence buffer input) (read-sequence buffer input)))
((zerop n) t)
(write-sequence buffer stream :end n)))))
(defun compress-stream-n (input output
&key
(threads 2) (level 6) (member-size 2251799813685248)
block-size dictionary-size match-len-limit)
"Read the data from the INPUT octet stream, compress it using multiple
threads, and write the result to the OUTPUT octet stream."
(destructuring-bind (dictionary-size match-len-limit)
(lzma-options level dictionary-size match-len-limit)
(let* ((lparallel:*kernel* (lparallel:make-kernel threads))
(queue (lparallel.queue:make-queue))
(buffer-size 1048576)
(buffer (make-array buffer-size :element-type 'u8))
(block-size (or block-size (* 2 dictionary-size))))
(labels ((read-block (size pipe first-read-p)
(let ((n (read-sequence buffer input
:end (min size buffer-size))))
(cond
((zerop n)
(not first-read-p))
(t
(write-sequence buffer pipe :end n)
(read-block (- size n) pipe nil)))))
(compress-block (pipe out)
(compress-stream-1 pipe out
:level level
:member-size member-size
:dictionary-size dictionary-size
:match-len-limit match-len-limit)
(list (octet-streams:get-output-stream-octets out)
pipe
out))
(add-task (pipe out)
(let ((pipe (or pipe (octet-streams:make-octet-pipe)))
(out (or out (octet-streams:make-octet-output-stream))))
(cond
((read-block block-size pipe t)
(let ((task (lparallel:future (compress-block pipe out))))
(lparallel.queue:push-queue task queue)))
(t
(close pipe)
(close out)))))
(process-queue ()
(unless (lparallel.queue:queue-empty-p queue)
(destructuring-bind (compressed-data pipe out)
(lparallel:force (lparallel.queue:pop-queue queue))
(write-sequence compressed-data output)
(add-task pipe out)
(process-queue)))))
(unwind-protect
(lparallel:task-handler-bind ((error (lambda (e)
(error e))))
(dotimes (i threads)
(add-task nil nil))
(process-queue)
t)
(lparallel:end-kernel))))))
(defun compress-stream (input output
&key
(threads 1) (level 6) (member-size 2251799813685248)
block-size dictionary-size match-len-limit)
"Read the data from the INPUT octet stream, compress it, and write the result
to the OUTPUT octet stream."
(if (< threads 2)
(compress-stream-1 input output
:level level
:member-size member-size
:dictionary-size dictionary-size
:match-len-limit match-len-limit)
(compress-stream-n input output
:threads threads
:level level
:member-size member-size
:block-size block-size
:dictionary-size dictionary-size
:match-len-limit match-len-limit)))
(defun compress-file (input output
&key
(threads 1) (level 6) (member-size 2251799813685248)
block-size dictionary-size match-len-limit)
"Read the data from the INPUT file, compress it, and write the result to the
OUTPUT file."
(with-open-file (input-stream input :element-type 'u8)
(with-open-file (output-stream output :direction :output :element-type 'u8)
(compress-stream input-stream output-stream
:threads threads
:level level
:member-size member-size
:block-size block-size
:dictionary-size dictionary-size
:match-len-limit match-len-limit))))
(defun compress-buffer (buffer
&key
(start 0) end (threads 1) (level 6)
(member-size 2251799813685248)
block-size dictionary-size match-len-limit)
"Read the data between the START and END offsets in the BUFFER, compress it,
and return the resulting octet vector."
(let ((end (or end (length buffer))))
(octet-streams:with-octet-output-stream (output)
(octet-streams:with-octet-input-stream (input buffer start end)
(compress-stream input output
:threads threads
:level level
:member-size member-size
:block-size block-size
:dictionary-size dictionary-size
:match-len-limit match-len-limit)))))
;;;
;;; Decompression functions
;;;
(defun decompress-stream-1 (input output
&key
(ignore-trailing t) loose-trailing)
"Read the data from the INPUT octet stream, decompress it, and write the
result to the OUTPUT octet stream."
(with-decompressing-stream (stream input
:ignore-trailing ignore-trailing
:loose-trailing loose-trailing)
(let ((buffer (make-array +buffer-size+ :element-type 'u8)))
(do ((n (read-sequence buffer stream) (read-sequence buffer stream)))
((zerop n) t)
(write-sequence buffer output :end n)))))
(defun decompress-stream-n (input output
&key
(threads 2) (ignore-trailing t) loose-trailing)
"Read the data from the INPUT octet stream, decompress it using multiple
threads, and write the result to the OUTPUT octet stream."
(let* ((lparallel:*kernel* (lparallel:make-kernel threads))
(queue (lparallel.queue:make-queue))
(buffer-size 1048576)
(buffer (make-array buffer-size :element-type 'u8))
(input-pipe (octet-streams:make-octet-pipe))
(magic (map '(simple-array u8 (4)) #'char-code "LZIP"))
(jump-table (octet-streams:make-jump-table magic)))
(labels ((find-magic (pipe)
(octet-streams:octet-stream-search pipe magic jump-table))
(read-member-size (pipe start)
(logior
(octet-streams:octet-stream-ref pipe start)
(ash (octet-streams:octet-stream-ref pipe (+ start 1)) 8)
(ash (octet-streams:octet-stream-ref pipe (+ start 2)) 16)
(ash (octet-streams:octet-stream-ref pipe (+ start 3)) 24)
(ash (octet-streams:octet-stream-ref pipe (+ start 4)) 32)
(ash (octet-streams:octet-stream-ref pipe (+ start 5)) 40)
(ash (octet-streams:octet-stream-ref pipe (+ start 6)) 48)
(ash (octet-streams:octet-stream-ref pipe (+ start 7)) 56)))
(decompress-member (pipe out)
(decompress-stream-1 pipe out
:ignore-trailing ignore-trailing
:loose-trailing loose-trailing)
(list (octet-streams:get-output-stream-octets out)
pipe
out))
(move-bytes (pipe n)
(when (plusp n)
(let ((length (read-sequence buffer input-pipe
:end (min n buffer-size))))
(write-sequence buffer pipe :end length)
(move-bytes pipe (- n length)))))
(read-member (member-size pipe)
(let ((n (read-sequence buffer input)))
(write-sequence buffer input-pipe :end n))
(let ((length (octet-streams:octet-stream-length input-pipe))
(index (find-magic input-pipe)))
(cond
((and (zerop length) (zerop member-size))
nil)
((null index)
;; Continue reading the current member.
(let ((n (- length 8)))
(cond
((plusp n)
(move-bytes pipe n)
(read-member (+ member-size n) pipe))
(t
;; End of stream.
(move-bytes pipe length)
t))))
((zerop index)
;; New member.
(move-bytes pipe 4)
(read-member 4 pipe))
((and (>= index 8)
(= (read-member-size input-pipe (- index 8))
(+ member-size index)))
;; Finish reading the current member.
(move-bytes pipe index)
t)
(t
(lz-error "Bad member in archive.")))))
(add-task (pipe out)
(let ((pipe (or pipe (octet-streams:make-octet-pipe)))
(out (or out (octet-streams:make-octet-output-stream))))
(cond
((read-member 0 pipe)
(let ((task (lparallel:future (decompress-member pipe out))))
(lparallel.queue:push-queue task queue)))
(t
(close pipe)
(close out)))))
(process-queue ()
(unless (lparallel.queue:queue-empty-p queue)
(destructuring-bind (data pipe out)
(lparallel:force (lparallel.queue:pop-queue queue))
(write-sequence data output)
(add-task pipe out)
(process-queue)))))
(unwind-protect
(lparallel:task-handler-bind ((error (lambda (e)
(error e))))
(dotimes (i threads)
(add-task nil nil))
(process-queue)
t)
(lparallel:end-kernel)))))
(defun decompress-stream (input output
&key
(threads 1) (ignore-trailing t) loose-trailing)
"Read the data from the INPUT octet stream, decompress it, and write the
result to the OUTPUT octet stream."
(if (< threads 2)
(decompress-stream-1 input output
:ignore-trailing ignore-trailing
:loose-trailing loose-trailing)
(decompress-stream-n input output
:threads threads
:ignore-trailing ignore-trailing
:loose-trailing loose-trailing)))
(defun decompress-file (input output
&key
(threads 1) (ignore-trailing t) loose-trailing)
"Read the data from the INPUT file, decompress it, and write the result to the
OUTPUT file."
(with-open-file (input-stream input :element-type 'u8)
(with-open-file (output-stream output :direction :output :element-type 'u8)
(decompress-stream input-stream output-stream
:threads threads
:ignore-trailing ignore-trailing
:loose-trailing loose-trailing))))
(defun decompress-buffer (buffer
&key
(start 0) end (threads 1)
(ignore-trailing t) loose-trailing)
"Read the data between the START and END offsets in the BUFFER, decompress it,
and return the resulting octet vector."
(let ((end (or end (length buffer))))
(octet-streams:with-octet-output-stream (output)
(octet-streams:with-octet-input-stream (input buffer start end)
(decompress-stream input output
:threads threads
:ignore-trailing ignore-trailing
:loose-trailing loose-trailing)))))
| 27,297 | Common Lisp | .lisp | 591 | 32.629442 | 85 | 0.551388 | glv2/cl-lzlib | 3 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | cb11e1d374cbcd5d3309e2d071acde0a8251513a1fa259de8f8beaf550a1e140 | 18,882 | [
-1
] |
18,883 | tests.lisp | glv2_cl-lzlib/tests/tests.lisp | ;;; This file is part of cl-lzlib
;;; Copyright 2019-2022 Guillaume LE VAILLANT
;;; Distributed under the GNU GPL v3 or later.
;;; See the file LICENSE for terms of use and distribution.
(defpackage :lzlib-tests
(:use :cl :cl-octet-streams :fiveam :lzlib))
(in-package :lzlib-tests)
(defun data-file-path (filename)
(let ((path (concatenate 'string "tests/" filename)))
(asdf:system-relative-pathname "lzlib-tests" path)))
(defun load-data-file (filename)
(with-open-file (file (data-file-path filename)
:element-type '(unsigned-byte 8))
(let* ((size (file-length file))
(buffer (make-array size :element-type '(unsigned-byte 8))))
(read-sequence buffer file)
buffer)))
(defun same-files-p (path-1 path-2)
(with-open-file (file-1 path-1 :element-type '(unsigned-byte 8))
(with-open-file (file-2 path-2 :element-type '(unsigned-byte 8))
(let ((buffer-1 (make-array 16384 :element-type '(unsigned-byte 8)))
(buffer-2 (make-array 16384 :element-type '(unsigned-byte 8))))
(loop for read-1 = (read-sequence buffer-1 file-1)
for read-2 = (read-sequence buffer-2 file-2)
never (or (/= read-1 read-2)
(mismatch buffer-1 buffer-2 :end1 read-1 :end2 read-1))
until (zerop read-1))))))
(def-suite lzlib-unit-tests
:description "Unit tests for lzip (de)compression.")
(in-suite lzlib-unit-tests)
(test decompressing-stream
(with-octet-input-stream (input #(76 90 73 80 1 12 0 0
128 157 97 211 29 7 5 127
255 248 129 32 0 244 153 11
71 5 0 0 0 0 0 0
0 41 0 0 0 0 0 0
0))
(let ((stream (make-decompressing-stream input))
(tmp (make-array 2 :element-type '(unsigned-byte 8))))
(is (= 1 (read-byte stream)))
(is (= 2 (read-byte stream)))
(is (= 2 (read-sequence tmp stream)))
(is (equalp #(3 4) tmp))
(is (= 5 (read-byte stream)))
(is (eql :eof (read-byte stream nil :eof)))
(close stream))))
(test decompress-stream
(is (equalp #()
(with-octet-output-stream (output)
(with-octet-input-stream (input #(76 90 73 80 1 12 0 131
255 251 255 255 192 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 36 0 0 0
0 0 0 0))
(decompress-stream input output)))))
(is (equalp #(1 2 3 4 5)
(with-octet-output-stream (output)
(with-octet-input-stream (input #(76 90 73 80 1 12 0 0
128 157 97 211 29 7 5 127
255 248 129 32 0 244 153 11
71 5 0 0 0 0 0 0
0 41 0 0 0 0 0 0
0))
(decompress-stream input output)))))
(let ((tmp (with-octet-output-stream (output)
(with-octet-input-stream (input #(76 90 73 80 1 113 0 57
239 251 191 254 163 177 94 229
248 63 178 170 38 85 248 104
112 65 112 21 15 141 253 30
76 27 138 66 183 25 244 105
24 113 174 102 35 138 138 77
47 163 13 217 127 166 227 140
35 17 83 224 89 24 197 117
138 226 119 248 182 148 127 12
106 192 222 116 73 100 226 233
92 83 178 4 214 177 246 68
181 91 255 255 185 170 0 0
122 78 48 21 160 134 1 0
0 0 0 0 116 0 0 0
0 0 0 0))
(decompress-stream input output)))))
(is (= 100000 (length tmp)))
(is-true (every (lambda (x) (= x 115)) tmp))))
(test decompress-file
(let ((decompressed (data-file-path "test.txt"))
(compressed (data-file-path "test.txt.lz"))
(tmp "/tmp/lzlib-test.txt"))
(unwind-protect
(progn
(is-true (decompress-file compressed tmp))
(is (same-files-p decompressed tmp)))
(uiop:delete-file-if-exists tmp)))
(let ((decompressed (data-file-path "test-multimember.dat"))
(compressed (data-file-path "test-multimember.dat.lz"))
(tmp "/tmp/lzlib-multimember.dat"))
(unwind-protect
(progn
(is-true (decompress-file compressed tmp))
(is (same-files-p decompressed tmp)))
(uiop:delete-file-if-exists tmp)))
(let ((decompressed (data-file-path "test-multimember.dat"))
(compressed (data-file-path "test-multimember.dat.lz"))
(tmp "/tmp/lzlib-multimember.dat"))
(unwind-protect
(progn
(is-true (decompress-file compressed tmp :threads 2))
(is (same-files-p decompressed tmp)))
(uiop:delete-file-if-exists tmp))))
(test decompress-buffer
(let ((decompressed (load-data-file "test.txt"))
(compressed (load-data-file "test.txt.lz")))
(is (equalp decompressed (decompress-buffer compressed))))
(is (equalp #(1 2 3 4 5) (decompress-buffer #(76 90 73 80 1 12 0 0
128 157 97 211 29 7 5 127
255 248 129 32 0 244 153 11
71 5 0 0 0 0 0 0
0 41 0 0 0 0 0 0
0)))))
(test decompress-corrupt-header
;; No header
(signals lzlib-error (decompress-buffer #()))
;; Bad header
(signals lzlib-error (decompress-buffer #(1 2 3 4 5 6 7 8 9)))
;; Incomplete header
(signals lzlib-error (decompress-buffer #(76 90 73 80)))
;; Bad version number
(signals lzlib-error (decompress-buffer #(76 90 73 80 23 12 0 0
128 157 97 211 29 7 5 127
255 248 129 32 0 244 153 11
71 5 0 0 0 0 0 0
0 41 0 0 0 0 0 0
0)))
;; Bad dictionary size
(signals lzlib-error (decompress-buffer #(76 90 73 80 1 255 0 0
128 157 97 211 29 7 5 127
255 248 129 32 0 244 153 11
71 5 0 0 0 0 0 0
0 41 0 0 0 0 0 0
0))))
(test decompress-corrupt-data
;; Bad byte in LZMA stream
(signals lzlib-error (decompress-buffer #(76 90 73 80 1 12 0 0
128 157 14 211 29 7 5 127
255 248 129 32 0 244 153 11
71 5 0 0 0 0 0 0
0 41 0 0 0 0 0 0
0)))
;; Bad byte in CRC
(signals lzlib-error (decompress-buffer #(76 90 73 80 1 12 0 0
128 157 97 211 29 7 5 127
255 248 129 32 0 244 13 11
71 5 0 0 0 0 0 0
0 41 0 0 0 0 0 0
0)))
;; Bad byte in data size
(signals lzlib-error (decompress-buffer #(76 90 73 80 1 12 0 0
128 157 97 211 29 7 5 127
255 248 129 32 0 244 153 11
71 5 2 0 0 0 0 0
0 41 0 0 0 0 0 0
0)))
;; Bad byte in member size
(signals lzlib-error (decompress-buffer #(76 90 73 80 1 12 0 0
128 157 97 211 29 7 5 127
255 248 129 32 0 244 153 11
71 5 0 0 0 0 0 0
0 32 0 0 0 0 0 0
0)))
;; Incomplete stream
(signals lzlib-error (decompress-buffer #(76 90 73 80 1 12 0 0
128 157 97 211 29 7 5 127
255 248))))
(test decompress-trailing-data
;; Trailing data
(is (equalp #(1 2 3 4 5) (decompress-buffer #(76 90 73 80 1 12 0 0
128 157 97 211 29 7 5 127
255 248 129 32 0 244 153 11
71 5 0 0 0 0 0 0
0 41 0 0 0 0 0 0
0 9 8 7 6 5 4 3
2 1 0))))
(signals lzlib-error (decompress-buffer #(76 90 73 80 1 12 0 0
128 157 97 211 29 7 5 127
255 248 129 32 0 244 153 11
71 5 0 0 0 0 0 0
0 41 0 0 0 0 0 0
0 9 8 7 6 5 4 3
2 1 0)
:ignore-trailing nil))
;; Trailing bad header
(signals lzlib-error (decompress-buffer #(76 90 73 80 1 12 0 0
128 157 97 211 29 7 5 127
255 248 129 32 0 244 153 11
71 5 0 0 0 0 0 0
0 41 0 0 0 0 0 0
0 76 90 0 80 1 12 0
0 0 0 0 0 0 0)))
(is (equalp #(1 2 3 4 5) (decompress-buffer #(76 90 73 80 1 12 0 0
128 157 97 211 29 7 5 127
255 248 129 32 0 244 153 11
71 5 0 0 0 0 0 0
0 41 0 0 0 0 0 0
0 76 90 0 80 1 12 0
0 0 0 0 0 0 0)
:loose-trailing t))))
(test compressing-stream
(let ((compressed (with-octet-output-stream (output)
(let ((stream (make-compressing-stream output :level 9)))
(write-byte 1 stream)
(write-byte 2 stream)
(write-sequence #(3 4 1 2 3 4 1 2 3 4) stream)
(write-byte 5 stream)
(close stream)))))
(is (equalp #(1 2 3 4 1 2 3 4 1 2 3 4 5)
(decompress-buffer compressed)))))
(test compress-stream
(is (equalp #()
(with-octet-output-stream (output)
(with-octet-pipe (pipe)
(with-octet-input-stream (input #())
(compress-stream input pipe)
(decompress-stream pipe output))))))
(is (equalp #(1 2 3 4 5)
(with-octet-output-stream (output)
(with-octet-pipe (pipe)
(with-octet-input-stream (input #(1 2 3 4 5))
(compress-stream input pipe)
(decompress-stream pipe output))))))
(let* ((data (make-array 100000
:element-type '(unsigned-byte 8)
:initial-element 115))
(tmp (with-octet-output-stream (output)
(with-octet-pipe (pipe)
(with-octet-input-stream (input data)
(compress-stream input pipe)
(decompress-stream pipe output))))))
(is (equalp data tmp))))
(test compress-file
(let ((decompressed (data-file-path "test.txt"))
(tmp-1 "/tmp/lzlib-test.txt.lz")
(tmp-2 "/tmp/lzlib-test.txt"))
(unwind-protect
(progn
(is-true (compress-file decompressed tmp-1))
(is-true (decompress-file tmp-1 tmp-2))
(is (same-files-p decompressed tmp-2)))
(uiop:delete-file-if-exists tmp-1)
(uiop:delete-file-if-exists tmp-2)))
(let ((decompressed (data-file-path "test-multimember.dat"))
(tmp-1 "/tmp/test-multimember.dat.lz")
(tmp-2 "/tmp/test-multimember.dat"))
(unwind-protect
(progn
(is-true (compress-file decompressed tmp-1 :member-size 100000))
(is-true (decompress-file tmp-1 tmp-2))
(is (same-files-p decompressed tmp-2)))
(uiop:delete-file-if-exists tmp-1)
(uiop:delete-file-if-exists tmp-2)))
(let ((decompressed (data-file-path "test-multimember.dat"))
(tmp-1 "/tmp/test-multimember.dat.lz")
(tmp-2 "/tmp/test-multimember.dat"))
(unwind-protect
(progn
(is-true (compress-file decompressed tmp-1
:threads 2
:block-size 100000))
(is-true (decompress-file tmp-1 tmp-2))
(is (same-files-p decompressed tmp-2)))
(uiop:delete-file-if-exists tmp-1)
(uiop:delete-file-if-exists tmp-2))))
(test compress-buffer
(let* ((decompressed (load-data-file "test.txt"))
(tmp-1 (compress-buffer decompressed))
(tmp-2 (decompress-buffer tmp-1)))
(is (< (length tmp-1) (length decompressed)))
(is-false (mismatch decompressed tmp-2)))
(let* ((decompressed (make-array 123456
:element-type '(unsigned-byte 8)
:initial-element 55))
(tmp-1 (compress-buffer decompressed))
(tmp-2 (decompress-buffer tmp-1)))
(is (< (length tmp-1) (length decompressed)))
(is-false (mismatch decompressed tmp-2))))
(test compress-bad-options
;; Missing compression options
(signals lzlib-error (compress-buffer #(7 6 6 7 6 6)
:level nil))
;; Invalid compression level
(signals lzlib-error (compress-buffer #(7 6 6 7 6 6)
:level 15))
;; Dictionary size too small
(signals lzlib-error (compress-buffer #(7 6 6 7 6 6)
:dictionary-size 3
:match-len-limit 10))
;; Dictionary size too big
(signals lzlib-error (compress-buffer #(7 6 6 7 6 6)
:dictionary-size 1073741824
:match-len-limit 10))
;; Match length limit too small
(signals lzlib-error (compress-buffer #(7 6 6 7 6 6)
:dictionary-size 2097152
:match-len-limit 1))
;; Match length limit too big
(signals lzlib-error (compress-buffer #(7 6 6 7 6 6)
:dictionary-size 2097152
:match-len-limit 1000))
;; Missing match length limit
(signals lzlib-error (compress-buffer #(7 6 6 7 6 6)
:dictionary-size 2097152))
;; Missing dictionary size
(signals lzlib-error (compress-buffer #(7 6 6 7 6 6)
:match-len-limit 10))
;; Member size to small
(signals lzlib-error (compress-buffer #(7 6 6 7 6 6)
:member-size 10))
;; Member size to big
(signals lzlib-error (compress-buffer #(7 6 6 7 6 6)
:member-size 18446744073709551616)))
| 16,472 | Common Lisp | .lisp | 318 | 31.003145 | 79 | 0.440305 | glv2/cl-lzlib | 3 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 80af235e1bfc187a21ed5086dd9ab3bfa6141730c794bd2e72d50be275655c53 | 18,883 | [
-1
] |
18,884 | lzlib.asd | glv2_cl-lzlib/lzlib.asd | ;;; This file is part of cl-lzlib
;;; Copyright 2019-2022 Guillaume LE VAILLANT
;;; Distributed under the GNU GPL v3 or later.
;;; See the file LICENSE for terms of use and distribution.
(defsystem "lzlib"
:name "lzlib"
:description "lzip (LZMA) (de)compression using bindings to lzlib"
:version "2.0"
:author "Guillaume LE VAILLANT"
:license "GPL-3"
:depends-on ("cffi" "cl-octet-streams" "lparallel" "trivial-gray-streams")
:in-order-to ((test-op (test-op "lzlib-tests")))
:components ((:module "src"
:serial t
:components ((:file "package")
(:file "lzlib")
(:file "lzip")))))
| 686 | Common Lisp | .asd | 17 | 33.058824 | 76 | 0.609281 | glv2/cl-lzlib | 3 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | c89da760ae8940f2286b870d258f04efca5788402c277cb02ebd9259f7ef74d1 | 18,884 | [
-1
] |
18,885 | lzlib-tests.asd | glv2_cl-lzlib/lzlib-tests.asd | ;;; This file is part of cl-lzlib
;;; Copyright 2019-2022 Guillaume LE VAILLANT
;;; Distributed under the GNU GPL v3 or later.
;;; See the file LICENSE for terms of use and distribution.
(defsystem "lzlib-tests"
:name "lzlib-tests"
:description "Tests for lzlib"
:version "2.0"
:author "Guillaume LE VAILLANT"
:license "GPL-3"
:depends-on ("cl-octet-streams" "fiveam" "lzlib" "uiop")
:in-order-to ((test-op (load-op "lzlib-tests")))
:perform (test-op (op s)
(let ((tests (uiop:find-symbol* 'lzlib-unit-tests :lzlib-tests)))
(uiop:symbol-call :fiveam 'run! tests)))
:components ((:module "tests"
:serial t
:components ((:static-file "test.txt")
(:static-file "test.txt.lz")
(:static-file "test-multimember.dat")
(:static-file "test-multimember.dat.lz")
(:file "tests")))))
| 967 | Common Lisp | .asd | 22 | 34.090909 | 78 | 0.572034 | glv2/cl-lzlib | 3 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 414484171bc082087bf2bddfc7e1c3881bf821eac31d0e09189bd2b80beb494d | 18,885 | [
-1
] |
18,892 | test-multimember.dat | glv2_cl-lzlib/tests/test-multimember.dat | xVp41AKDufT3BUSYmp320XVb+QnvYktMoQgVtHz+LmjEp3hT8RF4NXz8P2kh79BJtFWQ+GuSUdFb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| 354,128 | Common Lisp | .l | 4,600 | 75.984348 | 76 | 0.969133 | glv2/cl-lzlib | 3 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | d8be7d8432109bed90a4759536cc9f7401bc5b5cf4fb83df87830b08b28ac603 | 18,892 | [
-1
] |
18,908 | lispswarm20160509_quit.lisp | KedalionDaimon_larvarum-computationis-examen-iii/lispswarm20160509_quit.lisp | ; This is the "fast" version working with "only" 1000 atoms.
; MY ISSUE IS THE DOUBLE-CREATION OF UNKNOWN ATOMS AT THE RE-EVAL STAGE:
; (re-eval '(aa . bb) '((x . y) (b . c) (a . c) (b . d) (a . d) (l . r) (s . t) (l . m) (n . o) (o . p) (p . q) (q . r) (r . s)))
; --> (0 (AA . BB) (AA . BB) (X . Y) (B . C) (A . C) (B . D) (A . D) (L . R) (S . T) (L . M) (N . O) (O . P) (P . Q))
; whereas Scheme does:
; --> (1 (aa . bb) (x . y) (b . c) (a . c) (b . d) (a . d) (l . r) (s . t) (l . m) (n . o) (o . p) (p . q) (q . r))
; USING INCOGNITUM, NOW CORRECTED TO:
; --> (1 (AA . BB) (X . Y) (B . C) (A . C) (B . D) (A . D) (L . R) (S . T) (L . M) (N . O) (O . P) (P . Q) (Q . R))
; I AM USING A LOT OF CONSP INSTEAD OF MY "PAIR".
; USE THIS THING IN CLISP, _SKIP_ THE RECURSIVELEARN!
; MOST LIKELY - THE PROBLEM IS THAT I HAVE "NIL" FOR NOT FOUND ARGUMENTS! IT SHOULD NOT BE NIL! IT USED TO BE '()!
; I ACHIEVED PLANNING WITH ANALOGIES!
; The version "B" contains a more far-reaching snowflake mechanism
; (see below).
; LarCom E
; This system employs directional logical triangulation.
; The function proto-eval-triangle re-considers all possible cases of
; a directional conclusion. The predecessor system, victri, was
; operating exclusively on vic atoms. The system expresses the
; influence of a clause by putting it at the front of the list
; of all atoms (i.e. left-most) if it is influential. The system is
; not value-based but purely position-based.
; Herein, vic-connections are defined as dotted pairs - (a . b) - while
; ana-connections are expressed by means of lists - (a b).
; The precise manner of operation can be influenced below under
; USER-SET PARAMETERS.
; The present system has two enhancements to its reasoning mechanism.
; Firstly, it has a "re-slider" - a mechanism for re-considering input
; several times. - This is the "sledge". To disable the sledge, the
; iterations of re-sliding can be set to 0. Secondly, it considers the
; "considerations of the considerations" of a given vic-connection of
; input - and not only the vic-connection's sole considerations.
; (That mechanism may have become "too fanciful", but is still kept
; in existence.) It is implemented in the re-eval function below. If
; it is no longer desired, the "original" re-eval function may be
; re-implemented. - As reasoning, however, grows exponentially, it is
; being limited by the setting of "globallimit" - this global variable
; limits how many conclusions one single couple of atoms can enter
; into - if set to a negative value, it is effectively disabled.
; It could be re-considered whether planning really cannot incorporate
; at all ana-atoms, or whether simply one of the two alternatives has
; to be selected. The present choice - plans consist only out of vic-
; atoms - is more consistent, as only "elementary atoms" are in a
; vicinity, while the inclusion of ana-atoms would mean to include in
; planning the decision between alternatives. However, as one
; alternative _should_ exist, this would be imaginable.
; PREPARATIONS FOR THE USER-SET PARAMETERS:
; A text shall be given to the system for "pre-learning" prior to user
; interaction, so it already has some "fundamental ideas" and needs no
; teaching like a baby.
; For this purpose, the text shall be subdivided into partially
; overlapping sections.
; Take the first atoms of a list:
(defun proto-frontpart (howfar inlist resultlist)
(if (or (zerop howfar) (null inlist)) (reverse resultlist)
(proto-frontpart (- howfar 1) (cdr inlist) (cons (car inlist) resultlist))))
(defun frontpart (howfar inlist) (proto-frontpart howfar inlist '()))
; sample call:
; (frontpart 3 '(a b c d e f)) --> (a b c)
; (frontpart 10 '(a b c d e f)) --> (a b c d e f)
; skip the first atoms of a list:
(defun skip (howmany inlist)
(if (or (zerop howmany) (null inlist)) inlist
(skip (- howmany 1) (cdr inlist))))
; (skip 2 '(a b c d e)) --> (c d e)
; (skip 0 '(a b c d e)) --> (a b c d e)
; The chainload function cuts a long input list of text to be learned
; into partially overlapping smaller portions.
(defun proto-chainload (xskip ylength inlist resultlist)
(if (null inlist) (reverse resultlist)
(proto-chainload xskip ylength (skip xskip inlist) (cons (frontpart ylength inlist) resultlist))))
(defun chainload (xskip ylength inlist) (proto-chainload xskip ylength inlist '()))
; ==== USER-SET PARAMETERS ====
; "knowledgesize" determines the capacity of the system to contain atom
; connections - a higher count makes the system more intelligent.
(defvar knowledgesize 1000)
; "inmemory" determines on what size of input history the system shall
; reason - in particular, it should be longer than the longest expected
; input to the system. - If the input is longer, its front part is cut
; off and only the back part is used for reasoning.
(defvar inmemory 30)
; "re-slide-count" determines how often the system re-considers given
; input - set it to 0 in order to consider input only once.
(defvar re-slide-count 1)
; How many conclusions can be made with one pair that is in the focus
; of reasoning - set it to a negative number to enable unlimited
; reasoning, but beware that this quickly overwrites all other known
; atoms. It forces termination on countdown to "zero?".
(defvar globallimit 3)
; "rootlist" represents the initial list of "pre-set" learned material
; - the more, the better. This list can be also loaded from a prepared
; file - this is only a very short example. That list should be huge.
; This is used to implant previous knowledge into the system ere "using" it.
; (defvar rootlist '(a b c d e f g h i j))
; "initlist" defines a list of "chunks" of the rootlist, each "chunk"
; being separately learned by the system. This setting means:
; chunks of length three, each chunk progresses by 1 atom from the
; previous chunk (3 3 would have meant no repetitions in the chunks).
; The chunks can be of larger size - the larger, the better -
; however, large chunks use a lot of knowledge space as they are
; always fully hierarchised. "knowledgesize" must have been chosen
; appropriately large.
; (defvar initlist (chainload 1 3 rootlist))
(defvar snow-depth 1) ; how many re-considerations should be possible.
; use a snow-depth of 1 to have only 1 re-call (as before). "More
; fanciful" is a higher snow-depth.
; This defines how many words of past input may be maximum remembered.
; If all of the input words can be found inside the history, then this
; "insect" is suitable for handling said input.
(defvar historylength 30)
; ==== END OF USER-SET PARAMETERS ====
; That function is a cshift/eoshift-equivalent and has not been used -
; but should I ever start using vectors here, this may change:
; (defun proto-find-rotate (element position listofallatoms resultlist)
; (if (null? listofallatoms) (cons position (cons element (reverse (cdr resultlist))))
; (if (equal? element (car listofallatoms))
; (cons position (append (cons element (reverse resultlist)) (cdr listofallatoms)))
; (proto-find-rotate element (+ 1 position) (cdr listofallatoms) (cons (car listofallatoms) resultlist)))))
; sample calls:
; (proto-find-rotate 'a 0 '(x y z a b c) '()) --> (3 a x y z b c)
; (proto-find-rotate 'q 0 '(x y z a b c) '()) --> (6 q x y z a b)
; (defun find-rotate (element listofallatoms) (proto-find-rotate element 0 listofallatoms '()))
; In order to look at possible connections within the input, it should
; be split into possible pairs. This is done by the following function
; based on this observation:
; (map cons '(a b c) '(x y z)) --> ((a . x) (b . y) (c . z))
(defun mapcons (fulllist) (mapcar #'cons (reverse (cdr (reverse fulllist))) (cdr fulllist)))
; a variation of it could be, if you wish to tolerate the existence of
; (a)-style "connection", would be this:
; (defun mapcons (fulllist) (map cons fulllist (cdr fulllist)))
; that would be interesting for "no-response-plans", i.e. where "A" is
; found and the response is "()".
; sample call of current version:
; (mapcons '(a b c d)) --> ((a . b) (b . c) (c . d))
; If a vic-connection of the type (a . a), i.e. between the same atom,
; is observed, it cannot participate in further reasoning. - The only
; question is, whether it can be confirmed as already observed or not.
; A question is whether I should loot at analogies of the type (a a).
; Currently, they are not considered as I have not foreseen a way for
; their creation - that an atom is analogous to itself really needs no
; explicit mentioning.
(defun extractpair (sameatoms listofallatoms atomschecked)
(if (null listofallatoms)
(cons NIL (cons sameatoms (reverse atomschecked)))
(if (equal sameatoms (car listofallatoms))
(cons T (cons sameatoms (append (reverse atomschecked) (cdr listofallatoms) '((nihil . nihil)))))
(extractpair sameatoms (cdr listofallatoms) (cons (car listofallatoms) atomschecked)))))
; sample calls:
; (extractpair '(a . a) '((b . c) (c . d) (d . e) (e . f)) '()) --> (NIL (a . a) (b . c) (c . d) (d . e) (e . f))
; (extractpair '(a . a) '((b . c) (c . d) (d . e) (a . a)) '()) --> (T (a . a) (b . c) (c . d) (d . e) (NIHIL . NIHIL))
; The below triangulation function tests different conditions that
; may have been triggered by triangulation. They are one of:
; - reaching a confirmative conclusion - #t;
; - reaching a contradicting conclusion - #f; - I may consider to
; merely deliver "(#f)" in such a case, rather than the entire main
; knowledge list, if I do not re-use that list with the contradiction;
; - an inconclusive state - '() - when nothing can be said;
; none of the above, which warrants a re-try as long as there are
; untested atoms in the list of all atoms.
; In the below triangulation function, meeting the "opposite" of a
; connection means, generally, a contradiction to it. That is true
; in particular for the first and the third pairs. The first pair must
; either be confirmed by direct observation or conclude its triangle
; before its "opposite" can be seen. A=B (being the same as (B=A),
; A->B and B->A (these latter are considered distinct) are each a
; possible "opposite" of the other two. Only the second pair is
; so far more tolerant to being countered - it is only "dropped" but
; does not stop further reasoning, and that is only the case if the
; proposed third atom has not yet been seen.
; CONSIDER REPLACING THE "IF's" WITH ONE HUGE "COND".
; Avoiding "double" analogies - (b a) and (a b) - should already be the
; case as the "recognition" of analogies also checks for their reverse.
; A few effects used herein:
; (equal? (car '(a . b)) (cdar '((x . a)))) --> #t
; A->B X->A : X->B : (cons (caar '((x . a))) (cdr '(a . b)))
; (equal? (cdr '(a . b)) (caar '((b . x)))) --> #t
; A->B B->X : A->X : (cons (car '(a . b)) (cdar '((b . x))))
; (cons (cdr '(x . y)) (car '(x . y))) --> (y . x)
; A little auxiliary function to distinguish a "pair" and a "list" of
; two elements - the one is a vic-connection, the other is an ana-
; connection, and they are treated differently:
(defun ecdr (x) (if (or (symbolp x) (numberp x) NIL) NIL (cdr x)))
(defun ecar (x) (if (or (symbolp x) (numberp x) NIL) NIL (car x)))
(defun ecaar (x) (if (or (symbolp x) (numberp x) NIL) NIL (ecar (ecar x))))
(defun ecadr (x) (if (or (symbolp x) (numberp x) NIL) NIL (ecar (ecdr x))))
(defun ecdar (x) (if (or (symbolp x) (numberp x) NIL) NIL (ecdr (ecar x))))
(defun ecddr (x) (if (or (symbolp x) (numberp x) NIL) NIL (ecdr (ecdr x))))
(defun ecaaar (x) (if (or (symbolp x) (numberp x) NIL) NIL (ecar (ecaar x))))
(defun ecaadr (x) (if (or (symbolp x) (numberp x) NIL) NIL (ecar (ecadr x))))
(defun ecadar (x) (if (or (symbolp x) (numberp x) NIL) NIL (ecar (ecdar x))))
(defun ecaddr (x) (if (or (symbolp x) (numberp x) NIL) NIL (ecar (ecddr x))))
(defun ecdaar (x) (if (or (symbolp x) (numberp x) NIL) NIL (ecdr (ecaar x))))
(defun ecdadr (x) (if (or (symbolp x) (numberp x) NIL) NIL (ecdr (ecadr x))))
(defun ecddar (x) (if (or (symbolp x) (numberp x) NIL) NIL (ecdr (ecdar x))))
(defun ecdddr (x) (if (or (symbolp x) (numberp x) NIL) NIL (ecdr (ecddr x))))
; I got fed up and pair got a recursive definition:
(defun proto-pair (x)
(if (null x) NIL
(if (atom x) T
(proto-pair (cdr x)))))
(defun pair (x)
(if (atom x) NIL
(proto-pair x)))
; sample calls:
; (consp '(a . b)) --> T
; (consp '(a b)) --> T
; however:
; (pair '(a . b)) --> T
; (pair '(a b)) --> NIL
; I also created a more robust list test:
(defun listq (x) (if (and (listp x) (not (pair x))) T NIL))
; sample calls:
; (listp '(a . b)) --> T
; (listp '(a b)) --> T
; (listq '(a . b)) --> NIL
; (listq '(a b)) --> T
(defun proto-eval-triangle (firstpair secondpair thirdpair firstpairseen secondpairseen thirdpairseen inconclusives listofallatoms atomschecked)
; You may uncomment (progn ... ) in order to trace reasoning.
(progn ; (terpri) (print "firstpair: ") (print firstpair) (print " secondpair: ") (print secondpair) (print " thirdpair: ") (print thirdpair)
; (print " firstpairseen: ") (print firstpairseen) (print " secondpairseen: ") (print secondpairseen)
; (print " thirdpairseen: ") (print thirdpairseen) (print " inconclusives: ") (print inconclusives)
; (print " list of all atoms: ") (print listofallatoms)
; (print " atoms checked: ") (print atomschecked)
(cond
; POSITIVE:
; all three sides seen, triangulation possible:
((if (and (equal T firstpairseen) (equal T secondpairseen) (equal T thirdpairseen)) T NIL)
(progn ; (terpri) (print "CLAUSE 1 ") (print " FIRST: ") (print firstpair) (print " SECOND: ") (print secondpair) (print " THIRD: ") (print thirdpair) (terpri)
(cons T (append (cons firstpair (cons secondpair (cons thirdpair (reverse atomschecked)))) listofallatoms '((nihil . nihil))))))
; INCONCLUSIVE:
; nothing whatsoever has been seen - thirdpairseen is impossible if secondpairseen is NIL:
((if (and (null listofallatoms) (equal NIL firstpairseen) (equal NIL secondpairseen)) T NIL)
(progn ; (terpri) (print "CLAUSE 2 ") (print " FIRST: ") (print firstpair) (print " SECOND: ") (print secondpair) (print " THIRD: ") (print thirdpair) (terpri)
(cons 'INCOGNITUM (cons firstpair (reverse atomschecked))))) ; ======= THAT USED TO BE '()
; RECOGNISED:
; only the first pair has been seen:
((if (and (null listofallatoms) (equal T firstpairseen) (equal NIL secondpairseen) (equal NIL thirdpairseen)) T NIL)
(progn ; (terpri) (print "CLAUSE 3 ") (print " FIRST: ") (print firstpair) (print " SECOND: ") (print secondpair) (print " THIRD: ") (print thirdpair) (terpri)
(cons T (cons firstpair (append (reverse atomschecked) '((nihil . nihil)))))))
; CONCLUDED:
; the first pair has been seen and the second pair has been seen - the third pair is the "conclusion":
((if (and (null listofallatoms) (equal T firstpairseen) (equal T secondpairseen) (equal NIL thirdpairseen)) T NIL)
(progn ; (terpri) (print "CLAUSE 4 ") (print " FIRST: ") (print firstpair) (print " SECOND: ") (print secondpair) (print " THIRD: ") (print thirdpair) (terpri)
(cons T (cons firstpair (cons secondpair (cons thirdpair (reverse atomschecked)))))))
; CONCLUDED:
; the first pair has not been seen, but everything else has been seen - the first pair is the "conclusion":
((if (and (null listofallatoms) (equal NIL firstpairseen) (equal T secondpairseen) (equal T thirdpairseen)) T NIL)
(progn ; (terpri) (print "CLAUSE 5 ") (print " FIRST: ") (print firstpair) (print " SECOND: ") (print secondpair) (print " THIRD: ") (print thirdpair) (terpri)
(cons T (cons firstpair (cons secondpair (cons thirdpair (reverse atomschecked)))))))
; same as above one
; INCONCLUSIVE:
; the first pair has not been seen, but is a hypothesis - but the third pair cannot yet be concluded;
; still, the first and the second pair can be put on the front part:
((if (and (null listofallatoms) (equal NIL firstpairseen) (equal T secondpairseen) (equal NIL thirdpairseen)) T NIL)
(progn ; (terpri) (print "CLAUSE 6 ") (print " FIRST: ") (print firstpair) (print " SECOND: ") (print secondpair) (print " THIRD: ") (print thirdpair) (terpri)
(cons 'INCONGITUM (cons firstpair (cons secondpair (reverse atomschecked)))))) ; ======= THAT USED TO BE '()
; NEGATIVE - THIRD PAIR CONTRADICTED, FIRST PAIR SEEN (pair): --- THIS IS EXPRESSED A BIT UNUSUALLY COMPARED TO BELOW
((if (and (equal T firstpairseen) (equal T secondpairseen) (equal NIL thirdpairseen) (pair thirdpair)
(or (and (listq (car listofallatoms))
(or (equal (car listofallatoms) (list (car thirdpair) (cdr thirdpair)))
(equal (car listofallatoms) (list (cdr thirdpair) (car thirdpair)))))
(and (pair (car listofallatoms))
(equal (car listofallatoms) (cons (cdr thirdpair) (car thirdpair)))))) T NIL)
(progn ; (terpri) (print "CLAUSE 7 ") (print " FIRST: ") (print firstpair) (print " SECOND: ") (print secondpair) (print " THIRD: ") (print thirdpair) (print " CAR_L: ") (print (car listofallatoms)) (terpri)
(cons NIL (append (reverse atomschecked) listofallatoms (list thirdpair secondpair firstpair)))))
; NEGATIVE - THIRD PAIR CONTRADICTED, FIRST PAIR SEEN (list):
((if (and (equal T firstpairseen) (equal T secondpairseen) (equal NIL thirdpairseen) (listq thirdpair)
(pair (car listofallatoms))
(or (equal (car listofallatoms) (cons (car thirdpair) (ecadr thirdpair)))
(equal (car listofallatoms) (cons (ecadr thirdpair) (car thirdpair))))) T NIL)
(progn ; (terpri) (print "CLAUSE 8 ") (print " FIRST: ") (print firstpair) (print " SECOND: ") (print secondpair) (print " THIRD: ") (print thirdpair) (print " CAR_L: ") (print (car listofallatoms)) (terpri)
(cons NIL (append (reverse atomschecked) listofallatoms (list thirdpair secondpair firstpair)))))
; NEGATIVE - THIRD PAIR CONTRADICTED, FIRST PAIR NOT SEEN (pair): --- THIS IS EXPRESSED A BIT UNUSUALLY COMPARED TO BELOW
((if (and (equal NIL firstpairseen) (equal T secondpairseen) (equal NIL thirdpairseen) (pair thirdpair)
(or (and (listq (car listofallatoms))
(or (equal (car listofallatoms) (list (car thirdpair) (cdr thirdpair)))
(equal (car listofallatoms) (list (cdr thirdpair) (car thirdpair)))))
(and (pair (car listofallatoms))
(equal (car listofallatoms) (cons (cdr thirdpair) (car thirdpair)))))) T NIL)
(progn ; (terpri) (print "CLAUSE 9 ") (print " FIRST: ") (print firstpair) (print " SECOND: ") (print secondpair) (print " THIRD: ") (print thirdpair) (print " CAR_L: ") (print (car listofallatoms)) (terpri)
(cons NIL (append (reverse atomschecked) listofallatoms (list thirdpair secondpair)))))
; NEGATIVE - THIRD PAIR CONTRADICTED, FIRST PAIR NOT SEEN (list):
((if (and (equal NIL firstpairseen) (equal T secondpairseen) (equal NIL thirdpairseen) (listq thirdpair)
(pair (car listofallatoms))
(or (equal (car listofallatoms) (cons (car thirdpair) (ecadr thirdpair)))
(equal (car listofallatoms) (cons (ecadr thirdpair) (car thirdpair))))) T NIL)
(progn ; (terpri) (print "CLAUSE 10 ") (print " FIRST: ") (print firstpair) (print " SECOND: ") (print secondpair) (print " THIRD: ") (print thirdpair) (print " CAR_L: ") (print (car listofallatoms)) (terpri)
(cons NIL (append (reverse atomschecked) listofallatoms (list thirdpair secondpair)))))
; NEGATIVE - FIRST PAIR CONTRADICTED BEFORE IT WAS SEEN, SECOND ATOM NOT SEEN, EITHER (pair):
((if (and (equal NIL firstpairseen) (equal NIL secondpairseen) (pair firstpair)
(or (and (pair (car listofallatoms)) (equal (car listofallatoms) (cons (cdr firstpair) (car firstpair))))
(and (listq (car listofallatoms))
(or (equal (car listofallatoms) (list (car firstpair) (cdr firstpair)))
(equal (car listofallatoms) (list (cdr firstpair) (car firstpair))))))) T NIL)
(progn ; (terpri) (print "CLAUSE 11 ") (print " FIRST: ") (print firstpair) (print " SECOND: ") (print secondpair) (print " THIRD: ") (print thirdpair) (print " CAR_L: ") (print (car listofallatoms)) (terpri)
(cons NIL (append (reverse atomschecked) listofallatoms (list firstpair)))))
; NEGATIVE - FIRST PAIR CONTRADICTED BEFORE IT WAS SEEN, SECOND ATOM NOT SEEN, EITHER (list):
((if (and (equal NIL firstpairseen) (equal NIL secondpairseen) (listq firstpair)
(pair (car listofallatoms))
(or (equal (car listofallatoms) (cons (car firstpair) (ecadr firstpair)))
(equal (car listofallatoms) (cons (ecadr firstpair) (car firstpair))))) T NIL)
(progn ; (terpri) (print "CLAUSE 12 ") (print " FIRST: ") (print firstpair) (print " SECOND: ") (print secondpair) (print " THIRD: ") (print thirdpair) (print " CAR_L: ") (print (car listofallatoms)) (terpri)
(cons NIL (append (reverse atomschecked) listofallatoms (list firstpair)))))
; NEGATIVE - FIRST PAIR CONTRADICTED BEFORE IT WAS SEEN, SECOND ATOM SEEN, THIRD ATOM NOT SEEN (pair):
((if (and (equal NIL firstpairseen) (equal T secondpairseen) (equal NIL thirdpairseen) (pair firstpair)
(or (and (pair (car listofallatoms)) (equal (car listofallatoms) (cons (cdr firstpair) (car firstpair))))
(and (listq (car listofallatoms))
(or (equal (car listofallatoms) (list (car firstpair) (cdr firstpair)))
(equal (car listofallatoms) (list (cdr firstpair) (car firstpair))))))) T NIL)
(progn ; (terpri) (print "CLAUSE 13 ") (print " FIRST: ") (print firstpair) (print " SECOND: ") (print secondpair) (print " THIRD: ") (print thirdpair) (print " CAR_L: ") (print (car listofallatoms)) (terpri)
(cons NIL (append (reverse atomschecked) listofallatoms (list secondpair firstpair)))))
; NEGATIVE - FIRST PAIR CONTRADICTED BEFORE IT WAS SEEN, SECOND ATOM SEEN, THIRD ATOM NOT SEEN (list):
((if (and (equal NIL firstpairseen) (equal T secondpairseen) (equal NIL thirdpairseen) (listq firstpair)
(pair (car listofallatoms))
(or (equal (car listofallatoms) (cons (car firstpair) (ecadr firstpair)))
(equal (car listofallatoms) (cons (ecadr firstpair) (car firstpair))))) T NIL)
(progn ; (terpri) (print "CLAUSE 14 ") (print " FIRST: ") (print firstpair) (print " SECOND: ") (print secondpair) (print " THIRD: ") (print thirdpair) (print " CAR_L: ") (print (car listofallatoms)) (terpri)
(cons NIL (append (reverse atomschecked) listofallatoms (list secondpair firstpair)))))
; NEGATIVE - FIRST PAIR CONTRADICTED BEFORE IT WAS SEEN, SECOND ATOM SEEN, THIRD ATOM SEEN:
((if (and (equal NIL firstpairseen) (equal T secondpairseen) (equal T thirdpairseen) (pair firstpair)
(or (and (pair (car listofallatoms)) (equal (car listofallatoms) (cons (cdr firstpair) (car firstpair))))
(and (listq (car listofallatoms))
(or (equal (car listofallatoms) (list (car firstpair) (cdr firstpair)))
(equal (car listofallatoms) (list (cdr firstpair) (car firstpair))))))) T NIL)
(progn ; (terpri) (print "CLAUSE 15 ") (print " FIRST: ") (print firstpair) (print " SECOND: ") (print secondpair) (print " THIRD: ") (print thirdpair) (print " CAR_L: ") (print (car listofallatoms)) (terpri)
(cons NIL (append (reverse atomschecked) listofallatoms (list thirdpair secondpair firstpair)))))
; NEGATIVE - FIRST PAIR CONTRADICTED BEFORE IT WAS SEEN, SECOND ATOM SEEN, THIRD ATOM SEEN:
((if (and (equal NIL firstpairseen) (equal T secondpairseen) (equal T thirdpairseen) (listq firstpair)
(pair (car listofallatoms))
(or (equal (car listofallatoms) (cons (car firstpair) (ecadr firstpair)))
(equal (car listofallatoms) (cons (ecadr firstpair) (car firstpair))))) T NIL)
(progn ; (terpri) (print "CLAUSE 16 ") (print " FIRST: ") (print firstpair) (print " SECOND: ") (print secondpair) (print " THIRD: ") (print thirdpair) (print " CAR_L: ") (print (car listofallatoms)) (terpri)
(cons NIL (append (reverse atomschecked) listofallatoms (list thirdpair secondpair firstpair)))))
; RECALL - THIRD PAIR SEEN (pair):
; whether the first pair is seen or not is determined in the re-call, i.e. whether all three sides were seen.
((if (and (equal T secondpairseen) (equal NIL thirdpairseen) (pair thirdpair)
(pair (car listofallatoms)) (equal (car listofallatoms) thirdpair)) T NIL) ; then re-call with thirdpairseen set to "true"
(progn ; (terpri) (print "CLAUSE 17 ") (print " FIRST: ") (print firstpair) (print " SECOND: ") (print secondpair) (print " THIRD: ") (print thirdpair) (print " CAR_L: ") (print (car listofallatoms)) (terpri)
(proto-eval-triangle firstpair secondpair thirdpair firstpairseen secondpairseen T inconclusives (cdr listofallatoms) atomschecked)))
; RECALL - THIRD PAIR SEEN (list):
; whether the first pair is seen or not is determined in the re-call, i.e. whether all three sides were seen.
((if (and (equal T secondpairseen) (equal NIL thirdpairseen) (listq thirdpair)
(listq (car listofallatoms))
(or (equal (car listofallatoms) thirdpair)
(equal (car listofallatoms) (reverse thirdpair)))) T NIL) ; then re-call with thirdpairseen set to "true"
(progn ; (terpri) (print "CLAUSE 18 ") (print " FIRST: ") (print firstpair) (print " SECOND: ") (print secondpair) (print " THIRD: ") (print thirdpair) (print " CAR_L: ") (print (car listofallatoms)) (terpri)
(proto-eval-triangle firstpair secondpair thirdpair firstpairseen secondpairseen T inconclusives (cdr listofallatoms) atomschecked)))
; RECALL - FIRST PAIR SEEN (pair):
((if (and (equal NIL firstpairseen) (pair firstpair)
(pair (car listofallatoms)) (equal (car listofallatoms) firstpair)) T NIL) ; then re-call with firstpairseen set to "true"
(progn ; (terpri) (print "CLAUSE 19 ") (print " FIRST: ") (print firstpair) (print " SECOND: ") (print secondpair) (print " THIRD: ") (print thirdpair) (print " CAR_L: ") (print (car listofallatoms)) (terpri)
(proto-eval-triangle firstpair secondpair thirdpair T secondpairseen thirdpairseen inconclusives (cdr listofallatoms) atomschecked)))
; RECALL - FIRST PAIR SEEN (list):
((if (and (equal NIL firstpairseen) (listq firstpair)
(listq (car listofallatoms))
(or (equal (car listofallatoms) firstpair)
(equal (car listofallatoms) (reverse firstpair)))) T NIL) ; then re-call with firstpairseen set to "true"
(progn ; (terpri) (print "CLAUSE 20 ") (print " FIRST: ") (print firstpair) (print " SECOND: ") (print secondpair) (print " THIRD: ") (print thirdpair) (print " CAR_L: ") (print (car listofallatoms)) (terpri)
(proto-eval-triangle firstpair secondpair thirdpair T secondpairseen thirdpairseen inconclusives (cdr listofallatoms) atomschecked)))
; RECALL - SECOND PAIR SEEN (pair and pair, first possibility vic-vic-vic):
((if (and (equal NIL secondpairseen) (pair firstpair) (pair (car listofallatoms))
(equal (car firstpair) (ecdar listofallatoms))
(not (equal (cdr firstpair) (ecaar listofallatoms)))
(not (equal (car firstpair) (cdr firstpair)))
(not (equal (ecaar listofallatoms) (ecdar listofallatoms)))) T NIL)
(progn ; (terpri) (print "CLAUSE 21 ") (print " FIRST: ") (print firstpair) (print " SECOND: ") (print secondpair) (print " THIRD: ") (print thirdpair) (print " CAR_L: ") (print (car listofallatoms)) (terpri)
(proto-eval-triangle firstpair (car listofallatoms) (cons (ecaar listofallatoms) (cdr firstpair))
firstpairseen T thirdpairseen inconclusives (cdr listofallatoms) atomschecked)))
; RECALL - SECOND PAIR SEEN (pair and pair, second possibility vic-vic-vic):
((if (and (equal NIL secondpairseen) (pair firstpair) (pair (car listofallatoms))
(equal (cdr firstpair) (ecaar listofallatoms))
(not (equal (car firstpair) (ecdar listofallatoms)))
(not (equal (car firstpair) (cdr firstpair)))
(not (equal (ecaar listofallatoms) (ecdar listofallatoms)))) T NIL)
(progn ; (terpri) (print "CLAUSE 22 ") (print " FIRST: ") (print firstpair) (print " SECOND: ") (print secondpair) (print " THIRD: ") (print thirdpair) (print " CAR_L: ") (print (car listofallatoms)) (terpri)
(proto-eval-triangle firstpair (car listofallatoms) (cons (car firstpair) (ecdar listofallatoms))
firstpairseen T thirdpairseen inconclusives (cdr listofallatoms) atomschecked)))
; RECALL - SECOND PAIR SEEN (pair and pair, third possibility vic-vic-ana):
((if (and (equal NIL secondpairseen) (pair firstpair) (pair (car listofallatoms))
(equal (car firstpair) (ecaar listofallatoms))
(not (equal (cdr firstpair) (ecdar listofallatoms)))
(not (equal (car firstpair) (cdr firstpair)))
(not (equal (ecaar listofallatoms) (ecdar listofallatoms)))) T NIL)
(progn ; (terpri) (print "CLAUSE 23 ") (print " FIRST: ") (print firstpair) (print " SECOND: ") (print secondpair) (print " THIRD: ") (print thirdpair) (print " CAR_L: ") (print (car listofallatoms)) (terpri)
(proto-eval-triangle firstpair (car listofallatoms) (list (cdr firstpair) (ecdar listofallatoms))
firstpairseen T thirdpairseen inconclusives (cdr listofallatoms) atomschecked)))
; RECALL - SECOND PAIR SEEN (pair and pair, fourth possibility vic-vic-ana):
((if (and (equal NIL secondpairseen) (pair firstpair) (pair (car listofallatoms))
(equal (cdr firstpair) (ecdar listofallatoms))
(not (equal (car firstpair) (ecaar listofallatoms)))
(not (equal (car firstpair) (cdr firstpair)))
(not (equal (ecaar listofallatoms) (ecdar listofallatoms)))) T NIL)
(progn ; (terpri) (print "CLAUSE 24 ") (print " FIRST: ") (print firstpair) (print " SECOND: ") (print secondpair) (print " THIRD: ") (print thirdpair) (print " CAR_L: ") (print (car listofallatoms)) (terpri)
(proto-eval-triangle firstpair (car listofallatoms) (list (car firstpair) (ecaar listofallatoms))
firstpairseen T thirdpairseen inconclusives (cdr listofallatoms) atomschecked)))
; RECALL - SECOND PAIR SEEN (list and list, first possibility ana-ana-ana):
((if (and (equal NIL secondpairseen) (listq firstpair) (listq (car listofallatoms))
(equal (car firstpair) (ecaar listofallatoms))
(not (equal (ecadr firstpair) (ecadar listofallatoms)))
(not (equal (car firstpair) (ecadr firstpair)))
(not (equal (ecaar listofallatoms) (ecadar listofallatoms)))) T NIL)
(progn ; (terpri) (print "CLAUSE 25 ") (print " FIRST: ") (print firstpair) (print " SECOND: ") (print secondpair) (print " THIRD: ") (print thirdpair) (print " CAR_L: ") (print (car listofallatoms)) (terpri)
(proto-eval-triangle firstpair (car listofallatoms) (list (ecadr firstpair) (ecadar listofallatoms))
firstpairseen T thirdpairseen inconclusives (cdr listofallatoms) atomschecked)))
; RECALL - SECOND PAIR SEEN (list and list, second possibility ana-ana-ana):
((if (and (equal NIL secondpairseen) (listq firstpair) (listq (car listofallatoms))
(equal (ecadr firstpair) (ecadar listofallatoms))
(not (equal (car firstpair) (ecaar listofallatoms)))
(not (equal (car firstpair) (ecadr firstpair)))
(not (equal (ecaar listofallatoms) (ecadar listofallatoms)))) T NIL)
(progn ; (terpri) (print "CLAUSE 26 ") (print " FIRST: ") (print firstpair) (print " SECOND: ") (print secondpair) (print " THIRD: ") (print thirdpair) (print " CAR_L: ") (print (car listofallatoms)) (terpri)
(proto-eval-triangle firstpair (car listofallatoms) (list (car firstpair) (ecaar listofallatoms))
firstpairseen T thirdpairseen inconclusives (cdr listofallatoms) atomschecked)))
; RECALL - SECOND PAIR SEEN (list and list, third possibility ana-ana-ana):
((if (and (equal NIL secondpairseen) (listq firstpair) (listq (car listofallatoms))
(equal (car firstpair) (ecadar listofallatoms))
(not (equal (ecadr firstpair) (ecaar listofallatoms)))
(not (equal (car firstpair) (ecadr firstpair)))
(not (equal (ecaar listofallatoms) (ecadar listofallatoms)))) T NIL)
(progn ; (terpri) (print "CLAUSE 27 ") (print " FIRST: ") (print firstpair) (print " SECOND: ") (print secondpair) (print " THIRD: ") (print thirdpair) (print " CAR_L: ") (print (car listofallatoms)) (terpri)
(proto-eval-triangle firstpair (car listofallatoms) (list (ecadr firstpair) (ecaar listofallatoms))
firstpairseen T thirdpairseen inconclusives (cdr listofallatoms) atomschecked)))
; RECALL - SECOND PAIR SEEN (list and list, fourth possibility ana-ana-ana):
((if (and (equal NIL secondpairseen) (listq firstpair) (listq (car listofallatoms))
(equal (ecadr firstpair) (ecaar listofallatoms))
(not (equal (car firstpair) (ecadar listofallatoms)))
(not (equal (car firstpair) (ecadr firstpair)))
(not (equal (ecaar listofallatoms) (ecadar listofallatoms)))) T NIL)
(progn ; (terpri) (print "CLAUSE 28 ") (print " FIRST: ") (print firstpair) (print " SECOND: ") (print secondpair) (print " THIRD: ") (print thirdpair) (print " CAR_L: ") (print (car listofallatoms)) (terpri)
(proto-eval-triangle firstpair (car listofallatoms) (list (car firstpair) (ecadar listofallatoms))
firstpairseen T thirdpairseen inconclusives (cdr listofallatoms) atomschecked)))
; RECALL - SECOND PAIR SEEN (pair and pair, first possibility vic-ana-vic):
((if (and (equal NIL secondpairseen) (pair firstpair) (listq (car listofallatoms))
(equal (car firstpair) (ecaar listofallatoms))
(not (equal (cdr firstpair) (ecadar listofallatoms)))
(not (equal (car firstpair) (cdr firstpair)))
(not (equal (ecaar listofallatoms) (ecadar listofallatoms)))) T NIL)
(progn ; (terpri) (print "CLAUSE 29 ") (print " FIRST: ") (print firstpair) (print " SECOND: ") (print secondpair) (print " THIRD: ") (print thirdpair) (print " CAR_L: ") (print (car listofallatoms)) (terpri)
(proto-eval-triangle firstpair (car listofallatoms) (cons (ecadar listofallatoms) (cdr firstpair))
firstpairseen T thirdpairseen inconclusives (cdr listofallatoms) atomschecked)))
; RECALL - SECOND PAIR SEEN (pair and pair, second possibility vic-ana-vic):
((if (and (equal NIL secondpairseen) (pair firstpair) (listq (car listofallatoms))
(equal (cdr firstpair) (ecadar listofallatoms))
(not (equal (car firstpair) (ecaar listofallatoms)))
(not (equal (car firstpair) (cdr firstpair)))
(not (equal (ecaar listofallatoms) (ecadar listofallatoms)))) T NIL)
(progn ; (terpri) (print "CLAUSE 30 ") (print " FIRST: ") (print firstpair) (print " SECOND: ") (print secondpair) (print " THIRD: ") (print thirdpair) (print " CAR_L: ") (print (car listofallatoms)) (terpri)
(proto-eval-triangle firstpair (car listofallatoms) (cons (car firstpair) (ecaar listofallatoms))
firstpairseen T thirdpairseen inconclusives (cdr listofallatoms) atomschecked)))
; RECALL - SECOND PAIR SEEN (pair and pair, third possibility vic-ana-vic):
((if (and (equal NIL secondpairseen) (pair firstpair) (listq (car listofallatoms))
(equal (car firstpair) (ecadar listofallatoms))
(not (equal (cdr firstpair) (ecaar listofallatoms)))
(not (equal (car firstpair) (cdr firstpair)))
(not (equal (ecaar listofallatoms) (ecadar listofallatoms)))) T NIL)
(progn ; (terpri) (print "CLAUSE 31 ") (print " FIRST: ") (print firstpair) (print " SECOND: ") (print secondpair) (print " THIRD: ") (print thirdpair) (print " CAR_L: ") (print (car listofallatoms)) (terpri)
(proto-eval-triangle firstpair (car listofallatoms) (cons (ecaar listofallatoms) (cdr firstpair))
firstpairseen T thirdpairseen inconclusives (cdr listofallatoms) atomschecked)))
; RECALL - SECOND PAIR SEEN (pair and pair, fourth possibility vic-ana-vic):
((if (and (equal NIL secondpairseen) (pair firstpair) (listq (car listofallatoms))
(equal (cdr firstpair) (ecaar listofallatoms))
(not (equal (car firstpair) (ecadar listofallatoms)))
(not (equal (car firstpair) (cdr firstpair)))
(not (equal (ecaar listofallatoms) (ecadar listofallatoms)))) T NIL)
(progn ; (terpri) (print "CLAUSE 32 ") (print " FIRST: ") (print firstpair) (print " SECOND: ") (print secondpair) (print " THIRD: ") (print thirdpair) (print " CAR_L: ") (print (car listofallatoms)) (terpri)
(proto-eval-triangle firstpair (car listofallatoms) (cons (car firstpair) (ecadar listofallatoms))
firstpairseen T thirdpairseen inconclusives (cdr listofallatoms) atomschecked)))
; RECALL - SECOND PAIR SEEN (pair and pair, first possibility ana-vic-vic):
((if (and (equal NIL secondpairseen) (listq firstpair) (pair (car listofallatoms))
(equal (car firstpair) (ecaar listofallatoms))
(not (equal (ecadr firstpair) (ecdar listofallatoms)))
(not (equal (car firstpair) (ecadr firstpair)))
(not (equal (ecaar listofallatoms) (ecdar listofallatoms)))) T NIL)
(progn ; (terpri) (print "CLAUSE 33 ") (print " FIRST: ") (print firstpair) (print " SECOND: ") (print secondpair) (print " THIRD: ") (print thirdpair) (print " CAR_L: ") (print (car listofallatoms)) (terpri)
(proto-eval-triangle firstpair (car listofallatoms) (cons (ecadr firstpair) (ecdar listofallatoms))
firstpairseen T thirdpairseen inconclusives (cdr listofallatoms) atomschecked)))
; RECALL - SECOND PAIR SEEN (pair and pair, second possibility ana-vic-vic):
((if (and (equal NIL secondpairseen) (listq firstpair) (pair (car listofallatoms))
(equal (ecadr firstpair) (ecdar listofallatoms))
(not (equal (car firstpair) (ecaar listofallatoms)))
(not (equal (car firstpair) (ecadr firstpair)))
(not (equal (ecaar listofallatoms) (ecdar listofallatoms)))) T NIL)
(progn ; (terpri) (print "CLAUSE 34 ") (print " FIRST: ") (print firstpair) (print " SECOND: ") (print secondpair) (print " THIRD: ") (print thirdpair) (print " CAR_L: ") (print (car listofallatoms)) (terpri)
(proto-eval-triangle firstpair (car listofallatoms) (cons (ecaar listofallatoms) (car firstpair))
firstpairseen T thirdpairseen inconclusives (cdr listofallatoms) atomschecked)))
; RECALL - SECOND PAIR SEEN (pair and pair, third possibility ana-vic-vic):
((if (and (equal NIL secondpairseen) (listq firstpair) (pair (car listofallatoms))
(equal (car firstpair) (ecdar listofallatoms))
(not (equal (ecadr firstpair) (ecaar listofallatoms)))
(not (equal (car firstpair) (ecadr firstpair)))
(not (equal (ecaar listofallatoms) (ecdar listofallatoms)))) T NIL)
(progn ; (terpri) (print "CLAUSE 35 ") (print " FIRST: ") (print firstpair) (print " SECOND: ") (print secondpair) (print " THIRD: ") (print thirdpair) (print " CAR_L: ") (print (car listofallatoms)) (terpri)
(proto-eval-triangle firstpair (car listofallatoms) (cons (ecaar listofallatoms) (ecadr firstpair))
firstpairseen T thirdpairseen inconclusives (cdr listofallatoms) atomschecked)))
; RECALL - SECOND PAIR SEEN (pair and pair, fourth possibility ana-vic-vic):
((if (and (equal NIL secondpairseen) (listq firstpair) (pair (car listofallatoms))
(equal (ecadr firstpair) (ecaar listofallatoms))
(not (equal (car firstpair) (ecdar listofallatoms)))
(not (equal (car firstpair) (ecadr firstpair)))
(not (equal (ecaar listofallatoms) (ecdar listofallatoms)))) T NIL)
(progn ; (terpri) (print "CLAUSE 36 ") (print " FIRST: ") (print firstpair) (print " SECOND: ") (print secondpair) (print " THIRD: ") (print thirdpair) (print " CAR_L: ") (print (car listofallatoms)) (terpri)
(proto-eval-triangle firstpair (car listofallatoms) (cons (car firstpair) (ecdar listofallatoms))
firstpairseen T thirdpairseen inconclusives (cdr listofallatoms) atomschecked)))
; RECALL - SECOND PAIR CONTRADICTED ERE USED FOR A THIRD ATOM (pair):
; this is not a termination reason, as the hypothesis of the first atom was not per se being contradicted:
((if (and (equal T secondpairseen) (equal NIL thirdpairseen) (pair secondpair)
(or (and (pair (car listofallatoms)) (equal (car listofallatoms) (cons (cdr secondpair) (car secondpair))))
(and (listq (car listofallatoms))
(or (equal (car listofallatoms) (list (car secondpair) (cdr secondpair)))
(equal (car listofallatoms) (list (cdr secondpair) (car secondpair))))))) T NIL)
(progn ; (terpri) (print "CLAUSE 37 ") (print " FIRST: ") (print firstpair) (print " SECOND: ") (print secondpair) (print " THIRD: ") (print thirdpair) (print " CAR_L: ") (print (car listofallatoms)) (terpri)
(proto-eval-triangle firstpair 'INCOGNITUM 'INCOGNITUM firstpairseen NIL NIL inconclusives (cdr listofallatoms)
(cons secondpair (cons (car listofallatoms) atomschecked)))))
; the second pair will end up next to and behind its contradiction
; RECALL - SECOND PAIR CONTRADICTED ERE USED FOR A THIRD ATOM (list):
; this is not a termination reason, as the hypothesis of the first atom was not per se being contradicted:
((if (and (equal T secondpairseen) (equal NIL thirdpairseen) (listq secondpair)
(pair (car listofallatoms))
(or (equal (car listofallatoms) (cons (car secondpair) (ecadr secondpair)))
(equal (car listofallatoms) (cons (ecadr secondpair) (car secondpair))))) T NIL)
(progn ; (terpri) (print "CLAUSE 38 ") (print " FIRST: ") (print firstpair) (print " SECOND: ") (print secondpair) (print " THIRD: ") (print thirdpair) (print " CAR_L: ") (print (car listofallatoms)) (terpri)
(proto-eval-triangle firstpair 'INCOGNITUM 'INCOGNITUM firstpairseen NIL NIL inconclusives (cdr listofallatoms)
(cons secondpair (cons (car listofallatoms) atomschecked)))))
; the second pair will end up next to and behind its contradiction
; RECALL - NOTHING OF INTEREST HAPPENED:
(T
(proto-eval-triangle firstpair secondpair thirdpair firstpairseen secondpairseen thirdpairseen inconclusives
(cdr listofallatoms) (cons (car listofallatoms) atomschecked))))))
(defun eval-triangle (firstpair listofallatoms)
(if (equal (car firstpair) (cdr firstpair))
(extractpair firstpair listofallatoms NIL)
(proto-eval-triangle firstpair 'INCOGNITUM 'INCOGNITUM NIL NIL NIL NIL listofallatoms NIL)))
; The sample calls were mainly inspired by the victri-predecessor:
; sample calls (non-exhaustive):
; positive triangulation 1:
; (eval-triangle '(a . b) '((x . y) (b . c) (a . c) (y . z) (q . r) (a . b)))
; --> (T (A . B) (B . C) (A . C) (X . Y) (Y . Z) (Q . R) (NIHIL . NIHIL))
; negative triangulation 1:
; (eval-triangle '(a . b) '((x . y) (b . c) (a . b) (c . a) (y . z) (q . r)))
; --> (NIL (X . Y) (C . A) (Y . Z) (Q . R) (A . C) (B . C) (A . B))
; positive triangulation 2:
; (eval-triangle '(a . b) '((x . y) (z . a) (a . b) (z . b) (y . z) (q . r)))
; --> (T (A . B) (Z . A) (Z . B) (X . Y) (Y . Z) (Q . R) (NIHIL . NIHIL))
; negative triangulation 2:
; (eval-triangle '(a . b) '((x . y) (z . a) (a . b) (b . z) (y . z) (q . r)))
; --> (NIL (X . Y) (B . Z) (Y . Z) (Q . R) (Z . B) (Z . A) (A . B))
; positive triangulation 3:
; (eval-triangle '(a . b) '((x . y) (b c) (a . c) (y . z) (q . r) (a . b)))
; --> (T (A . B) (B C) (A . C) (X . Y) (Y . Z) (Q . R) (NIHIL . NIHIL))
; negative triangulation 3:
; (eval-triangle '(a . b) '((x . y) (b c) (a c) (y . z) (q . r) (a . b)))
; --> (NIL (X . Y) (A C) (Y . Z) (Q . R) (A . B) (A . C) (B C))
; positive triangulation 4:
; (eval-triangle '(a b) '((x . y) (b . c) (a . c) (y . z) (q . r) (a b)))
; --> (T (A B) (B . C) (A . C) (X . Y) (Y . Z) (Q . R) (NIHIL . NIHIL))
; negative triangulation 3:
; (eval-triangle '(a b) '((x . y) (b . c) (a c) (y . z) (q . r) (a b)))
; --> (NIL (X . Y) (A C) (Y . Z) (Q . R) (A B) (A . C) (B . C))
; positive triangulation 5:
; (eval-triangle '(a b) '((x . y) (b c) (a c) (y . z) (q . r) (a b)))
; --> (T (A B) (B C) (A C) (X . Y) (Y . Z) (Q . R) (NIHIL . NIHIL))
; negative triangulation 5:
; (eval-triangle '(a b) '((x . y) (b . c) (c . a) (y . z) (q . r) (a b)))
; --> (NIL (X . Y) (C . A) (Y . Z) (Q . R) (A B) (A . C) (B . C))
; conclusion 1:
; (eval-triangle '(a . b) '((x . y) (b . c) (a . b) (e . f) (y . z) (q . r)))
; --> (T (A . B) (B . C) (A . C) (X . Y) (E . F) (Y . Z) (Q . R))
; conclusion 2:
; (eval-triangle '(a . b) '((x . y) (z . a) (a . b) (e . f) (y . z) (q . r)))
; --> (T (A . B) (Z . A) (Z . B) (X . Y) (E . F) (Y . Z) (Q . R))
; conclusion 3:
; (eval-triangle '(a . b) '((x . y) (b . c) (a . c) (e . f) (y . z) (q . r)))
; --> (T (A . B) (B . C) (A . C) (X . Y) (E . F) (Y . Z) (Q . R))
; conclusion 4:
; (eval-triangle '(a . b) '((x . y) (z . a) (z . b) (e . f) (y . z) (q . r)))
; --> (T (A . B) (Z . A) (Z . B) (X . Y) (E . F) (Y . Z) (Q . R))
; conclusion 5:
; (eval-triangle '(a . b) '((x . y) (b c) (a . b) (e . f) (y . z) (q . r)))
; --> (T (A . B) (B C) (A . C) (X . Y) (E . F) (Y . Z) (Q . R))
; conclusion 6:
; (eval-triangle '(a b) '((x . y) (b . c) (a b) (e . f) (y . z) (q . r)))
; --> (T (A B) (B . C) (A . C) (X . Y) (E . F) (Y . Z) (Q . R))
; conclusion 7:
; (eval-triangle '(a . b) '((x . y) (a . c) (a . b) (e . f) (y . z) (q . r)))
; --> (T (A . B) (A . C) (B C) (X . Y) (E . F) (Y . Z) (Q . R))
; conclusion 8:
; (eval-triangle '(a b) '((x . y) (b c) (a b) (e . f) (y . z) (q . r)))
; --> (T (A B) (B C) (A C) (X . Y) (E . F) (Y . Z) (Q . R))
; counter-conclusion 1:
; (eval-triangle '(a . b) '((x . y) (b . c) (b . a) (e . f) (y . z) (q . r)))
; --> (NIL (X . Y) (B . A) (E . F) (Y . Z) (Q . R) (B . C) (A . B))
; counter-conclusion 2:
; (eval-triangle '(a . b) '((x . y) (z . a) (b . a) (e . f) (y . z) (q . r)))
; --> (NIL (X . Y) (B . A) (E . F) (Y . Z) (Q . R) (Z . A) (A . B))
; counter-conclusion 3:
; (eval-triangle '(a . b) '((x . y) (b . c) (c . a) (e . f) (y . z) (q . r)))
; --> (NIL (X . Y) (C . A) (E . F) (Y . Z) (Q . R) (A . C) (B . C))
; counter-conclusion 4:
; (eval-triangle '(a . b) '((x . y) (z . a) (b . z) (e . f) (y . z) (q . r)))
; --> (NIL (X . Y) (B . Z) (E . F) (Y . Z) (Q . R) (Z . B) (Z . A))
; counter-conclusion 5:
; (eval-triangle '(a . b) '((x . y) (b c) (a b) (e . f) (y . z) (q . r)))
; --> (NIL (X . Y) (A B) (E . F) (Y . Z) (Q . R) (B C) (A . B))
; counter-conclusion 6:
; (eval-triangle '(a b) '((x . y) (b . c) (c . a) (e . f) (y . z) (q . r)))
; --> (NIL (X . Y) (C . A) (E . F) (Y . Z) (Q . R) (A . C) (B . C))
; counter-conclusion 7:
; (eval-triangle '(a . b) '((x . y) (a c) (a b) (e . f) (y . z) (q . r)))
; --> (NIL (X . Y) (A B) (E . F) (Y . Z) (Q . R) (A C) (A . B))
; counter-conclusion 8:
; (eval-triangle '(a b) '((x . y) (b . c) (a . b) (e . f) (y . z) (q . r)))
; --> (NIL (X . Y) (A . B) (E . F) (Y . Z) (Q . R) (B . C) (A B))
; inconclusive - A-B is proposed, but cannot be proven in any way:
; (eval-triangle '(a . b) '((x . y) (g . h) (f . g) (e . f) (y . z) (q . r)))
; --> (INCOGNITUM (A . B) (X . Y) (G . H) (F . G) (E . F) (Y . Z) (Q . R))
; inconclusive - A=B is proposed, but cannot be proven in any way:
; (eval-triangle '(a b) '((x . y) (g . h) (f . g) (e . f) (y . z) (q . r)))
; --> (INCOGNITUM (A B) (X . Y) (G . H) (F . G) (E . F) (Y . Z) (Q . R))
; inconclusive - vicinal combination possible, but proposal unknown:
; (eval-triangle '(a . b) '((x . y) (g . h) (b . c) (e . f) (y . z) (q . r)))
; --> (INCONGITUM (A . B) (B . C) (X . Y) (G . H) (E . F) (Y . Z) (Q . R))
; inconclusive - analogous combination possible, but proposal unknown:
; (eval-triangle '(a b) '((x . y) (g . h) (b . c) (e . f) (y . z) (q . r)))
; --> (INCONGITUM (A B) (B . C) (X . Y) (G . H) (E . F) (Y . Z) (Q . R))
; direct confirmation 1:
; (eval-triangle '(a . b) '((x . y) (e . f) (a . b) (b . a) (y . z) (q . r)))
; --> (T (A . B) (X . Y) (E . F) (B . A) (Y . Z) (Q . R) (NIHIL . NIHIL))
; direct confirmation 2:
; (eval-triangle '(a b) '((x . y) (e . f) (a b) (b . a) (y . z) (q . r)))
; --> (T (A B) (X . Y) (E . F) (B . A) (Y . Z) (Q . R) (NIHIL . NIHIL))
; direct confirmation 3:
; (eval-triangle '(a b) '((x . y) (e . f) (b a) (b . a) (y . z) (q . r)))
; --> (T (A B) (X . Y) (E . F) (B . A) (Y . Z) (Q . R) (NIHIL . NIHIL))
; the atom doubling in the end is not good:
; direct contradiction 1:
; (eval-triangle '(a . b) '((x . y) (e . f) (b . a) (q . e) (y . z) (a . b)))
; --> (NIL (X . Y) (E . F) (B . A) (Q . E) (Y . Z) (A . B) (A . B))
; direct contradiction 2:
; (eval-triangle '(a . b) '((x . y) (b . c) (b . a) (q . e) (y . z) (a . b)))
; --> (NIL (X . Y) (B . A) (Q . E) (Y . Z) (A . B) (B . C) (A . B))
; direct contradiction 3:
; (eval-triangle '(a . b) '((x . y) (b . c) (a . c) (b . a) (y . z) (a . b)))
; --> (NIL (X . Y) (B . A) (Y . Z) (A . B) (A . C) (B . C) (A . B))
; direct contradiction 4:
; (eval-triangle '(a . b) '((x . y) (e . f) (b a) (q . e) (y . z) (a . b)))
; --> (NIL (X . Y) (E . F) (B A) (Q . E) (Y . Z) (A . B) (A . B))
; direct contradiction 5:
; (eval-triangle '(a b) '((x . y) (e . f) (a . b) (q . e) (y . z) (a b)))
; --> (NIL (X . Y) (E . F) (A . B) (Q . E) (Y . Z) (A B) (A B))
; say that a list must have at least 3 elements to be considered for
; triangulation (minimum for recognising three known triangle sides):
(defun notlongenough (somelist)
(if (or
(null somelist)
(null (ecdr somelist))
(null (ecddr somelist)))
T NIL))
; sample calls:
; (notlongenough '(a b)) --> T
; (notlongenough '(a b c)) --> NIL
; later on, I will use cddddr, i.e. one "cdr" more, because I know that the list
; will have a #t, #f or () attached in front.
; OPERATION SNOWFLAKE:
; As an improvement to an earlier version, not only a term is evaluated,
; but also each of the participants in its triangulations is evaluated.
; I.e., each of the two other sides now tries to reach further
; conclusions. - That means that inheritance of conclusions is possible
; even if not directly driven by input. (That might be too far-reaching
; and too "fanciful", which is why the old version above is kept for
; reference.) - I am calling this figure a "snowflake" as further
; triangles may thus emerge from the sides of triangles.
; Relying only on the first pair for confirming a term is possible, but
; other choices are possible, too. Relying on the first pair bases
; reasoning on the basis of "most recent experience". But if one were
; to base reasoning on the "most consistent recent experience", one
; should look at further combination possibilities of a given term -
; namely, HOW MANY positive conclusions can be made without
; hitting a contradiction. This is done by re-evaluating a term on the
; list of all atoms "apart from" positive previous conclusions.
(defun proto1-re-eval (firstpair listofallatoms congruentpairs counter)
(if (notlongenough listofallatoms)
congruentpairs ; this line is - it delivers which congruent pairs to re-evaluate.
(let ((evaltri (eval-triangle firstpair listofallatoms)))
(if (equal NIL (car evaltri)) ; we hit a wrong combination - output the transformed list so far
congruentpairs
(if (null (car evaltri)) ; we hit an inconclusive combination
congruentpairs
(proto1-re-eval firstpair (cddddr evaltri) (cons (cadddr evaltri) (cons (caddr evaltri) congruentpairs)) (+ 1 counter)))))))
; Deriving conclusions has the positive effect of extending consistent
; knowledge - but it also has the negative effect of displacing old
; knowledge into forgetting. - This second effect becomes problematic
; if very many conclusions are reached, and therefore, the below
; function terminates reasoning if the "global limit" of conclusions
; has been reached. (If that number is negative, there is no limit.)
; The global limit of conclusions not only limits the conclusions of a
; given couple of atoms, it also limits how many "consequential"
; evaluations may be undertaken, namely globallimit^N, where currently
; N=2. (The initial pair triggering N conclusions, and each of these
; triggering further N conclusions.)
; NOW _THIS_ IS FUN: I HAVE DIFFERENT CONSEQUENCES FOR #f & NIL!
; I HANDLED THE "#f" as "NIL" and the "'()" as "'INCOGNITUM".
; THUNK: GLOBAL LIMIT ENABLED IN THE SECOND LINE. Otherwise exactly the same as above.
(defun proto2-re-eval (firstpair listofallatoms congruentpairs counter)
(if (or (zerop globallimit) (notlongenough listofallatoms))
(cons counter (cons firstpair (append (reverse congruentpairs) listofallatoms)))
(let ((evaltri (eval-triangle firstpair listofallatoms)))
(if (equal NIL (car evaltri)) ; we hit a wrong combination - output the transformed list so far
(cons (- counter 1) (cons firstpair (append (reverse congruentpairs) (reverse (cdr (reverse (cdr evaltri)))))))
(if (equal 'INCOGNITUM (car evaltri)) ; we hit an inconclusive combination
(cons counter (cons firstpair (append (reverse congruentpairs) (cddr evaltri))))
(proto2-re-eval firstpair (cddddr evaltri) (cons (cadddr evaltri) (cons (caddr evaltri) congruentpairs)) (+ 1 counter)))))))
; the congruent pairs are delivered in a back-to-front way:
(defun proto3-re-eval (firstpair congruentpairs counter listofallatoms)
(if (null congruentpairs)
(reverse (cdr (reverse (proto2-re-eval firstpair listofallatoms '() counter)))) ; (cons counter listofallatoms)
(let ((reeval (reverse (cdr (reverse (proto2-re-eval (car congruentpairs) listofallatoms '() counter))))))
(proto3-re-eval firstpair (cdr congruentpairs) (+ counter (car reeval)) (cdr reeval))))) ; making this not reverse cdr reverse reeval keeps the length.
; Basically, the idea is that not a single pair is re-evaluated, but
; all pairs that single pair generates. For this, first the congruent
; pairs are established in in proto1-re-eval. Then proto3-re-eval is
; feeding each of these pairs to the original list of all atoms (i.e.
; not the evaluated one in proto1-re-eval) by means of proto2-re-eval.
; When done, it spits out the last evaluation.
; Old version, just once following the conclusions - can be enabled any
; time instead of the other functions:
; (defun re-eval (firstpair listofallatoms)
; (let ((re-ev (proto1-re-eval firstpair listofallatoms '() 1))) ; "1" means minimum 0 in the result.
; (proto3-re-eval firstpair re-ev 1 listofallatoms)))
; Erasedup is an UGLY KLUDGE that should be eliminated in order to get
; the below functions to work (not needed for try 4):
(defun proto-erasedup (somelist resultlist)
(if (null somelist) (reverse resultlist)
(if (or (and (listq (car somelist))
(not (member (car somelist) resultlist))
(not (member (reverse (car somelist)) resultlist)))
(and (pair (car somelist))
(not (member (car somelist) resultlist))))
(proto-erasedup (cdr somelist) (cons (car somelist) resultlist))
(proto-erasedup (cdr somelist) resultlist))))
(defun erasedup (somelist) (proto-erasedup somelist '()))
(defun build-conclusions-list (listofconclusions listofallatoms resultlist)
(if (null listofconclusions) ; the previous variant "(cdr resultlist)"
(if (not (null resultlist)) (cdr resultlist) '()) ; caused an error on an empty list
(build-conclusions-list (cdr listofconclusions) listofallatoms
(append resultlist (proto1-re-eval (car listofconclusions) listofallatoms '() 1)))))
(defun proto-get-conclusions (snowdepth listofallatoms resultconclusions)
(if (zerop snowdepth) resultconclusions
(let ((build-conc (build-conclusions-list resultconclusions listofallatoms '())))
(if (null build-conc) ; then you are unable to re-reason and you may terminate faster
resultconclusions ; otherwise, continue searching conclusions:
(proto-get-conclusions (- snowdepth 1) listofallatoms (append resultconclusions build-conc))))))
(defun get-conclusions (firstpair listofallatoms)
(proto-get-conclusions snow-depth listofallatoms (list firstpair)))
(defun re-eval (firstpair listofallatoms)
(let ((re-ev (get-conclusions firstpair listofallatoms))) ; "1" means minimum 0 in the result.
; (begin (display "re-ev: ") (display re-ev) (display #\newline)
; THIS CAN BE REPLACED:
(proto3-re-eval firstpair (cdr (erasedup re-ev)) 1 listofallatoms)))
; EXTREME DEPTH CAN BE GAINED IF NOT USING ERASEDUP, BUT THE
; CONCLUSIONS COUNT RISES AWFULLY - FROM 126 TO 274953538178:
; (proto3-re-eval firstpair (cdr re-ev) 1 listofallatoms)))
; )
; Rather than a global limit, the above function could contain a local
; limit - I do not _need_ to supply the _entire_ re-eval to
; proto3-re-eval, I could limit it to its first M conclusions.
; M does not have to be the same as N above, it could be e.g. N^2.
; So far, everything is symmetrically regulated by the globallimit.
; sample calls:
; (re-eval '(a . b) '((x . y) (q . r) (b . c) (c . a) (s . t) (b . d) (d . a) (l . m) (n . o) (o . p) (p . q) (q . r)))
; --> (0 (A . B) (X . Y) (Q . R) (C . A) (S . T) (B . D) (D . A) (L . M) (N . O) (O . P) (P . Q) (Q . R))
; (re-eval '(a . b) '((x . y) (q . r) (s . t) (l . m) (n . o) (o . p) (p . q) (q . r) (r . s)))
; --> (1 (A . B) (X . Y) (Q . R) (S . T) (L . M) (N . O) (O . P) (P . Q) (Q . R))
; (re-eval '(a . b) '((x . y) (b . c) (a . c) (q . r) (s . t) (l . m) (n . o) (o . p) (p . q) (q . r) (r . s)))
; --> (2 (A . B) (B . C) (A . C) (X . Y) (Q . R) (S . T) (L . M) (N . O) (O . P) (P . Q) (Q . R))
; (re-eval '(a . b) '((x . y) (b . c) (a . c) (b . d) (a . d) (l . r) (s . t) (l . m) (n . o) (o . p) (p . q) (q . r) (r . s)))
; --> (3 (A . B) (B . C) (A . C) (B . D) (A . D) (X . Y) (L . R) (S . T) (L . M) (N . O) (O . P) (P . Q) (Q . R))
; (re-eval '(a . b) '((x . y) (b . c) (a . c) (b . d) (a . d) (b . e) (e . a) (l . r) (s . t) (l . m) (n . o) (o . p) (p . q) (q . r) (r . s)))
; --> (2 (A . B) (B . C) (A . C) (B . D) (A . D) (X . Y) (E . A) (L . R) (S . T) (L . M) (N . O) (O . P) (P . Q) (Q . R) (R . S))
; (re-eval '(a . b) '((x . y) (b . c) (a . c) (b . d) (a . d) (b . e) (e . a) (b . f) (f . a) (q . r) (s . t) (l . m) (n . o) (o . p) (p . q) (q . r) (r . s)))
; --> (2 (A . B) (B . C) (A . C) (B . D) (A . D) (X . Y) (E . A) (B . F) (F . A) (Q . R) (S . T) (L . M) (N . O) (O . P) (P . Q) (Q . R) (R . S))
; (re-eval '(a . b) '((x . y) (b . c) (a . c) (b . e) (e . a) (b . f) (f . a) (q . r) (s . t) (l . m) (n . o) (o . p) (p . q) (q . r) (r . s)))
; --> (1 (A . B) (B . C) (A . C) (X . Y) (E . A) (B . F) (F . A) (Q . R) (S . T) (L . M) (N . O) (O . P) (P . Q) (Q . R) (R . S))
; (re-eval '(a . b) '((x . y) (b . e) (e . a) (b . f) (f . a) (q . r) (s . t) (l . m) (n . o) (o . p) (p . q) (q . r) (r . s)))
; --> (0 (A . B) (X . Y) (E . A) (B . F) (F . A) (Q . R) (S . T) (L . M) (N . O) (O . P) (P . Q) (Q . R) (R . S))
; END OF OPERATION SNOWFLAKE.
; Now - remove all duplicates and say how often you saw any unicate.
; Triangulation should be undertaken on each input unit only once.
; However, triangulation merely shows "confirmed observations" -
; actually, observations may be confirmed also from how often they are seen in input.
(defun proto1-erase-duplicates (unicate listofpairs counter resultlist)
(if (null listofpairs) (cons (cons counter unicate) (reverse resultlist))
(if (equal unicate (car listofpairs))
(proto1-erase-duplicates unicate (cdr listofpairs) (+ 1 counter) resultlist)
(proto1-erase-duplicates unicate (cdr listofpairs) counter (cons (car listofpairs) resultlist)))))
(defun proto2-erase-duplicates (listofunicates listofpairs resultlist)
(if (null listofunicates) (reverse resultlist)
(let ((proto1 (proto1-erase-duplicates (car listofunicates) listofpairs 0 '())))
(proto2-erase-duplicates (cdr proto1) (cdr proto1)
(cons (car proto1) resultlist)))))
(defun erase-duplicates (listofpairs) (proto2-erase-duplicates listofpairs listofpairs '()))
; sample call:
; (erase-duplicates '((a . b) (a . b) (b . c) (c . d) (a . b) (c . d)))
; --> ((3 A . B) (1 B . C) (2 C . D))
; I could now MULTIPLY that with triangulation results...
; or I could merely ADD it, and ADDING IT would be more interesting if
; the results could be NEGATIVE. But NEGATIVE results would only
; signify ABSOLUTE KNOWLEDGE rather than ATTENTION.
(defun proto-compare-tri (pairs listofallatoms bestresult)
(if (null pairs) bestresult
(let ((intermediate (re-eval (cdar pairs) listofallatoms)))
(if (>= (+ (caar pairs) (car intermediate)) (car bestresult))
(proto-compare-tri (cdr pairs) listofallatoms
(cons (+ (caar pairs) (car intermediate)) (cdr intermediate)))
(proto-compare-tri (cdr pairs) listofallatoms bestresult)))))
(defun compare-tri (inputlist listofallatoms)
(proto-compare-tri (erase-duplicates (mapcons inputlist)) listofallatoms '(-1 ())))
; sample calls:
; (compare-tri '(a b c a b d a b e)
; '((f . g) (a . b) (b . x) (g . h) (b . y) (a . y) (b . z) (z . a)
; (b . h) (a . h) (c . i) (c . j) (k . b) (k . c) (l . b) (l . c)
; (m . b) (m . c) (b . i) (b . j)
; ; (c . a) is unknown
; (d . b)
; (e . n) (n . b)))
; previously in Scheme it used to be:
; --> (5 (a . b) (b . x) (a . x) (b . y) (a . y) (f . g) (g . h)
; (z . a) (b . h) (a . h) (c . i) (c . j) (k . b) (k . c) (l . b)
; (l . c) (m . b) (m . c) (b . i) (b . j) (d . b) (e . n) (n . b))
; now it is:
; --> (13 (B . E) (A . B) (F . G) (B . X) (G . H) (B . Y) (A . Y)
; (B . Z) (Z . A) (B . H) (A . H) (K . B) (C . I) (L . B) (C . J)
; (M . B) (K . C) (B . I) (L . C) (B . J) (M . C) (D . B) (E . N))
; (compare-tri '(a b c a b d a b e)
; '((f . g) (a . b) (b . x) (g . h) (b . y) (a . y) (b . z) (z . a)
; (b . h) (a . h) (c . b) (c . i) (c . j)
; (a . c) ; it tend to conclude
; (a . d) ; each of these three's antitheses if they are not
; (d . b) ; specified, because they are later than "(a . b)"
; (e . n) (n . b)))
; previously in Scheme it used to be:
; --> (5 (a . b) (b . x) (a . x) (b . y) (a . y) (f . g) (g . h)
; (z . a) (b . h) (a . h) (c . b) (c . i) (c . j) (a . c) (a . d)
; (d . b) (e . n) (n . b))
; now it is:
; --> (8 (B . E) (A . B) (F . G) (B . X) (G . H) (B . Y) (A . Y)
; (B . Z) (Z . A) (B . H) (A . H) (C . B) (C . I) (D . B) (C . J)
; (A . C) (A . D) (N . B))
; Now, the foundation of hierarchisation has to be defined. I.e. that
; the system re-considers input, each time combining another pair.
; IN THE PRESENT DESIGN, HIERARCHISATION ALWAYS CONTINUES "TO THE TOP"
; AND DELIVERS "ONE" CONNECTION AS THE ANSWER. - THIS HAPPENS ON EACH
; RE-HIERARCHISATION, TOO. - That might be re-considered as it is
; wasteful of atoms, but on the positive side, it creates a lot of
; variations of one and the same input that can be used in further
; reasoning and thus aids the creation of "areas of knowledge".
(defun proto-hierarchise (chosen carinputlist inputlist resultlist)
(if (null inputlist) (reverse resultlist)
(if (equalp chosen (cons carinputlist (car inputlist)))
(proto-hierarchise chosen (car inputlist) (cdr inputlist) (cons chosen (cdr resultlist)))
(proto-hierarchise chosen (car inputlist) (cdr inputlist) (cons (car inputlist) resultlist)))))
(defun hierarchise (chosen inputlist)
(if (null inputlist) '()
(proto-hierarchise chosen (car inputlist) (cdr inputlist) (list (car inputlist)))))
; (hierarchise '(a . b) '(a b c d a b c d a b))
; --> ((A . B) C D (A . B) C D (A . B))
; (hierarchise '((a . b) . c) (hierarchise '(a . b) '(a b c d a b c d a b)))
; --> (((A . B) . C) D ((A . B) . C) D (A . B))
; (hierarchise '(b . c) '(a b c a b d a b e o))
; --> (A (B . C) A B D A B E O)
; The above function is used in the tri-hier function defined below.
; If input is re-hierarchised after being only partially shifted, i.e.
; if input history is partially "re-considered", that creates multiple
; hierarchisation peaks and contributes to "areas of knowledge" as well
; as giving the system "multiple points of view" on the same "matter".
; ======== THIS MODIFICATION TO SPLITFUSE CAN WORK WITH ANALOGIES ========
; The next function is where a plan is prepared for output. Its
; hierarchy is flattened and the list of sub-atoms constitutes the
; answer. - This function is later used in planning.
(defun proto-splitfuse (pairtree resultlist)
(if (not (consp pairtree)) (reverse (cons pairtree resultlist))
(if (not (consp (car pairtree)))
(proto-splitfuse (cdr pairtree) (cons (car pairtree) resultlist))
(proto-splitfuse (cons (caar pairtree) (cons (cdar pairtree) (cdr pairtree))) resultlist))))
; sample calls:
; (proto-splitfuse '(((a (b . c) d . e) . f) g . h) '()) --> (A B C D E F G H)
; (proto-splitfuse '(a . b) '()) --> (A B)
; (proto-splitfuse 'a '()) --> (A)
(defun elimnil (somelist resultlist)
(if (null somelist) resultlist
(if (equal NIL (car somelist))
(elimnil (cddr somelist) resultlist)
(elimnil (cdr somelist) (cons (car somelist) resultlist)))))
(defun splitfuse (pairtree) (elimnil (reverse (proto-splitfuse pairtree '())) '()))
; sample calls - first pure vic, second with anas:
; (splitfuse '(((a (b . c) d . e) . f) g . h)) --> (A B C D E F G H)
; (splitfuse '(((a (b c) d e) . f) g . h)) --> (A B D F G H)
; The next function tries to find a plan as the continuation of the
; present. If the hierarchy has no right neighbour, it is decomposed.
; Then again it is checked whether the right-most part has a right
; neighbour in the list of all atoms, until such right neighbour is
; found - it is this right neighbour that consititutes the plan:
(defun proto-findplan (initialpair listofallatoms original-listofallatoms)
(if (and (null listofallatoms) (consp initialpair))
(proto-findplan (cdr initialpair) original-listofallatoms original-listofallatoms)
(if (null listofallatoms) NIL
(if (and (consp (car listofallatoms))
(or (and (consp initialpair) (equal (cdr initialpair) (caar listofallatoms)))
(equal initialpair (caar listofallatoms))))
(splitfuse (cdar listofallatoms))
(proto-findplan initialpair (cdr listofallatoms) original-listofallatoms)))))
(defun findplan (initialpair listofallatoms) (proto-findplan initialpair listofallatoms listofallatoms))
; sample calls:
; (findplan '(x . a) '((r . s) (s . t) (t . u) (u . a) (a . v) (a . w) (u . v))) --> (V)
; (findplan '(y x . a) '((r . s) (s . t) (t . u) (u . a) (a v . w) (a . w) (u . v))) --> (V W)
; debugging version, delivering not a plan, but the problematic
; listofallatoms:
; (defun tri-hier (inputlist listofallatoms)
; (progn (princ "inputlist: ") (princ inputlist) (terpri) (terpri)
; (princ "listofallatoms: ") (princ listofallatoms) (terpri)
; (princ "length of listofallatoms: ") (princ (length listofallatoms)) (terpri) (terpri)
; (if (equal? 1 (length inputlist)) (findplan inputlist listofallatoms) ; (cons inputlist listofallatoms)
; (let ((tri-knowledge (compare-tri inputlist listofallatoms)))
; (tri-hier (hierarchise (cadr tri-knowledge) inputlist) (cdr tri-knowledge))))))
; Now it is time to "triangulate and hierarchise", i.e. combining
; the previous functions into a challenge-response package. The answer
; of that function contains both the string of the plan and a changed
; version of the list of all atoms (changes according to reasoning).
(defun tri-hier (inputlist listofallatoms)
(if (equal 1 (length inputlist)) (cons (findplan (car inputlist) listofallatoms) listofallatoms) ; inputlist
(let ((tri-knowledge (compare-tri inputlist listofallatoms)))
(tri-hier (hierarchise (cadr tri-knowledge) inputlist) (cdr tri-knowledge)))))
; sample call:
; (tri-hier '(a b c a b e) '((e n o p . q) (f . g)
; (a . b) (b . x) (g . h) (b . y) (a . y) (b . z) (z . a)
; (b . h) (a . h) (c . i) (c . j) (k . b) (k . c) (l . b)
; (l . c) (m . b) (m . c) (b . i) (b . j) (d . b) (n . b)))
; previously in Scheme:
; --> ((n o p q) ((a . b) c (a . b) . e) ((a . b) . e) (c (a . b) . e)
; (c . i) (e n o p . q) (a . b) (b . x) (a . x) (b . y) (a . y) (f . g)
; (g . h) (z . a) (b . h) (a . h) (c . j) (k . b) (k . c) (l . b)
; (l . c) (m . b) (m . c) (b . i))
; now in Lisp:
; ((N O P Q) ((A B . C) A B . E) (A B . C) (A B . E)
; (A . B) (A . Y) (B . C) (Z . A) (B . E) (E N O P . Q)
; (F . G) (B . X) (B . Y) (B . Z) (G . H) (B . H) (K . B) (K . C) (L . B)
; (L . C) (C . I) (B . I) (M . B) (M . C))
; ---- EXPERIMENTAL STAGE: MAKE IT "LEARN A TEXT", THEN TALK ABOUT IT!
; defun a global list of all atoms, "empty" for now
(defun proto-protolist (x resultlist)
(if (zerop x) resultlist ; no need to reverse, it is nonsense anyway
(proto-protolist (- x 1) (cons '(nihil . nihil) resultlist))))
; THUNK: The below function defuns the list of all atoms according to
; the globally set variable knowledgesize.
; (defun protolist (proto-protolist 65000 '())) ; a first experiment with 65k atoms.
(defvar protolist (proto-protolist knowledgesize '()))
; This is where you require the "filling" of the knowledge base before
; even "elementary" teaching;
; this also determines the length of the list of all atoms.
; For interactive input, always the last N atoms will be reasoned on:
(defun proto-takelastn (counter somelist resultlist)
(if (or (zerop counter) (null somelist)) resultlist
(proto-takelastn (- counter 1) (cdr somelist) (cons (car somelist) resultlist))))
; OPERATION SLEDGE:
; It is possible that repeated hierarchisations uncover formerly
; unknown combination possibilities - this is why the input should be
; re-considered to a certain history length, and moreover, each chunk
; of history should be considered several times. This is implemented
; below. takelastn determines how much of the history is to be re-
; considered while re-slider defines the re-consideration of history.
(defun takelastn (counter somelist) (proto-takelastn counter (reverse somelist) '()))
; sample call:
; (takelastn 3 '(a b c d e f)) --> (d e f)
(defun re-slider (howoften inputlist listofallatoms)
(if (zerop howoften) (tri-hier inputlist listofallatoms)
(re-slider (- howoften 1) inputlist (cdr (tri-hier inputlist listofallatoms)))))
; END OF OPERATION SLEDGE.
(defvar mainlist '())
(defvar maininput '())
(defvar tempmain '())
(defvar newinput '())
; This function is used to "learn" an input list - without generating
; a reply, i.e. only the list of all atoms is changed. This is used
; for pre-setting knowledge into the system.
(defun learn (inputlist listofallatoms)
(if (equal 1 (length inputlist)) listofallatoms ; (cons (findplan (car inputlist) listofallatoms) listofallatoms)
(let ((tri-knowledge (compare-tri inputlist listofallatoms)))
(learn (hierarchise (cadr tri-knowledge) inputlist) (cdr tri-knowledge)))))
(defun recursivelearn (listofinputlists listofallatoms)
(if (null listofinputlists) (setq mainlist listofallatoms)
(recursivelearn (cdr listofinputlists) (learn (car listofinputlists) listofallatoms))))
; This is where the actual pre-learning takes place:
; (recursivelearn initlist protolist)
; (setq rootlist '()) ; free memory of the rootlist after pre-learning.
; make sure the history of past input is within limits:
(defun proto-takefirstn (counter x resultlist)
(if (or (zerop counter) (null x)) (reverse resultlist)
(proto-takefirstn (- counter 1) (cdr x) (cons (car x) resultlist))))
(defun takefirstn (howmany x) (proto-takefirstn howmany x '()))
; sample call:
; (takefirstn 3 '(a b c d e f)) --> (a b c)
; (takefirstn 3 '(a b)) --> (a b)
; this function tests whether each element of the first list
; can be found in the second list. I shall use this to
; determine whether the machine is able to be used for a specific
; input or whether such input would be unknown to it.
(defun allinsecond (firstlist secondlist)
(if (null firstlist) T
(if (null (member (car firstlist) secondlist)) NIL
(allinsecond (cdr firstlist) secondlist))))
; sample calls:
; (allinsecond '(a b a c a) '(a b c)) --> T
; (allinsecond '(a b x c a) '(a b c)) --> NIL
; THIS IS A THUNK.
; It updates the past input history for future calls.
(defun mergehistory (newinput knownhistory)
(takefirstn historylength (append newinput knownhistory)))
(defun shallitrun (readinsist newinput knownhistory)
(if (equal readinsist '(DORUN)) T
(allinsecond newinput knownhistory)))
; setup instincts - "must have" in reality, but
; neither the Scheme version nor the Fortran version have them.
(defun word-instinct (word)
(cond ((equal word 'I) 'YOU)
((equal word 'ME) 'YOU)
((equal word 'YOU) 'ME)
((equal word 'AM) 'ARE)
((equal word 'ARE) 'AM-ARE)
((equal word 'MINE) 'YOURS)
((equal word 'YOURS) 'MINE)
((equal word 'MY) 'YOUR)
((equal word 'YOUR) 'MY)
((equal word 'MYSELF) 'YOURSELF)
((equal word 'YOURSELF) 'MYSELF)
((equal word 'WAS) 'WAS-WERE)
(T word)))
(defun proto-apply-instincts (sentence checked-sentence)
(cond ((null sentence)
(reverse checked-sentence))
(T
(proto-apply-instincts
(cdr sentence)
(cons (word-instinct (car sentence)) checked-sentence)))))
(defun apply-instincts (sentence)
(proto-apply-instincts sentence '()))
; sample call: (apply-instincts '(I WAS HERE TODAY))
; --> (YOU WAS-WERE HERE TODAY)
; The below functions handle batch interaction of the system.
(defvar mainlist '())
(defvar maininput '())
(defvar inputhistory '())
(defvar insistence '())
; The list of input is placed into swarminput.txt,
; the list of all atoms should be in swarmdata.txt,
; and the answer is to be received in swarmoutput.txt.
; swarminsistence tries to find out whether reasoning
; should take place "anyway" (otherwise it will only
; take place if the input can be found in the history)
; for this, insistence must be set to "(DORUN)".
; It is the OS' responsibility to clean up the insistence,
; clean up the input, and handle and clean up the output.
(defun head ()
(progn
; (print "reading swarmdata.txt")
(with-open-file (stream "swarmdata.txt")
(setq mainlist (read stream)))
; (print "reading swarminput.txt")
(with-open-file (stream "swarminput.txt")
(setq maininput (apply-instincts (read stream))))
; (print "reading swarminsistence.txt")
(with-open-file (stream "swarminsistence.txt")
(setq insistence (read stream)))
; (print "reading swarmhistory.txt")
; (setq inputhistory '())
(with-open-file (stream "swarmhistory.txt")
(setq inputhistory (apply-instincts (read stream))))
; (print "going for trihier")
(if (null (shallitrun insistence maininput inputhistory)) (quit) ; "then do nothing", else:
(let ((trihier (re-slider re-slide-count maininput mainlist)))
(progn
; (print "reading swarmdata.txt")
(with-open-file (stream "swarmdata.txt" :direction :output :if-exists :supersede)
(format stream (write-to-string (cdr trihier))))
; (print "reading swarmoutput.txt")
(with-open-file (stream "swarmoutput.txt" :direction :output :if-exists :supersede)
(format stream (write-to-string (car trihier))))
; (print "reading swarmhistory.txt")
(with-open-file (stream "swarmhistory.txt" :direction :output :if-exists :supersede)
(format stream (write-to-string (mergehistory maininput inputhistory))))
(quit))))))
; fire up the whole exchange:
; (head) ; Lisp with parentheses, Scheme without parentheses.
(head)
; (quit)
; TO SUM IT UP:
; THE SYSTEM WILL FIRE IF THE INPUT LIST'S ELEMENTAS ARE ALL KNOWN,
; OTHERWISE IT WILL NOT FIRE. THIS CAN BE OVERRIDDEN BY PLACING
; "(DORUN)" IN swarminsistence.txt - THEN THE SYSTEM ALSO RUNS IF THE
; INPUT LIST'S ELEMENTS ARE NOT ALL KNOWN. (OBVIOUSLY, IT THEN CREATES
; NEW ELEMENTS AND COULD RUN ON THAT SAME INPUT AGAIN, EVEN WITHOUT
; (DORUN), BECAUSE NOW IT BECOMES KNOWN INPUT).
| 76,336 | Common Lisp | .lisp | 1,100 | 65.562727 | 213 | 0.649488 | KedalionDaimon/larvarum-computationis-examen-iii | 3 | 1 | 0 | AGPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 7115eeacb6f3e60efcd14a5edcf209dae224a7df855fdbc38a16d74b8d55a2ee | 18,908 | [
-1
] |
18,909 | parsefiles20160227_quit.lisp | KedalionDaimon_larvarum-computationis-examen-iii/parsefiles20160227_quit.lisp | ; THIS IS FAILING SO FAR.
; NOT ALL HAS BEEN PORTED, EITHER.
; I HAVE NO NUMBER->STRING FUNCTION!
; MAKE THE SCM-SIGNAL-BLAH UPPERCASE!
; This file parser is very similar to what I have in LarCom A.
; It will always parse files in both directions - from input and to plan,
; at once.
; USAGE:
; SET THE USER INPUT INTO usertoswarm.txt
; (You might actually just set there "cat input | tail -afewlines", to limit input
; length, thought that is not necessary, as each swarm insect will do that anyway.)
; It will then create out of this mutin.txt, containing the input as machine list.
; SET THE MACHINE OUTPUT INTO mutout.txt
; It will then translate the machine output into user-presentable input in
; swarmtouser.txt. This you may show again to the user.
; ORIGINALLY EMPTY are therefore mutin.txt and swarmtouser.txt.
; usertoswarm.txt: the (original) list of input from the outer world
; mutin.txt: the (targeted) list of input for the swarm
; mutout.txt: the (original) list of output by the swarm
; swarmtouser.txt: the (targeted) list of input to the outer world.
; +---------------------------------------------------+
; | Parse a String to Symbols and Symbols to a String |
; +---------------------------------------------------+
(defun string->number (somenumber) (read-from-string somenumber))
(defun number->string (somenumber) (write-to-string somenumber))
(defun string->list (somestring) (concatenate 'list (string-upcase somestring)))
; sample call:
; (string->list "this is a string")
; --> (#\T #\H #\I #\S #\ #\I #\S #\ #\A #\ #\S #\T #\R #\I #\N #\G)
(defun list->string (characterlist) (string-upcase (concatenate 'string characterlist)))
; sample call:
; (list->string '(#\t #\h #\e #\s #\e #\ #\c #\h #\a #\r #\a #\c #\t #\e #\r #\s))
; --> "THESE CHARACTERS"
(defun symbol->string (somesymbol) (string-upcase (string somesymbol)))
; sample call:
; (symbol->string 'hello) --> "HELLO"
(defun string->symbol (somestring) (intern (string-upcase somestring)))
; sample call:
; (string->symbol "hello")
;
; --> HELLO
; :INTERNAL
; HOWEVER, SO FAR IT IS VALID ONLY FOR TWO STRINGS, NOT MORE:
(defun string-append (firststring secondstring) (concatenate 'string firststring secondstring))
; sample call:
; (string-append "abc" "def") --> "abcdef"
; The parts from this one on have actually not much to do with
; reasoning. They merely concern the technicalities of file I/O.
; Note only the final part that actually concerns activating
; file input into the system.
; THIS SEEMS TO WORK:
(defun chartester (somecharacter)
(cond
((equal somecharacter #\A) somecharacter)
((equal somecharacter #\B) somecharacter)
((equal somecharacter #\C) somecharacter)
((equal somecharacter #\D) somecharacter)
((equal somecharacter #\E) somecharacter)
((equal somecharacter #\F) somecharacter)
((equal somecharacter #\G) somecharacter)
((equal somecharacter #\H) somecharacter)
((equal somecharacter #\I) somecharacter)
((equal somecharacter #\J) somecharacter)
((equal somecharacter #\K) somecharacter)
((equal somecharacter #\L) somecharacter)
((equal somecharacter #\M) somecharacter)
((equal somecharacter #\N) somecharacter)
((equal somecharacter #\O) somecharacter)
((equal somecharacter #\P) somecharacter)
((equal somecharacter #\Q) somecharacter)
((equal somecharacter #\R) somecharacter)
((equal somecharacter #\S) somecharacter)
((equal somecharacter #\T) somecharacter)
((equal somecharacter #\U) somecharacter)
((equal somecharacter #\V) somecharacter)
((equal somecharacter #\W) somecharacter)
((equal somecharacter #\X) somecharacter)
((equal somecharacter #\Y) somecharacter)
((equal somecharacter #\Z) somecharacter)
((equal somecharacter #\a) #\A) ; symbols are matched in caps
((equal somecharacter #\b) #\B)
((equal somecharacter #\c) #\C)
((equal somecharacter #\d) #\D)
((equal somecharacter #\e) #\E)
((equal somecharacter #\f) #\F)
((equal somecharacter #\g) #\G)
((equal somecharacter #\h) #\H)
((equal somecharacter #\i) #\I)
((equal somecharacter #\j) #\J)
((equal somecharacter #\k) #\K)
((equal somecharacter #\l) #\L)
((equal somecharacter #\m) #\M)
((equal somecharacter #\n) #\N)
((equal somecharacter #\o) #\O)
((equal somecharacter #\p) #\P)
((equal somecharacter #\q) #\Q)
((equal somecharacter #\r) #\R)
((equal somecharacter #\s) #\S)
((equal somecharacter #\t) #\T)
((equal somecharacter #\u) #\U)
((equal somecharacter #\v) #\V)
((equal somecharacter #\w) #\W)
((equal somecharacter #\x) #\X)
((equal somecharacter #\y) #\Y)
((equal somecharacter #\z) #\Z)
((equal somecharacter #\0) somecharacter)
((equal somecharacter #\1) somecharacter)
((equal somecharacter #\2) somecharacter)
((equal somecharacter #\3) somecharacter)
((equal somecharacter #\4) somecharacter)
((equal somecharacter #\5) somecharacter)
((equal somecharacter #\6) somecharacter)
((equal somecharacter #\7) somecharacter)
((equal somecharacter #\8) somecharacter)
((equal somecharacter #\9) somecharacter)
((equal somecharacter #\.) '(scm-signal-dot))
((equal somecharacter #\,) '(scm-signal-comma))
((equal somecharacter #\!) '(scm-signal-bang))
((equal somecharacter #\?) '(scm-signal-question))
((equal somecharacter #\:) '(scm-signal-colon))
((equal somecharacter #\;) '(scm-signal-semicolon))
((equal somecharacter #\-) '(scm-signal-dash))
((equal somecharacter #\") '(scm-signal-quote)) ; due to syntax highlighting: "
((equal somecharacter #\') '(scm-signal-singlequote))
((equal somecharacter #\+) '(scm-signal-plus))
((equal somecharacter #\*) '(scm-signal-asterisk))
((equal somecharacter #\/) '(scm-signal-divide))
((equal somecharacter #\\) '(scm-signal-backslash))
((equal somecharacter #\$) '(scm-signal-dollar))
((equal somecharacter #\() '(scm-signal-openpar))
((equal somecharacter #\)) '(scm-signal-closepar))
((equal somecharacter #\[) '(scm-signal-opensqpar))
((equal somecharacter #\]) '(scm-signal-closesqpar))
((equal somecharacter #\_) '(scm-signal-underscore))
((equal somecharacter #\#) '(scm-signal-hash))
((equal somecharacter #\%) '(scm-signal-percent))
((equal somecharacter #\~) '(scm-signal-tilde))
((equal somecharacter #\&) '(scm-signal-and))
((equal somecharacter #\>) '(scm-signal-biggerthan))
((equal somecharacter #\<) '(scm-signal-smallerthan))
((equal somecharacter #\|) '(scm-signal-pipe))
((equal somecharacter #\^) '(scm-signal-powerof))
((equal somecharacter #\=) '(scm-signal-equal))
((equal somecharacter #\{) '(scm-signal-openshpar))
((equal somecharacter #\}) '(scm-signal-closeshpar))
((equal somecharacter #\newline) '(scm-signal-newline))
((equal somecharacter #\space) '()) ; spaces and tabs are ignored.
; ((equal? somecharacter (car (string->list " "))) '()) ; #'\t' works for jscheme, but not for kawa; and jscheme does not like #\tab, apparently.
(T '(scm-signal-othercharacter))))
; NUMBER->STRING IS SO FAR UNTESTED
; THIS SEEMS TO WORK:
(defun proto-parsesym (mysymlist resultstring)
(if (or (not (listp mysymlist)) (null mysymlist)) resultstring
(let ((nextsymbol (car mysymlist)))
(cond ; tab and space not contained in this listing
((equal nextsymbol 'scm-signal-dot) (proto-parsesym (cdr mysymlist) (string-append resultstring (string #\.))))
((equal nextsymbol 'scm-signal-comma) (proto-parsesym (cdr mysymlist) (string-append resultstring (string #\,))))
((equal nextsymbol 'scm-signal-bang) (proto-parsesym (cdr mysymlist) (string-append resultstring (string #\!))))
((equal nextsymbol 'scm-signal-question) (proto-parsesym (cdr mysymlist) (string-append resultstring (string #\?))))
((equal nextsymbol 'scm-signal-colon) (proto-parsesym (cdr mysymlist) (string-append resultstring (string #\:))))
((equal nextsymbol 'scm-signal-semicolon) (proto-parsesym (cdr mysymlist) (string-append resultstring (string #\;))))
((equal nextsymbol 'scm-signal-dash) (proto-parsesym (cdr mysymlist) (string-append resultstring (string #\-))))
((equal nextsymbol 'scm-signal-quote) (proto-parsesym (cdr mysymlist) (string-append resultstring (string #\")))) ; due to syntax highlighting: "
((equal nextsymbol 'scm-signal-singlequote) (proto-parsesym (cdr mysymlist) (string-append resultstring (string #\'))))
((equal nextsymbol 'scm-signal-plus) (proto-parsesym (cdr mysymlist) (string-append resultstring (string #\+))))
((equal nextsymbol 'scm-signal-asterisk) (proto-parsesym (cdr mysymlist) (string-append resultstring (string #\*))))
((equal nextsymbol 'scm-signal-divide) (proto-parsesym (cdr mysymlist) (string-append resultstring (string #\/))))
((equal nextsymbol 'scm-signal-backslash) (proto-parsesym (cdr mysymlist) (string-append resultstring (string #\\))))
((equal nextsymbol 'scm-signal-dollar) (proto-parsesym (cdr mysymlist) (string-append resultstring (string #\$))))
((equal nextsymbol 'scm-signal-openpar) (proto-parsesym (cdr mysymlist) (string-append resultstring (string #\())))
((equal nextsymbol 'scm-signal-closepar) (proto-parsesym (cdr mysymlist) (string-append resultstring (string #\)))))
((equal nextsymbol 'scm-signal-opensqpar) (proto-parsesym (cdr mysymlist) (string-append resultstring (string #\[))))
((equal nextsymbol 'scm-signal-closesqpar) (proto-parsesym (cdr mysymlist) (string-append resultstring (string #\]))))
((equal nextsymbol 'scm-signal-underscore) (proto-parsesym (cdr mysymlist) (string-append resultstring (string #\_))))
((equal nextsymbol 'scm-signal-hash) (proto-parsesym (cdr mysymlist) (string-append resultstring (string #\#))))
((equal nextsymbol 'scm-signal-percent) (proto-parsesym (cdr mysymlist) (string-append resultstring (string #\%))))
((equal nextsymbol 'scm-signal-tilde) (proto-parsesym (cdr mysymlist) (string-append resultstring (string #\~))))
((equal nextsymbol 'scm-signal-and) (proto-parsesym (cdr mysymlist) (string-append resultstring (string #\&))))
((equal nextsymbol 'scm-signal-biggerthan) (proto-parsesym (cdr mysymlist) (string-append resultstring (string #\>))))
((equal nextsymbol 'scm-signal-smallerthan) (proto-parsesym (cdr mysymlist) (string-append resultstring (string #\<))))
((equal nextsymbol 'scm-signal-pipe) (proto-parsesym (cdr mysymlist) (string-append resultstring (string #\|))))
((equal nextsymbol 'scm-signal-powerof) (proto-parsesym (cdr mysymlist) (string-append resultstring (string #\^))))
((equal nextsymbol 'scm-signal-equal) (proto-parsesym (cdr mysymlist) (string-append resultstring (string #\=))))
((equal nextsymbol 'scm-signal-openshpar) (proto-parsesym (cdr mysymlist) (string-append resultstring (string #\{))))
((equal nextsymbol 'scm-signal-closeshpar) (proto-parsesym (cdr mysymlist) (string-append resultstring (string #\}))))
((equal nextsymbol 'scm-signal-newline) (proto-parsesym (cdr mysymlist) (string-append resultstring (string #\newline))))
((equal nextsymbol 'scm-signal-othercharacter) (proto-parsesym (cdr mysymlist) (string-append resultstring (string #\_)))) ; underscore for unknown characters
(T (proto-parsesym (cdr mysymlist) (string-append (string-append resultstring " ")
(if (symbolp nextsymbol) (symbol->string nextsymbol) (number->string nextsymbol))))))))) ; always append a space
; sample call:
; (proto-parsesym '(A LIST OF SYMS) "") --> " A LIST OF SYMS"
; Your system is reading a input "string", but actually, it shall operate on symbols.
; Moreover, in order to output an answer, it will again need to turn symbols to a string.
; THIS WORKS:
(defun proto-parsechars (listofchars currentwordlist resultlist)
(if (null listofchars) ; then, IF we DO NOT have a word, give the result:
(if (null currentwordlist) resultlist ; or else append the word:
(append resultlist (list (string->symbol (list->string currentwordlist)))))
(let ((chart (chartester (car listofchars))))
(if (listp chart) ; then terminate the word:
(proto-parsechars (cdr listofchars) NIL
(append resultlist
(if (null currentwordlist) NIL (list (string->symbol (list->string currentwordlist))))
chart)) ; else just extend the word:
(proto-parsechars (cdr listofchars)
(append currentwordlist (list chart))
resultlist)))))
(defun parsestringtosym (mystring) (proto-parsechars (string->list mystring) '() '()))
(defun parsesymtostring (mysymlist) (proto-parsesym mysymlist ""))
; sample call:
; (parsesymtostring (parsestringtosym "Hey, this is a test!")) --> " HEY, THIS IS A TEST!" ; WORKS
; +-------------------------------+
; | Read from and Write to a File |
; +-------------------------------+
; The READING part:
(defun attachnewline (somestring) (string-append somestring (string #\newline)))
(defun slowstrappend (mylistofstrings resultstring)
(if (null mylistofstrings) resultstring
(slowstrappend (cdr mylistofstrings) (string-append resultstring (car mylistofstrings)))))
; sample call: (slowstrappend '("la" "li" "lu") "") --> "lalilu"
(defvar *readresult* '())
; this global variable will contain the file that has been read.
(defun proto-readfile (filenameasstring)
(with-open-file (stream filenameasstring)
(do ((line (read-line stream nil)
(read-line stream nil)))
((null line))
(setq *readresult* (cons line *readresult*)))))
(defun readfile (filenameasstring)
(progn
(setq *readresult* '())
(proto-readfile filenameasstring)
(string->list (slowstrappend (mapcar #'attachnewline (reverse *readresult*)) ""))))
; (defvar redfil "")
; (seq! redfil (readfile "somefile.txt"))
; sample call:
; (print redfil) ; The file is displayed as it is read into chars.
; The WRITING part:
; (defvar outputf "schemwrite.txt")
(defun writereport (filenameasstring mystring)
(with-open-file (stream filenameasstring :direction :output :if-exists :supersede)
(format stream mystring))) ; You cannot use print or princ here.
; sample call:
; (writereport outputf "This is some funny text. I want to see it written.")
; +--------------------------------------+
; | Write to and Read from a File a List |
; +--------------------------------------+
(defvar *inlist* '())
(defun readlist (filenameasstring)
(with-open-file (stream filenameasstring)
(setq *inlist* (read stream))))
; sample call:
; (readlist "somelist.txt") --> inlist becomes '(A B C D E F G)
(defun writelist (filenameasstring mylist)
(with-open-file (stream filenameasstring :direction :output :if-exists :supersede)
(format stream (write-to-string mylist)))) ; You cannot use print or princ here.
; sample call:
; (writelist "some-bogus.txt" '(THIS IS A LIST))
; +---------------------------+
; | Specification of File I/O |
; +---------------------------+
; Define the files and symbol lists to be used:
(defvar userinput "./usertoswarm.txt")
(defvar useroutput "./swarmtouser.txt")
(defvar INPUTSYMBOLS '())
(defvar OUTPUTSYMBOLS '())
; Read the user input:
(defun giveuserinput ()
(progn
(setq INPUTSYMBOLS (parsestringtosym (list->string (readfile userinput))))
INPUTSYMBOLS))
; Answer with output to the user:
(defun senduseroutput (OUTPUTSYMBOLS)
(progn
(writereport useroutput (parsesymtostring OUTPUTSYMBOLS))
(setq OUTPUTSYMBOLS '())))
; sample call - this translates correctly the infile to the outfile:
; (senduseroutput giveuserinput)
(defun parsehead ()
(progn
(giveuserinput)
; (writelist "mutin.txt" INPUTSYMBOLS) ; Now the system has the input.
; THE ABOVE FALSELY PLANTS A NEWLINE AT THE END. THE BELOW DOES NOT.
(writelist "mutin.txt" (butlast INPUTSYMBOLS)) ; Now the system has the input.
(readlist "mutout.txt") ; Now *inlist* will contain the plan list.
(setq OUTPUTSYMBOLS *inlist*) ; Transfer *inlist* ready for output.
(senduseroutput OUTPUTSYMBOLS)
(quit))) ; Show the plan list to the user.
; (parsehead)
(parsehead)
; (quit)
| 15,897 | Common Lisp | .lisp | 291 | 51.938144 | 159 | 0.702015 | KedalionDaimon/larvarum-computationis-examen-iii | 3 | 1 | 0 | AGPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 4f9b3d322486a316c3da968e6f4046381b85fd028bc589be3ab36373682c0f22 | 18,909 | [
-1
] |
18,912 | soloqueen.sh | KedalionDaimon_larvarum-computationis-examen-iii/soloqueen.sh | #!/bin/bash
# The purpose of this program is to initialise a new swarm.
# It also determines the size of the swarm.
rm insects.txt 2> /dev/null
rm -r pupa* 2>/dev/null
# redirect errors to /dev/null
for i in {1..20} # say how many prototype insects you will want
do
echo $i >> insects.txt
mkdir ./pupa$i
cp ./swarmdata.txt ./swarmhistory.txt ./swarminsistence.txt ./swarminput.txt ./swarmoutput.txt ./pupa$i
cd ./pupa$i
ln ../examen ./examen
cd ..
chmod +x ./pupa$i/examen
done
| 498 | Common Lisp | .l | 16 | 28.875 | 105 | 0.714286 | KedalionDaimon/larvarum-computationis-examen-iii | 3 | 1 | 0 | AGPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | af9066eabe90d09096c6b30e25a38619e544b1578ef66c40deefcea2f4fb4e86 | 18,912 | [
-1
] |
18,914 | relink.sh | KedalionDaimon_larvarum-computationis-examen-iii/relink.sh | #!/bin/bash
# The purpose of this program is to re-link the swarm to a new version.
for i in {1..20} # say how many prototype insects you will want
do
rm ./pupa$i/examen
cd ./pupa$i
ln ../examen ./examen
cd ..
done
| 227 | Common Lisp | .l | 9 | 22.888889 | 71 | 0.696262 | KedalionDaimon/larvarum-computationis-examen-iii | 3 | 1 | 0 | AGPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | e618e6bf21d74379b613f4b12d280744bcfa4e5fa2bdf50027e4904e959d85fc | 18,914 | [
-1
] |
18,915 | overlord.sh | KedalionDaimon_larvarum-computationis-examen-iii/overlord.sh | #!/bin/bash
# activate with: rlwrap overlord.sh
# corrected ps-aux-check in memory
# EMPTY OUTPUT SHOULD ALSO NOT BE PARSED.
# EMPTY IS REALLY "", NOT JUST "()".
# TO-DO: THE TRANSMUTATIONS,
# AS WELL AS "READING" AND "WRITING".
# Assume input is in usertoswarm.txt and
# output is in swarmtouser.txt. Assume in
# transformed form they are mutin.txt and
# mutout.txt (for the undetaken "mutations").
echo " :: SYSTEM OPERATIONAL. ENTER AN EMPTY LINE TO TERMINATE. :: "
# Empty the main files that you will operate upon:
echo "pseudo-userinput" > usertoswarm.txt
echo "pseudo-useroutput" > swarmtouser.txt
echo "(pseudo-mutin)" > mutin.txt
echo "(pseudo-mutout)" > mutout.txt
emptyoutput=""
# MAIN I/O LOOP:
while (true)
do
# NOW THE INPUT SHOULD BE RECORDED, AND MUTIN IS TO BE SET.
# Record the input:
echo -n "READ: "
read usertoswarmvar
if [ "$usertoswarmvar" = "$emptyoutput" ]
then
echo " :: EMPTY INPUT. INTERACTION TERMINATED. :: "
exit
fi
# MAKE IT REGARD THE LAST MACHINE-HUMAN PAIR:
usertoswarmvar="$previousreply $usertoswarmvar"
echo $usertoswarmvar > usertoswarm.txt
# the below is just needed so the parser does not complain:
echo "(pseudo-mutout)" > mutout.txt
# Transform usertoswarm.txt into mutin.txt:
./parser
# (side effect: it also transfroms
# mutout.txt into swarmtouser.txt)
# Activate each insect of the swarm:
for i in `cat insects.txt` # i.e. insects in that order.
do
cp ./mutin.txt ./pupa$i/swarminput.txt
echo "" > ./pupa$i/swarmoutput.txt # TURN ON AGAIN PLAN CLOBBERING
echo "(NORUN)" > ./pupa$i/swarminsistence.txt # TURN ON AGAIN INSISTENCE CLOBBERING
cd ./pupa$i
./examen & # The BACKGROUND RUN is important!
cd ..
done
sleep 10 # Safety time buffer - to give swarm a chance to run.
# FOR THE ABOVE, I COULD SSH OUT.
# If swarm IS running:
# ps -e | grep swarm | wc -l SHOULD BE AT LEAST 1
# ps u | grep swarm | wc -l SHOULD BE AT LEAST 2.
# Check whether the swarm has landed again already.
# There seem to be "more civilized" ways to do this,
# either with "wait" or with "GNU/Parallel".
# But this one is very simple.
# Check whether some swarm element is still operating
# and wait for it to terminate
isitrunning=2
while [ $isitrunning != "1" ]
do
sleep 1
isitrunning=`ps aux | grep ' ./examen' | wc -l`
done
# FOR THE ABOVE, I COULD GET SSH INFO BACK.
# Now try to see which insect got the first plan:
sleep 2 # this delay is needed so the machines can write their data
# to disk - otherwise it forces the creation of a new machine.
foundplan="false"
planmatch=0
for i in `cat insects.txt` # i.e. insects in that order
do
insectoutput=`cat ./pupa$i/swarmoutput.txt| tr -d \n`
# The tr -d part can be commented out.
# echo "insectoutput = $insectoutput"
# echo "emptyouptput = $emptyoutput"
planmatch=$i
if [ "$insectoutput" != "$emptyoutput" ]
then
foundplan="true"
break
fi
done
# echo "foundplan = $foundplan" # THAT SHOULD NOT BE FALSE!!!
if [ "$foundplan" = "false" ]
then
cat ./pupa1/swarminput.txt | tr [:digit:] ' ' | tr [:punct:] ' ' | tr ' ' '\n' | egrep -v '^$' > eachword.txt
# No | sort | uniq, as I want a weighted sum for the words below: repeated words are more important.
mostwords=0
for i in `cat insects.txt` # i.e. insects in that order
do
foundmostwords=0
for j in `cat eachword.txt` # i.e. words
do
wordread=`grep $j ./pupa$i/swarmhistory.txt`
if [ "$wordread" != "" ]
then
foundmostwords=`expr $foundmostwords + 1`
fi
done
if [ $foundmostwords -gt $mostwords ]
then
mostwords=$foundmostwords
echo "MOST WORDS: $mostwords"
newest=$i
# planmatch=$i # that went a few lines down, differently.
unused=`tail -1 insects.txt`
# If the selected is the "last" used, then
# then the "new" last used is the next-to-last used.
if [ "$newest" = "$unused" ]
then
unused=`tail -2 insects.txt | head -1`
fi
planmatch=$unused
fi
done
if [ "$mostwords" = 0 ]
then
unused=`tail -1 insects.txt` # replace the oldest unused insect
newest=`head -1 insects.txt`
planmatch=$unused # We force the plan to match here.
fi
# DEACTIVATE THIS:
echo " :: FORCING CONSIDERATION WITH $unused EX $newest :: "
rm ./pupa$unused/swarmdata.txt
rm ./pupa$unused/swarmhistory.txt
rm ./pupa$unused/swarminput.txt
rm ./pupa$unused/swarmoutput.txt
cp ./pupa$newest/swarmdata.txt ./pupa$unused
cp ./pupa$newest/swarmhistory.txt ./pupa$unused
cp ./pupa$newest/swarminput.txt ./pupa$unused
cp ./pupa$newest/swarmoutput.txt ./pupa$unused
echo "(DORUN)" > ./pupa$unused/swarminsistence.txt
cd ./pupa$unused/
./examen
cd ..
echo "(NORUN)" > ./pupa$unused/swarminsistence.txt
foundplan="true"
fi
# Cycle the last activated insect:
cat insects.txt | grep -vx $planmatch > tempinsects.txt
echo $planmatch > insects.txt
cat tempinsects.txt >> insects.txt
echo -n " :: MATCHING MACHINE :: "
echo $planmatch
# Copy the plan to transformation:
cp ./pupa$planmatch/swarmoutput.txt ./mutout.txt
if test -s ./mutout.txt # file exists and is not empty
then
# the below is just needed so the parser does not complain:
echo "pseudo-userinput" > usertoswarm.txt
# Transform mutout.txt into swarmtouser.txt:
./parser
# (side effect: it also transfroms
# usertoswarm.txt into mutin.txt)
else
echo "" > swarmtouser.txt
fi
echo -n "REPLY: "
cat swarmtouser.txt
echo ""
# MAKE IT REGARD THE LAST MACHINE-HUMAN PAIR:
read previousreply < swarmtouser.txt
previousreply=`echo -n $previousreply | tr -d '\n'`
# END OF MAIN I/O LOOP:
done
| 5,624 | Common Lisp | .l | 168 | 30.720238 | 111 | 0.710687 | KedalionDaimon/larvarum-computationis-examen-iii | 3 | 1 | 0 | AGPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | cbf774715c8772ecd77569ec169d6aaaeb697988a0aef9fe7741cb64b9ba43f5 | 18,915 | [
-1
] |
18,930 | package.lisp | rotatef_esmtp-client/package.lisp | ;;;; esmtp-client
;;;;
;;;; Copyright (C) 2017 Thomas Bakketun <[email protected]>
;;;;
;;;; This 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.
;;;;
;;;; This 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 General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU General Public License
;;;; along with this library. If not, see <http://www.gnu.org/licenses/>.
(defpackage #:esmtp-client
(:nicknames #:esmtp)
(:use :common-lisp)
(:export
#:auth-for
#:auth-plain-message
#:client-error
#:data
#:data-end
#:data-bytes
#:data-line
#:data-start
#:extensionp
#:extensions
#:hello-greeting
#:greeting
#:mail-from
#:make-credentials
#:make-credentials-for
#:max-size
#:noop
#:permanent-error
#:protocol-error
#:register-auth-mechanism
#:rcpt-to
#:rset
#:send-command
#:string-to-utf8-base64
#:transient-error
#:with-session
))
| 1,334 | Common Lisp | .lisp | 47 | 25.510638 | 78 | 0.68818 | rotatef/esmtp-client | 3 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 10f925f13de60bca9a7af19cf6af9e5f03867e743f7ff48a3ac28db0ce599d43 | 18,930 | [
-1
] |
18,931 | auth-login.lisp | rotatef_esmtp-client/auth-login.lisp | ;;;; esmtp-client
;;;;
;;;; Copyright (C) 2017 Thomas Bakketun <[email protected]>
;;;;
;;;; This 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.
;;;;
;;;; This 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 General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU General Public License
;;;; along with this library. If not, see <http://www.gnu.org/licenses/>.
(in-package #:esmtp-client)
(defmethod make-credentials-for ((m (eql :login)) &key username password)
(lambda (stream phase)
(ecase phase
(:username (princ (string-to-utf8-base64 username) stream))
(:password (princ (string-to-utf8-base64 password) stream)))))
(defmethod auth-for ((m (eql :login)) credentials-fn)
(assert-secure-connection)
(send-command 334 "AUTH LOGIN")
(send-command 334 "" (lambda (stream)
(funcall credentials-fn stream :username)))
(send-command 235 "" (lambda (stream)
(funcall credentials-fn stream :password))))
(register-auth-mechanism :login :quality 0.5)
| 1,456 | Common Lisp | .lisp | 30 | 44.733333 | 78 | 0.69464 | rotatef/esmtp-client | 3 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 1f46f0a2494f5e3599f8a6a735376dfa41c31097b65a252bcf9bec00a8950d62 | 18,931 | [
-1
] |
18,932 | auth-xoauth2.lisp | rotatef_esmtp-client/auth-xoauth2.lisp | ;;;; esmtp-client
;;;;
;;;; Copyright (C) 2017 Thomas Bakketun <[email protected]>
;;;;
;;;; This 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.
;;;;
;;;; This 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 General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU General Public License
;;;; along with this library. If not, see <http://www.gnu.org/licenses/>.
(in-package #:esmtp-client)
(defmethod make-credentials-for ((m (eql :xoauth2)) &key))
(defmethod auth-for ((m (eql :xoauth2)) credentials-fn)
(assert-secure-connection)
(multiple-value-bind (code first-line)
(send-command '(235 334) "AUTH XOAUTH2 "
(lambda (stream)
(funcall credentials-fn stream)))
(when (eql code 334)
(error 'client-error :session *session*
:message (format nil "XOAUTH2: ~A" (base64:base64-string-to-string first-line))))))
(register-auth-mechanism :xoauth2)
| 1,365 | Common Lisp | .lisp | 28 | 44.285714 | 110 | 0.680963 | rotatef/esmtp-client | 3 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 639a9d367daa0633077f3f21b328324e1238b6662062fd69e70d9fecca082ebd | 18,932 | [
-1
] |
18,933 | auth-plain.lisp | rotatef_esmtp-client/auth-plain.lisp | ;;;; esmtp-client
;;;;
;;;; Copyright (C) 2017 Thomas Bakketun <[email protected]>
;;;;
;;;; This 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.
;;;;
;;;; This 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 General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU General Public License
;;;; along with this library. If not, see <http://www.gnu.org/licenses/>.
(in-package #:esmtp-client)
(defun auth-plain-message (username password)
(string-to-utf8-base64 (format nil "~A~C~A~C~A"
username
#\null
username
#\null
password)))
(defmethod make-credentials-for ((m (eql :plain)) &key username password)
(lambda (stream)
(princ (auth-plain-message username password) stream)))
(defmethod auth-for ((m (eql :plain)) credentials-fn)
(assert-secure-connection)
(send-command 235 "AUTH PLAIN " credentials-fn))
(register-auth-mechanism :plain :quality 1)
| 1,461 | Common Lisp | .lisp | 31 | 40.096774 | 78 | 0.64507 | rotatef/esmtp-client | 3 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 504fcb2949015e2ab4c5634f2b947a7e83ce19e7d7cd9da9dda080f001497dde | 18,933 | [
-1
] |
18,934 | package.lisp | rotatef_esmtp-client/tests/package.lisp | ;;;; esmtp-client
;;;;
;;;; Copyright (C) 2017 Thomas Bakketun <[email protected]>
;;;;
;;;; This 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.
;;;;
;;;; This 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 General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU General Public License
;;;; along with this library. If not, see <http://www.gnu.org/licenses/>.
(defpackage #:esmtp-client-tests
(:use
:common-lisp)
(:export
:run
:travis-run))
| 882 | Common Lisp | .lisp | 22 | 38.454545 | 78 | 0.712456 | rotatef/esmtp-client | 3 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 5fbf7671c39c9f8688e76caf68b31f7c11c011aa5bc70178c48176fed2820616 | 18,934 | [
-1
] |
18,935 | tests.lisp | rotatef_esmtp-client/tests/tests.lisp | ;;;; esmtp-client
;;;;
;;;; Copyright (C) 2017 Thomas Bakketun <[email protected]>
;;;;
;;;; This 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.
;;;;
;;;; This 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 General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU General Public License
;;;; along with this library. If not, see <http://www.gnu.org/licenses/>.
(in-package #:esmtp-client-tests)
(defun talk-to-test.smtp.org ()
(esmtp:with-session (list :host "test.smtp.org"
:cl+ssl-options '(:verify nil)
:credentials (esmtp:make-credentials :username "user16" :password "pass16")
:trace *trace-output*)
(esmtp:mail-from "[email protected]")
(esmtp:rcpt-to "bit-bucket")
(esmtp:data (flex:string-to-octets
"From: Me <[email protected]>
To: You <[email protected]>
Subject: Test
Hello World."))))
(defparameter *mailtrap.io-credentials*
;; All mail sent using these credentials are discarded by mailtrap.io.
;; Exposing them is unlikely to allow for any misuse.
(esmtp:make-credentials :username "479a48b137b928"
:password "3d7550496f7a14"))
(defun talk-to-mailtrap.io ()
(esmtp:with-session (list :host "smtp.mailtrap.io"
:port 2525
:credentials *mailtrap.io-credentials*
:trace *trace-output*)
(esmtp:mail-from "[email protected]")
(esmtp:rcpt-to "[email protected]")
(esmtp:data '("From: Me <[email protected]>"
"To: You <[email protected]>"
"Subject: Test"
""
"Hello World."))))
(defun talk-to-gmail.com ()
(esmtp:with-session (list :host "smtp.gmail.com"
:trace *trace-output*)
(esmtp:noop)
(esmtp:rset)
(format t "~&Verify reply: ~A" (esmtp:send-command 252 "VRFY postmaster"))
(format t "~&Initial greeting: ~A" (esmtp:greeting))
(format t "~&Hello greeting: ~A" (esmtp:hello-greeting))
(format t "~&Supported extentions: ~S" (esmtp:extensions))
(format t "~&Maximium message size: ~A" (esmtp:max-size))
(handler-case (esmtp:mail-from "[email protected]")
(esmtp:permanent-error (e)
(format t "~&======~&Got error as expected:~&~A~&======" e)))))
;; python -m smtpd -n -c DebuggingServer localhost:2525
(defun talk-to-local-python ()
(esmtp:with-session '(:host "localhost"
:port 2525
:trace t)
(esmtp:mail-from "[email protected]")
(esmtp:rcpt-to "[email protected]")
(esmtp:data '("From: Me <[email protected]>"
"To: You <[email protected]>"
"Subject: Test"
""
"Hello World."))))
(defun run ()
(talk-to-test.smtp.org)
(talk-to-mailtrap.io)
(talk-to-gmail.com))
(defun travis-run ()
(talk-to-mailtrap.io)
(talk-to-gmail.com))
| 3,394 | Common Lisp | .lisp | 78 | 35.269231 | 103 | 0.602121 | rotatef/esmtp-client | 3 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 89bd0fb71db8d3ea34b4948e9cd4f73f188189598a75565c405afc2ddc990205 | 18,935 | [
-1
] |
18,936 | package.lisp | rotatef_esmtp-client/cram-md5/package.lisp | ;;;; esmtp-client
;;;;
;;;; Copyright (C) 2017 Thomas Bakketun <[email protected]>
;;;;
;;;; This 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.
;;;;
;;;; This 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 General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU General Public License
;;;; along with this library. If not, see <http://www.gnu.org/licenses/>.
(defpackage #:esmtp-client-cram-md5
(:use :common-lisp)
(:export
#:auth-cram-md5-message))
| 886 | Common Lisp | .lisp | 20 | 42.9 | 78 | 0.716763 | rotatef/esmtp-client | 3 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | c3ec87f8c5e1fb27d0c86b93578eac6f4bbc92d21808978e76cb739312f8a8e1 | 18,936 | [
-1
] |
18,937 | cram-md5.lisp | rotatef_esmtp-client/cram-md5/cram-md5.lisp | ;;;; esmtp-client
;;;;
;;;; Copyright (C) 2017 Thomas Bakketun <[email protected]>
;;;;
;;;; This 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.
;;;;
;;;; This 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 General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU General Public License
;;;; along with this library. If not, see <http://www.gnu.org/licenses/>.
(in-package #:esmtp-client-cram-md5)
(defun auth-cram-md5-message (challenge username password)
(let* ((key (flex:string-to-octets password :external-format :utf-8))
(hmac (ironclad:make-hmac key :md5))
(digest (progn (ironclad:update-hmac hmac challenge)
(ironclad:byte-array-to-hex-string (ironclad:hmac-digest hmac))))
(response (format nil "~A ~A" username digest)))
(esmtp:string-to-utf8-base64 response)))
(defmethod esmtp:make-credentials-for ((m (eql :cram-md5)) &key username password)
(lambda (challenge)
(auth-cram-md5-message challenge username password)))
(defmethod esmtp:auth-for ((m (eql :cram-md5)) credentials-fn)
(let* ((challenge-base64 (esmtp:send-command 334 "AUTH CRAM-MD5"))
(challenge (base64:base64-string-to-usb8-array challenge-base64)))
(esmtp:send-command 235 "~A" (funcall credentials-fn challenge))))
(esmtp:register-auth-mechanism :cram-md5 :quality 1.5)
| 1,763 | Common Lisp | .lisp | 32 | 51.34375 | 89 | 0.708309 | rotatef/esmtp-client | 3 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | e9cfdcebba513fe38c602a21d8498ca449a963ef77466c03d075e44c169e2942 | 18,937 | [
-1
] |
18,938 | esmtp-client.asd | rotatef_esmtp-client/esmtp-client.asd | ;;;; esmtp-client
;;;;
;;;; Copyright (C) 2017 Thomas Bakketun <[email protected]>
;;;;
;;;; This 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.
;;;;
;;;; This 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 General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU General Public License
;;;; along with this library. If not, see <http://www.gnu.org/licenses/>.
(defsystem #:esmtp-client
:name "esmtp-client"
:licence "GNU Lesser General Public Licence 3.0"
:author "Thomas Bakketun <[email protected]>"
:description "A library for sending email via SMTP according to RFC 6409."
:depends-on (:cl-base64
:cl+ssl
:usocket)
:serial t
:components ((:file "package")
(:file "client")
(:file "auth-plain")
(:file "auth-login")
(:file "auth-xoauth2")))
| 1,286 | Common Lisp | .asd | 30 | 38.366667 | 78 | 0.668526 | rotatef/esmtp-client | 3 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 1a93f6016b6cfbee84363cb5b8a673eaa5357cc169d7499caeff12c4558c1b0c | 18,938 | [
-1
] |
18,939 | esmtp-client-tests.asd | rotatef_esmtp-client/tests/esmtp-client-tests.asd | ;;;; esmtp-client
;;;;
;;;; Copyright (C) 2017 Thomas Bakketun <[email protected]>
;;;;
;;;; This 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.
;;;;
;;;; This 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 General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU General Public License
;;;; along with this library. If not, see <http://www.gnu.org/licenses/>.
(defsystem #:esmtp-client-tests
:name "esmtp-client-tests"
:licence "GNU Lesser General Public Licence 3.0"
:author "Thomas Bakketun <[email protected]>"
:description "Tests for cl-stmp-submitter"
:depends-on (:esmtp-client-cram-md5)
:serial t
:components ((:file "package")
(:file "tests")))
| 1,120 | Common Lisp | .asd | 25 | 42.6 | 78 | 0.71298 | rotatef/esmtp-client | 3 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 7034d7f5bd05bf3abc625ab43847ab64b7681633ceffa890ebc7f4b67b5415a6 | 18,939 | [
-1
] |
18,940 | esmtp-client-cram-md5.asd | rotatef_esmtp-client/cram-md5/esmtp-client-cram-md5.asd | ;;;; esmtp-client
;;;;
;;;; Copyright (C) 2017 Thomas Bakketun <[email protected]>
;;;;
;;;; This 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.
;;;;
;;;; This 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 General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU General Public License
;;;; along with this library. If not, see <http://www.gnu.org/licenses/>.
(defsystem #:esmtp-client-cram-md5
:name "esmtp-client-cram-md5"
:licence "GNU Lesser General Public Licence 3.0"
:author "Thomas Bakketun <[email protected]>"
:description "CRAM-MD5 authentication mechanism for esmtp-client"
:depends-on (:esmtp-client
:cl-base64
:ironclad)
:serial t
:components ((:file "package")
(:file "cram-md5")))
| 1,194 | Common Lisp | .asd | 27 | 41 | 78 | 0.699828 | rotatef/esmtp-client | 3 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 9316679be48524809911e16d8d9d056b46b1dc71892f122a5a272d6aae1e8d23 | 18,940 | [
-1
] |
18,948 | .travis.yml | rotatef_esmtp-client/.travis.yml | language: lisp
sudo: required
branches:
only:
- master
env:
matrix:
- LISP=sbcl
install:
- curl -L https://github.com/luismbo/cl-travis/raw/master/install.sh | sh
script:
- cl -e "(ql:quickload :esmtp-client-tests) (esmtp-client-tests:travis-run)"
| 268 | Common Lisp | .l | 12 | 19.666667 | 78 | 0.718254 | rotatef/esmtp-client | 3 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 3e1cf29fe14503e36718d673672c544dc6803372fb0fd3f73cbb365fd9f9a559 | 18,948 | [
-1
] |
18,971 | package.lisp | WilmerLeal_dendron/package.lisp | ;;;; package.lisp
(defpackage #:dendron
(:use #:cl)
(:export :dendron
:pattern-equal
:first-child
:second-child
:distance
:dendronp
:pattern-set
:elements))
| 190 | Common Lisp | .lisp | 11 | 13.272727 | 21 | 0.634831 | WilmerLeal/dendron | 3 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 1ec1534c59d38b75012e56e42a483a1fd452032d2ab08bd58fbe99cbf51cc632 | 18,971 | [
-1
] |
18,972 | errors.lisp | WilmerLeal_dendron/errors.lisp | ;-*-Lisp-*-
;; Error conditions in dendron
(in-package :dendron)
;; (define-condition input-error ()
;; )
;; (define-condition no-reading-permission (input-error)
;; )
;; (define-condition input-file-does-not-exist (input-error)
;; )
;; (define-condition unknown-input-format (input-error)
;; )
;; (define-condition empty-leaf (input-error)
;; )
| 358 | Common Lisp | .lisp | 13 | 25.923077 | 60 | 0.700297 | WilmerLeal/dendron | 3 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 0a54ea4a9e01ca3581fae543da79209b589471943de907b1c0004a8af1db7391 | 18,972 | [
-1
] |
18,973 | example.lisp | WilmerLeal_dendron/example.lisp |
(in-package :dendron)
(defvar lista '(((a 1 b 1) 2 (c 3 d 3) 2) 4 (e 5 (f 6 (g 7 h 7) 6) 5) 4))
| 97 | Common Lisp | .lisp | 2 | 47 | 73 | 0.521277 | WilmerLeal/dendron | 3 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 0907ab92649fda497645a171231e8686cae68bc5dce8ba43bca2e8d5c9f5f4c2 | 18,973 | [
-1
] |
18,974 | dendron.lisp | WilmerLeal_dendron/dendron.lisp |
;;;; dendron.lisp
(in-package #:dendron)
(defun newick (lst)
(cond ((not (consp lst)) lst)
((= 4 (length lst))
(let (d1)
(destructuring-bind (fchild dist schild dist2) lst
(declare (ignore dist2))
(setf d1 (make-instance 'dendron
:first-child (newick fchild)
:second-child (newick schild)
:distance dist))
(setf (pattern-set d1)
(make-instance 'pattern-set
:elements (union (leaves (first-child d1))
(leaves (second-child d1))))))
(canonicalise d1)
d1))
(t
(error 'simple-error
:format-string "Unlabeled Newick format should have exactly 4 arguments:~%~a, but has ~d arguments~%"
:format-arguments (list lst (length lst))))))
(defun make-dendron (lst &key (format #'newick))
"Return a dendron from list."
(funcall format lst))
(defun make-dendrogram (lst &key (format #'newick))
"Return a dendrogram from list"
(enumerate (make-instance 'dendrogram :root (make-dendron lst :format format))))
(defmethod delete-leaves (leaves (ss pattern-set))
(make-instance 'pattern-set :elements
(set-difference (elements ss) leaves)))
(defmethod delete-leaves (leaves (dd dendron))
(let (d1)
(cond ((every #'(lambda (x) (not (belongp x dd))) leaves)
dd)
((every #'(lambda (x) (member x leaves)) (elements dd))
nil)
;; from now on, dd is not completely contained in leaves
((and (not (dendronp (first-child dd)))
(not (dendronp (second-child dd))))
(if (member (first-child dd) leaves)
(second-child dd)
(first-child dd)))
((not (dendronp (first-child dd)))
(cond ((member (first-child dd) leaves)
(delete-leaves leaves (second-child dd)))
((every #'(lambda (x) (member x leaves)) (elements (second-child dd)))
(first-child dd))
(t (setf d1 (make-instance 'dendron :first-child (first-child dd)
:second-child (delete-leaves leaves (second-child dd))
:pattern-set (delete-leaves leaves (pattern-set dd))))
(canonicalise d1)
d1)))
((not (dendronp (second-child dd)))
(cond ((member (second-child dd) leaves)
(delete-leaves leaves (first-child dd)))
((every #'(lambda (x) (member x leaves)) (elements (first-child dd)))
(second-child dd))
(t (setf d1 (make-instance 'dendron
:first-child (delete-leaves leaves (first-child dd))
:second-child (second-child dd)
:pattern-set (delete-leaves leaves (pattern-set dd))))
(canonicalise d1)
d1)))
((every #'(lambda (x) (member x leaves)) (elements (first-child dd)))
(delete-leaves leaves (second-child dd)))
((every #'(lambda (x) (member x leaves)) (elements (second-child dd)))
(delete-leaves leaves (first-child dd)))
(t
(setf d1 (make-instance 'dendron
:first-child (delete-leaves leaves (first-child dd))
:second-child (delete-leaves leaves (second-child dd))
:pattern-set (delete-leaves leaves (pattern-set dd))))
(canonicalise d1)
d1))))
;; Associate subdendrons to a given list of dendrons.
;; If a subdendron already exists in the list, its occurrence
;; and that of its children are incremented.
(defmethod assoc-subdendrons ((dd dendron))
(let ((d2 (find dd *dendrons* :test #'pattern-equal)))
(cond (d2
(mapden d2 #'(lambda (x) (incf (support x)))))
(t
(incf (support dd))
(lpush dd *dendrons*)
(cond ((not (dendronp (first-child dd))))
((not (dendronp (second-child dd)))
(assoc-subdendrons (first-child dd)))
(t
(assoc-subdendrons (first-child dd))
(assoc-subdendrons (second-child dd))))))))
(defmethod assoc-subdendrons ((dd dendrogram))
(assoc-subdendrons (root dd)))
;; Associate pattern-set of a given dendron
;; to a list of patterns. If any pattern belongs
;; to that list, its occurrence is incremented.
(defmethod assoc-pattern-sets ((dd dendron))
(let (val)
(dolist (den (subdendrons dd))
(setf val (find (pattern-set den) *pattern-sets* :test #'pattern-equal))
(cond (val
(setf (pattern-set den) val)
(incf (support (pattern-set den))))
(t
(incf (support (pattern-set den)))
(push (pattern-set den) *pattern-sets*))))))
(defmethod containedp ((s1 pattern-set) (s2 pattern-set))
(every #'(lambda (x) (member x (elements s2))) (elements s1)))
(defmethod containedp ((d1 dendron) (d2 dendron))
(some #'(lambda (x) (pattern-equal d1 x)) (subdendrons d2)))
(defmethod containedp ((ss pattern-set) (dd dendron))
(some #'(lambda (x) (pattern-equal ss x))
(mapcar #'pattern-set (subdendrons dd))))
(defmethod containedp ((dd dendron) (ss pattern-set))
(containedp (pattern-set dd) ss))
(defmethod containedp (leave (dd pattern))
(member leave (elements dd)))
(defmethod similarity ((d1 dendron) (d2 dendron))
(let* ((subd1 (subdendrons d1))
(subd2 (subdendrons d2))
(int (intersection subd1 subd2 :test #'pattern-equal)))
(values
(float (/ (length int)
(length (union subd1 subd2 :test #'pattern-equal))))
int)))
(defmethod similarity ((ss pattern-set) (pp pattern))
(let ((int (intersection (elements pp) (elements ss))))
(values (/ (length int)
(length (union (elements pp) (elements ss))) 1.0)
int)))
(defmethod similarity ((ss pattern-set) (dd dendron))
(similarity ss (pattern-set dd)))
(defmethod similarity ((dd dendron) (ss pattern-set))
(similarity ss (pattern-set dd)))
(defmethod max-similarity ((pp pattern) (dd dendrogram))
(let ((res (reduce #'(lambda (x y)
(if (> (car x) (car y)) x y))
(mapdendron (root dd)
#'(lambda (x)
(multiple-value-bind (val int)
(similarity pp x)
(cons val int)))))))
(values (car res) (cdr res))))
(defmethod calc-membership ((pp pattern-set) int)
(dolist (ee (elements pp))
(when (member ee int)
(incf (gethash ee (membership pp) 1)))))
(defmethod calc-membership ((dd dendron) int)
(dolist (ee (subdendrons dd))
(when (member ee int :test #'pattern-equal)
(incf (gethash ee (membership dd) 1)))))
(defmethod calc-membership ((pp pattern-set) (ii (eql :all)))
(dolist (ee (elements pp))
(incf (gethash ee (membership pp) 1))))
(defmethod calc-membership ((dd dendron) (ii (eql :all)))
(dolist (ee (subdendrons dd))
(incf (gethash ee (membership dd) 1))))
(defmethod calc-support ((pp pattern) (rr dendrogram) (method (eql :crispy)))
(let* ((erased
(set-difference (elements pp)
(elements rr)))
(p1 (delete-leaves erased pp)))
(when (or (null (elements p1))
(containedp p1 (root rr)))
(incf (support pp)))))
(defmethod calc-support ((pp pattern) (rr dendrogram) (method (eql :relaxed)))
(let* ((erased
(set-difference (elements pp)
(elements rr)))
(d1 (delete-leaves erased pp)))
(if (> (length (elements d1)) 1)
(multiple-value-bind (sim int)
(max-similarity d1 rr)
(incf (relaxed-support pp) sim)
(calc-membership pp int))
(progn (incf (relaxed-support pp))
(calc-membership pp :all)))))
;;; Reading functions
(defun read-dend-from-string (str &key (format #'newick) (type 'dendrogram))
"Read a tree structure from a string"
(let ((line (copy-seq str))
ss)
(setf line (substitute #\SPACE #\: line))
(setf line (substitute #\SPACE #\, line))
(with-input-from-string (st line)
(setf ss (read st)))
(if (eq type 'dendrogram)
(make-dendrogram ss :format format)
(make-dendron ss :format format))))
(defun read-pset-from-string (str)
(let (ss)
(with-input-from-string (st str)
(setf ss (read st)))
(make-instance 'pattern-set :elements ss)))
(defmacro do-lines ((var file &optional (counter (gensym))) &body body)
`(handler-case
(with-open-file (thy ,file)
(setf ,counter 0)
(loop for ,var = (read-line thy nil) then (read-line thy nil)
until (null ,var)
do
,@body
(incf ,counter)))
(end-of-file nil
(error 'simple-error
:format-control "Incomplete data in file at line: ~d."
:format-arguments (list ,file ,counter)))
(simple-error (cond)
(error 'simple-error
:format-control "There is an error in the file: ~a, at line: ~d.~%~a"
:format-arguments (list ,file ,counter cond)))
(file-error (cond)
(error 'simple-error
:format-control "Some error occured when reading file `~a' at line ~d~%~a" ,file ,counter cond))))
(defun read-patterns-from-file (file &key
(format #'newick)
(dendron-as :both)
include-subdendrons)
(let (patterns dd (cc 0))
(do-lines (line file cc)
(cond ((or (> (count #\( line :test #'char=) 1)
(position #\: line))
(setf dd (make-dendron (read-dend-from-string line :format format :type 'dendron)))
(cond ((eq dendron-as :graph)
(if include-subdendrons
(mapden dd #'(lambda (x)
(lpush x patterns)))
(lpush dd patterns)))
((eq dendron-as :set)
(if include-subdendrons
(mapden dd #'(lambda (x)
(lpush (pattern-set x) patterns)))
(lpush (pattern-set dd) patterns)))
(t
(if include-subdendrons
(mapden dd #'(lambda (x)
(lpush x patterns)
(lpush (pattern-set x) patterns)))
(progn (lpush dd patterns)
(lpush (pattern-set dd) patterns))))))
((= (count #\( line :test #'char=) 1)
(lpush (read-pset-from-string line) patterns))
(t (warn "Pattern in file ~a at line ~d is not a set nor a dendron, not taken into account" file cc))))
patterns))
(defun support-patterns (patfile repfile &key
(method :all)
(format #'newick)
(include-subdendrons nil)
(dendron-as :both))
(let ((patterns (read-patterns-from-file patfile
:format format
:dendron-as dendron-as
:include-subdendrons include-subdendrons))
rr cc)
(do-lines (ll repfile cc)
(setf rr (read-dend-from-string ll))
(dolist (pp patterns)
(cond ((and (eq method :all)
(eq (type-of pp) 'pattern-set))
(calc-support pp rr :crispy)
(calc-support pp rr :relaxed))
((eq (type-of pp) 'pattern-set)
(calc-support pp rr method))
((eq method :all)
(calc-support pp rr :crispy)
(calc-support pp rr :relaxed))
(t (calc-support pp rr method)))))
(mapc #'(lambda(x)
(setf (support x)
(/ (support x) cc)
(relaxed-support x)
(/ (relaxed-support x) cc)))
patterns)
patterns))
(defun print-pattern-list (plist out &key (fs #\TAB) (support :all))
(setf *print-pretty* nil)
(cond ((eq support :all)
(format out "pattern~Ccrispy~Crelaxed~%" fs fs))
((eq support :crispy)
(format out "pattern~Ccrispy~%" fs))
(t
(format out "pattern~Crelaxed~%" fs)))
(dolist (pp plist)
(cond ((and (eq support :all)
(eq (type-of pp) 'dendron))
(format out "~a;~C~,4f~C~,4f~%" (dendron-to-newick pp) fs (support pp) fs (relaxed-support pp)))
((and (dendronp pp)
(eq support :crispy))
(format out "~a;~C~,4f~%" (dendron-to-newick pp) fs (support pp)))
((dendronp pp)
(format out "~a;~C~,4f~%" (dendron-to-newick pp) fs (relaxed-support pp)))
((eq support :all)
(format out "~S;~C~,4f~C~,4f~%" (elements pp) fs (support pp) fs (relaxed-support pp)))
((eq support :crispy)
(format out "~S;~C~,4f~%" (elements pp) fs (support pp)))
(t (format out "~S;~C~,4f~%" (elements pp) fs (relaxed-support pp))))))
| 11,394 | Common Lisp | .lisp | 296 | 33.472973 | 108 | 0.637448 | WilmerLeal/dendron | 3 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 2951931bbe0dd17aef0f74fb48d9a370c29b62ec0d001945b103205e9109f394 | 18,974 | [
-1
] |
18,975 | auxiliary.lisp | WilmerLeal_dendron/auxiliary.lisp | ; -*-mode: Lisp-*-
;; Contains some auxiliary functions
;; and macros
(in-package #:dendron)
;; Push at the end of a list
(defmacro lpush (obj lst)
"Replace cdr of the last cons with a cons containing an object as its car."
`(cond ((null ,lst) (setf ,lst (list ,obj)))
(t (push ,obj (rest (last ,lst))))))
(defun elements-if (pred lst &optional res)
"Return elements of a list obeying a given predicate."
(cond ((null lst) res)
((funcall pred (car lst))
(elements-if pred (cdr lst) (cons (car lst) res)))
(t (elements-if pred (cdr lst) res))))
(defun minimum (lst &key (key #'identity) (min most-positive-fixnum) res)
(cond ((null lst) (values res min))
((< (funcall key (car lst)) min)
(minimum (cdr lst) :key key :min (funcall key (car lst)) :res (car lst)))
(t (minimum (cdr lst) :key key :min min :res res))))
(defun maximum (lst &key (key #'identity) (max most-positive-fixnum) res)
(cond ((null lst) (values res max))
((> (funcall key (car lst)) max)
(maximum (cdr lst) :key key :max (funcall key (car lst)) :res (car lst)))
(t (maximum (cdr lst) :key key :max max :res res))))
(defun split-string (str &optional (fs #\SPACE) empty)
(let (res (dd ""))
(dotimes (i (length str))
(cond ((and empty
(char= (elt str i) fs))
(lpush dd res)
(setf dd ""))
((char= (elt str i) fs)
(when (not (string= dd ""))
(lpush dd res)
(setf dd "")))
(t (setf dd (concatenate 'string dd
(list (elt str i)))))))
(when (or (and empty
(string= "" dd))
(string/= "" dd))
(lpush dd res))
res))
| 1,606 | Common Lisp | .lisp | 43 | 33.302326 | 77 | 0.606684 | WilmerLeal/dendron | 3 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 725a34ed7ae7834b74f429844bc1ae6bad14e6c6a9aefa4ca83a16c86590a3e5 | 18,975 | [
-1
] |
18,976 | conditions.lisp | WilmerLeal_dendron/conditions.lisp | ;-*-Lisp mode-*-
;; Contains error conditions
;; of dendron
(in-package :dendron)
(define-condition malformed-file (error)
((file :accessor file
:initarg :file)
(message :accessor message
:initarg :message)))
(define-condition malformed-line (malformed-file)
((line :accessor line
:initarg :line)))
(define-condition invalid-format (error)
((format :accessor current-format
:initarg :current-format)))
| 429 | Common Lisp | .lisp | 15 | 25.8 | 49 | 0.733496 | WilmerLeal/dendron | 3 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 124af0318abf30eda73b62f08841673397dc17e45c67ded6b980ca16be0ab2c9 | 18,976 | [
-1
] |
18,977 | app.lisp | WilmerLeal_dendron/app.lisp | ;-*-Lisp mode-*-
;; Use this file for building
;; an executable with buildapp
(require :asdf)
(push (truename ".") asdf:*central-registry*)
(asdf:operate 'asdf:load-op 'dendron)
(in-package :dendron)
(defvar *dendron-usage*
"dendron -- a simple tool for calculating frequency of patterns within dendrograms. Such calculation is performed
using input patterns, stored in a file, and a set of dendrograms (replicas), stored in other file using
newick format. dendron's output is a table having input patterns and their frequencies.
Input patterns may be sets, dendrograms or branches (dendrons). Such patterns are compared with those ones
coming from the set of replicas using two methods: crispy and relaxed. Using 'crispy' method dendron search
for exact matches of the given patterns throughout the replicas. When relaxed method is selected, then
a relaxed measure of similarity is used for finding the most similar subpattern within each replica.
Usage: dendron --patterns FILE --replicas REP_FILE [--output PREFIX] [--method METHOD] [--include-subdendrons] [--dendrons-as TYPE]
--dendron-as TYPE When a dendron is found in the pattern file, use TYPE
for comparison. TYPE might be one of the following values:
'set', 'graph' or 'both'. If the value of TYPE is 'set',
then dendrons are treated as sets. If TYPE is 'graph', then
they are treated as graphs (compare as drawings). If TYPE
is 'both' (default), then frequencies are calculated both as sets
and as graphs.
--help Display this text.
--include-subdendrons Recursively calculate frequency of subdendrons of each dendron
in FILE. Useful for calculating the frequency of a whole dendrogram
and all its branches.
Might be time consuming for large dendrograms, especially using
graph comparison.
--method METHOD METHOD may be one of:
'crispy', calculate frequency of patterns
using the crispy comparison.
'relaxed', calculate frequency of patterns
using a relaxed measure.
'all', calculate frequency of patterns using all
measures (default).
--output OUTPUT OUTPUT is the name of the output file. It stores all
input patterns (see --paterns) and their corresponding
frequency in a table. Fields are separated by a TAB character.
--patterns FILE Patterns are read from file FILE, one per line.
Patterns might be of the type `set' or `dendron'.
Sets are lists of elements separated by spaces and
enclosed by `(' and `)'. Dendrons are newick formated
dendrograms or branches (see examples). Elements should
not have any of the following characters: SPACE, TAB,
LINEFEED, CARRIAGE_RETURN, COLON, COMMA, SEMICOLON,
APOSTROPHE and DOUBLE_QUOTES.
--replicas REP_FILE Read REP_FILE to load dendrograms where to calculate frequency of patterns.
One dendrogram per line in newick format.
Examples: dendron --patterns example.tre --output example-output --method crispy-set --replicas rep.tre
To calculate supports of patterns in example.tre using a crispy set comparison whith dendrograms
from the file rep.tre.
dendron --replicas rep.tre --patterns example2.tre --output example2-out --method all --include-subdendrons
To calculate supports of patterns in the file example.tre, including their branches and using all methods."
"A string explaining how dendron works.")
(defvar *pattern-file* nil "File where patterns are input")
(defvar *output-file* "dendron-output" "The prefix name for the output file.")
(defvar *include-subdendrons* nil "A flag for including subdendrons in the calculations.")
(defvar *dendron-as* :both)
(defvar *method* :all)
(defvar *patterns* nil)
(defvar *replicas* nil)
(defun dendron-quit (&optional (code 0))
"Portable quit."
#+allegro (excl:exit code)
#+clisp (#+lisp=cl ext:quit #-lisp=cl lisp:quit code)
#+cmu (ext:quit code)
#+sbcl (sb-ext:quit :unix-status code)
#+gcl (lisp:bye code))
(defun support-patterns-from-file (argv)
(handler-case
(progn (cond ((member "--help" argv :test #'string=)
(format t "~a~%" *dendron-usage*)
(dendron-quit))
(t (do ((arg argv (cdr arg)))
((null arg))
(cond ((string= "--patterns" (car arg))
(setf arg (cdr arg)
*pattern-file* (pathname (car arg))))
((string= "--include-subdendrons" (car arg))
(setf *include-subdendrons* t))
((string= "--replicas" (car arg))
(setf arg (cdr arg)
*replicas* (pathname (car arg))))
((string= "--output" (car arg))
(setf arg (cdr arg)
*output-file* (car arg)))
((string= "--method" (car arg))
(setf arg (cdr arg)
*method* (intern (string-upcase (car arg)) :keyword)))
((string= "--dendron-as" (car arg))
(setf arg (cdr arg))
(setf *dendron-as* (intern (string-upcase (car arg)) :keyword)))))))
(when (not (member *dendron-as* '(:graph :set :both)))
(error 'simple-error
:format-control "option dendron-as: '~a' not recognized"
:format-arguments (list (symbol-name *dendron-as*))))
(when (not (member *method* '(:relaxed :crispy :all)))
(error 'simple-error
:format-control "option method: '~a' not recognized"
:format-arguments (list (symbol-name *method*))))
(when (or (not *pattern-file*)
(not (directory *pattern-file*)))
(error 'simple-error
:format-control "no pattern file given or does not exist"))
(when (or (not *replicas*)
(not (directory *replicas*)))
(error 'simple-error
:format-control "no replica file given or does not exist"))
(setf *patterns* (support-patterns *pattern-file* *replicas*
:method (intern (string-upcase *method*) :keyword)
:include-subdendrons *include-subdendrons*
:dendron-as *dendron-as*))
(handler-case
(with-open-file (golem *output-file* :direction :output :if-exists :supersede)
(print-pattern-list *patterns* golem :support *method*))
(file-error (cond)
(error 'simple-error
:format-control "cannot write to file: ~a, ~a"
:format-arguments (list *output-file* cond)))))
(error (cond)
(format t "An error occured during processing: ~a~%" cond)
(dendron-quit))))
| 7,195 | Common Lisp | .lisp | 123 | 46.357724 | 137 | 0.6082 | WilmerLeal/dendron | 3 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | d3c14c52b20565b6b3f3c5cea4412f9eb9cf41157543538f08c04aa6a87121f8 | 18,977 | [
-1
] |
18,978 | classes.lisp | WilmerLeal_dendron/classes.lisp | ;-*-Lisp-*-
(in-package #:dendron)
;; Classes and some methods used in dendron.
(defclass pattern ()
((relaxed-support :accessor relaxed-support
:initform 0
:type float)
(support :accessor support
:initform 0
:type float)
(occurrence :accessor occurrence
:initform 0)
(membership
:accessor membership
:initform (make-hash-table)))
(:documentation
"Root class for patterns."))
;;
(defclass pattern-set (pattern)
((elements :accessor elements
:initarg :elements
:type list
:initform nil)
(cardinal :accessor cardinal
:initarg :cardinal
:type integer))
(:documentation "Class of patterns considered as leaves."))
(defclass dendron (pattern)
((first-child :accessor first-child
:initarg :first-child)
(second-child :accessor second-child
:initarg :second-child)
(distance :accessor distance
:initarg :distance
:type 'float)
(associated-pattern-set :accessor pattern-set
:initarg :pattern-set)
(ordinal :accessor ordinal
:type 'string))
(:documentation "Class of patterns considered as trees."))
(defclass dendrogram ()
((root :accessor root
:initarg :root
:type 'dendron))
(:documentation "Class possesing a root dendron."))
(defmacro dendronp (d)
`(or (eq (type-of ,d) 'dendron)
(subtypep (type-of ,d) 'dendron)))
;; ;;; Sort elements of a given pattern set (canonical form)
(defmethod initialize-instance :after ((ss pattern-set) &rest args)
(declare (ignore args))
(setf (elements ss) (sort (elements ss) *leaf-sorting-function*)
(cardinal ss) (length (elements ss))))
(defmethod elements ((dd dendron))
(elements (pattern-set dd)))
(defmethod (setf elements) (new-val (dd dendron))
(setf (slot-value (slot-value dd 'pattern-set) 'elements) new-val))
;; Assign a new value to elements
(defmethod (setf elements) (new-val (ss pattern-set))
(setf (slot-value ss 'elements) new-val
(slot-value ss 'cardinal) (length new-val))
(setf (slot-value ss 'elements)
(sort (elements ss) *leaf-sorting-function*))
new-val)
(defmethod elements ((dd dendrogram))
(elements (root dd)))
;; Anything else
(defmethod elements (s)
(list s))
(defmethod elements ((ss null))
nil)
(defmethod leaves (s)
(list s))
(defmethod cardinal ((dd dendron))
(cardinal (pattern-set dd)))
(defmethod cardinal (ss)
1)
(defmethod cardinal ((dd null))
0)
(defmethod leaves ((dd dendron))
;; should work for non canonical dendrons
(cond ((and (not (dendronp (first-child dd)))
(not (dendronp (second-child dd))))
(list (first-child dd) (second-child dd)))
((not (dendronp (first-child dd)))
(cons (first-child dd) (leaves (second-child dd))))
((not (dendronp (second-child dd)))
(cons (second-child dd) (leaves (first-child dd))))
(t (append (leaves (first-child dd))
(leaves (second-child dd))))))
(defmethod leaves ((dd dendrogram))
(leaves (root dd)))
(defmethod subdendrons ((dd dendrogram))
(subdendrons (root dd)))
(defmethod enumerate ((dd dendrogram))
(labels ((num (dd &optional (ord "r"))
(cond ((not (dendronp dd)))
(t (setf (ordinal dd) ord)
(num (first-child dd)
(concatenate 'string ord ".0"))
(num (second-child dd)
(concatenate 'string ord ".1"))))))
(num (root dd))
dd))
(defmethod pattern-equal ((d1 dendron) (d2 dendron))
(cond ((or (not (eq (type-of (first-child d1))
(type-of (first-child d2))))
(not (eq (type-of (second-child d1))
(type-of (second-child d2))))
(not (equal (elements d1) (elements d2))))
nil)
((and (not (dendronp (first-child d1)))
(not (dendronp (first-child d2))))
(and (eq (first-child d1) (first-child d2))
(eq (second-child d1) (second-child d2))))
((and (not (dendronp (second-child d1)))
(not (dendronp (second-child d2))))
(and (eq (second-child d1) (second-child d2))
(pattern-equal (first-child d1) (first-child d2))))
(t
(and (pattern-equal (first-child d1) (first-child d2))
(pattern-equal (second-child d1) (second-child d2))))))
(defmethod pattern-equal ((s1 pattern-set) (s2 pattern-set))
(equal (elements s1) (elements s2)))
(defmethod pattern-equal (s1 s2)
(eq s1 s2))
;; The canonical form of a dendrogram is defined as
;; - If FIRST-CHILD and SECOND-CHILD are both leaves, FIRST-CHILD and SECOND-CHILD
;; are ordered alphabetically.
;; - If one of them is not a leave, it must be SECOND-CHILD
;; - Otherwise, FIRST-CHILD must be heavier than SECOND-CHILD.
;; - If they are equally heavy, then are ordered alfabetically according
;; to their elements.
(defmethod canonicalise ((dd dendron))
(cond ((and (not (dendronp (first-child dd)))
(not (dendronp (second-child dd))))
(when (funcall *leaf-sorting-function*
(second-child dd)
(first-child dd))
(psetf (first-child dd) (second-child dd)
(second-child dd) (first-child dd))))
((not (dendronp (second-child dd)))) ; do nothing
((not (dendronp (first-child dd)))
(psetf (first-child dd) (second-child dd)
(second-child dd) (first-child dd)))
((< (length (leaves (first-child dd)))
(length (leaves (second-child dd))))
(psetf (first-child dd) (second-child dd)
(second-child dd) (first-child dd)))
((= (length (leaves (first-child dd)))
(length (leaves (second-child dd))))
(when (funcall *leaf-sorting-function*
(car (leaves (second-child dd)))
(car (leaves (first-child dd))))
(psetf (first-child dd) (second-child dd)
(second-child dd) (first-child dd))))))
(defmethod canonicalise (dd)
(declare (ignore dd)))
;; find a leaf in elements of a pattern
(defmethod belongp (leaf (pp pattern))
(find leaf (elements pp)))
;; Return a copy of a pattern set
(defmethod copy-pattern ((ss pattern-set))
(make-instance 'pattern-set
:elements (copy-tree (elements ss))))
;; Return a new copy of dendron
(defmethod copy-pattern ((dd dendron))
(cond ((and (not (dendronp (first-child dd)))
(not (dendronp (second-child dd))))
(make-instance 'dendron
:first-child (first-child dd)
:second-child (second-child dd)
:pattern-set (copy-pattern (pattern-set dd))))
((not (dendronp (second-child dd)))
(make-instance 'dendron
:first-child (copy-pattern (first-child dd))
:second-child (second-child dd)
:pattern-set (copy-pattern (pattern-set dd))))
(t (make-instance 'dendron
:first-child (copy-pattern (first-child dd))
:second-child (copy-pattern (second-child dd))
:pattern-set (copy-pattern (pattern-set dd))))))
;; Return a list of dendrons contained
;; in a given dendron. Leaves are omitted.
(defmethod subdendrons ((dd dendron))
(cond ((and (not (dendronp (first-child dd)))
(not (dendronp (second-child dd))))
(list dd))
((not (dendronp (first-child dd)))
(cons dd (subdendrons (second-child dd))))
((not (dendronp (second-child dd)))
(cons dd (subdendrons (first-child dd))))
(t (append (list dd)
(subdendrons (first-child dd))
(subdendrons (second-child dd))))))
;; Should work for non canonical dendrons
(defmethod mapdendron ((dd dendron) fn)
(cond ((and (not (dendronp (first-child dd)))
(not (dendronp (second-child dd))))
(list (funcall fn dd)))
((not (dendronp (first-child dd)))
(cons (funcall fn dd)
(mapdendron (second-child dd) fn)))
((not (dendronp (second-child dd)))
(cons (funcall fn dd)
(mapdendron (first-child dd) fn)))
(t (append (list (funcall fn dd))
(mapdendron (first-child dd) fn)
(mapdendron (second-child dd) fn)))))
(defmethod mapden ((dd dendron) fn)
(cond ((and (not (dendronp (first-child dd)))
(not (dendronp (second-child dd))))
(funcall fn dd))
((not (dendronp (first-child dd)))
(funcall fn dd)
(mapden (second-child dd) fn))
((not (dendronp (second-child dd)))
(funcall fn dd)
(mapden (first-child dd) fn))
(t (funcall fn dd)
(mapden (first-child dd) fn)
(mapden (second-child dd) fn))))
(defmethod dendrons-if ((dd dendron) pred)
(if (funcall pred dd)
(cond ((not (dendronp (first-child dd)))
(list dd))
((not (dendronp (second-child dd)))
(cons dd (dendrons-if (first-child dd) pred)))
(t (append
(list dd)
(dendrons-if (first-child dd) pred)
(dendrons-if (second-child dd) pred))))
(cond ((not (dendronp (first-child dd)))
nil)
((not (dendronp (second-child dd)))
(dendrons-if (first-child dd) pred))
(t
(append (dendrons-if (first-child dd) pred)
(dendrons-if (second-child dd) pred))))))
;; quick hack to find dendrons
(defmethod find-dendron ((dd dendron) (lst list))
(let ((ll (elements-if #'(lambda (x)
(equal (elements dd)
(elements x)))
lst)))
(find dd ll :test #'pattern-equal)))
;; Return a string corresponding to the printed
;; representation of a dendron (newick format)
(defmethod dendron-to-newick ((dd dendron)
&key
(leaf-print #'(lambda (x) (format nil "~a" x)))
(support #'support)
include-support)
(cond ((not (dendronp (first-child dd)))
(format nil "(~a:~,6f,~a:~,6f)~:[~;~,6f~]"
(funcall leaf-print (first-child dd))
(distance dd)
(funcall leaf-print (second-child dd))
(distance dd)
include-support
(funcall support dd)))
((not (dendronp (second-child dd)))
(format nil "(~a:~,6f,~a:~,6f)~:[~;~,6f~]"
(dendron-to-newick (first-child dd)
:leaf-print leaf-print
:support support
:include-support include-support)
(distance dd)
(funcall leaf-print (second-child dd))
(distance dd)
include-support
(funcall support dd)))
(t
(format nil "(~a:~,6f,~a:~,6f)~:[~;~,6f~]"
(dendron-to-newick (first-child dd)
:leaf-print leaf-print
:support support
:include-support include-support)
(distance dd)
(dendron-to-newick (second-child dd)
:leaf-print leaf-print
:support support
:include-support include-support)
(distance dd)
include-support
(funcall support dd)))))
(defmethod membership-list ((dd dendrogram) (sb dendron))
(loop for ee in (elements dd)
collect (gethash ee (membership sb) 0)))
| 10,215 | Common Lisp | .lisp | 289 | 31.242215 | 84 | 0.660162 | WilmerLeal/dendron | 3 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 8086735d99ad008d7de2ff575343e5b350ced7b6ffa18612656adcad266f1ed9 | 18,978 | [
-1
] |
18,979 | variables.lisp | WilmerLeal_dendron/variables.lisp | ;-*-Lisp-*-
(in-package #:dendron)
;; Global variables used by dendron
(defvar *dendrons* nil "A list containing all dendrons read.")
(defvar *pattern-sets* nil "A list containing all pattern sets read.")
(defvar *input-formats* nil "An alist containing formats and tree parsing functions.")
(defvar *leaf-sorting-function* #'(lambda (x y)
(if (and (numberp x) (numberp y)) (< x y)
(string< (symbol-name x) (symbol-name y))))
"Function to sort leaves during canonicalisation.")
(defun reset-vars ()
(setf *dendrons* nil
*pattern-sets* nil))
| 566 | Common Lisp | .lisp | 13 | 40.615385 | 86 | 0.703839 | WilmerLeal/dendron | 3 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 1df4498f8f70d4577acbba1ace897e6f9f04e05720e07929144e3c928558848a | 18,979 | [
-1
] |
18,980 | dendron.asd | WilmerLeal_dendron/dendron.asd | ;;;; dendron.asd
(asdf:defsystem #:dendron
:serial t
:description "Dendron is simple tool for calculating statistical support of dendrograms"
:author "Eugenio J. Llanos <[email protected]> and Wilmer Leal <[email protected]>"
:license "This product is realeased under the terms of GPL v3.0"
:components ((:file "package")
(:file "variables" :depends-on ("package"))
(:file "auxiliary" :depends-on ("package"))
(:file "classes" :depends-on ("package" "auxiliary" "variables"))
(:file "dendron" :depends-on ("package" "auxiliary" "variables" "classes"))
(:file "random-sampler" :depends-on ("package" "auxiliary" "variables"))))
| 692 | Common Lisp | .asd | 12 | 51.833333 | 92 | 0.675994 | WilmerLeal/dendron | 3 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | d606e437568adf861667f0ac844d502bb902b98640cb8ca8a13f552543b1de06 | 18,980 | [
-1
] |
19,005 | build.lisp | exercism_common-lisp-representer/build/build.lisp | (load "quicklisp/setup.lisp")
(ql:quickload "representer")
(let ((bin-dir (make-pathname :directory '(:relative "bin"))))
(ensure-directories-exist bin-dir)
(sb-ext:save-lisp-and-die (merge-pathnames "representer" bin-dir)
:toplevel #'(lambda ()
(apply #'representer/main:main
(uiop:command-line-arguments)))
:executable t))
| 477 | Common Lisp | .lisp | 9 | 35.111111 | 80 | 0.505353 | exercism/common-lisp-representer | 2 | 5 | 4 | AGPL-3.0 | 9/19/2024, 11:28:00 AM (Europe/Amsterdam) | d767b4157998c3f00859ee11242b2dcd5a98818ae1b2bbdad794cc9dc1a24401 | 19,005 | [
-1
] |
19,006 | manual-test.lisp | exercism_common-lisp-representer/test/manual-test.lisp | ;;;
;;; Functions useful for doing "one-off" manual testing
;;;
(in-package :representer-test)
(defun represent-stream (solution &optional (slug "test"))
(let ((repr (make-string-output-stream))
(map (make-string-output-stream)))
(unwind-protect
(progn (representer/main::produce-representation slug solution repr map)
(pairlis '(:repr :map) (list (get-output-stream-string repr)
(get-output-stream-string map))))
(progn (close repr)
(close map)))))
(defun represent-file (solution &optional (slug "test"))
(with-open-file (stream solution :direction :input)
(acons :solution solution (represent-stream stream slug))))
| 731 | Common Lisp | .lisp | 16 | 37.6875 | 81 | 0.63764 | exercism/common-lisp-representer | 2 | 5 | 4 | AGPL-3.0 | 9/19/2024, 11:28:00 AM (Europe/Amsterdam) | 0a2faffa7222a5680ef21ea718b1d76f2accb15b58461c8aa70de0d666883fae | 19,006 | [
-1
] |
19,007 | represent.lisp | exercism_common-lisp-representer/test/represent.lisp | (in-package :representer-test)
(def-suite represent-test :in all-tests)
(in-suite represent-test)
(def-fixture with-placeholders-initialized (slug)
(placeholder:init slug)
(&body)
(placeholder:init "outside-a-test"))
(test empty-form
(with-fixture with-placeholders-initialized ("slug")
(is (equalp '() (representer:represent nil '())))
(is (equalp '() (placeholder:->alist)))))
(test arbitrary-form
(with-fixture with-placeholders-initialized ("slug")
(let ((mapped (placeholder:add 'x))
(form '(foo 2 x 4)))
(is (equal (substitute mapped 'x form)
(representer:represent (car form) form))))))
(test uninterned-symbol-with-no-placeholder
(is (equalp++ '(foo #:cl)
(representer:represent 'foo '(foo #:cl)))))
(test defpackage
(with-fixture with-placeholders-initialized ("test")
(is (equalp '(defpackage :test-0
(:export :test-1)
(:use :test-2))
(representer:represent 'defpackage
'(defpackage :pack
(:use :cl)
(:export :thingie)))))
(is (equalp '((":TEST-0" . ":PACK") (":TEST-1" . ":THINGIE")
(":TEST-2" . ":CL"))
(placeholder:->alist)))))
(test defun-empty
(with-fixture with-placeholders-initialized ("defun")
(is (equalp '(defun :defun-0
((:required nil) (:optional nil) (:rest nil) (:keyword nil)
(:aux nil) (:allow-other-keys nil))
(:docstring nil)
(:declare nil)
())
(representer:represent 'defun '(defun foo ()))))
(is (equal '((":DEFUN-0" . "FOO"))
(placeholder:->alist)))))
(test defun-body-is-atom
(with-fixture with-placeholders-initialized ("defun")
(is (equalp '(:a-single-atom)
(sixth (representer:represent 'defun '(defun foo () :a-single-atom)))))))
(test defun-one-of-every-arg
(with-fixture with-placeholders-initialized ("defun")
(is (equalp '(defun :defun-0
((:required (:defun-1)) (:optional ((:defun-2 nil nil)))
(:rest :defun-3) (:keyword ((:defun-4 nil nil)))
(:aux ((:defun-5 nil))) (:allow-other-keys t))
(:docstring nil)
(:declare nil)
())
(representer:represent 'defun
'(defun fun (req
&optional opt
&rest rest
&key key
&allow-other-keys
&aux aux)))))
(is (equal '((":DEFUN-0" . "FUN")
(":DEFUN-1" . "REQ")
(":DEFUN-2" . "OPT")
(":DEFUN-3" . "REST")
(":DEFUN-4" . "KEY")
(":DEFUN-5" . "AUX"))
(placeholder:->alist)))))
(test defun-with-default-values-and-supplied-p
(with-fixture with-placeholders-initialized ("defun")
(let ((representation
(representer:represent
'defun
'(defun foo (&optional (opt opt-default opt-supplied-p)
&key (key key-default key-supplied-p))))))
(is (equal '(:optional ((:defun-1 :defun-2 :defun-3)))
(assoc :optional (third representation))))
(is (equal '(:keyword ((:defun-4 :defun-5 :defun-6)))
(assoc :keyword (third representation))))
(is (equal '((":DEFUN-0" . "FOO")
(":DEFUN-1" . "OPT")
(":DEFUN-2" . "OPT-DEFAULT")
(":DEFUN-3" . "OPT-SUPPLIED-P")
(":DEFUN-4" . "KEY")
(":DEFUN-5" . "KEY-DEFAULT")
(":DEFUN-6" . "KEY-SUPPLIED-P"))
(placeholder:->alist))))))
(test defun-with-aux-value
(with-fixture with-placeholders-initialized ("defun")
(let ((representation
(representer:represent
'defun
'(defun foo (&aux (aux aux-default))))))
(is (equal '(:aux ((:defun-1 :defun-2)))
(assoc :aux (third representation))))
(is (equal '((":DEFUN-0" . "FOO")
(":DEFUN-1" . "AUX")
(":DEFUN-2" . "AUX-DEFAULT"))
(placeholder:->alist))))))
(test defun-with-docstring
(with-fixture with-placeholders-initialized ("defun")
(is (equalp '(defun :defun-0 ((:required nil) (:optional nil)
(:rest nil) (:keyword nil)
(:aux nil) (:allow-other-keys nil))
(:docstring t)
(:declare nil)
(()))
(representer:represent 'defun '(defun foo () "a docstring" nil))))
(is (equal '((":DEFUN-0" . "FOO"))
(placeholder:->alist)))))
(test defun-with-declarations
(with-fixture with-placeholders-initialized ("defun")
(is (equalp '(:declare ((declare (ignore :defun-1) (speed 0))))
(fifth (representer:represent
'defun '(defun foo (bar)
(declare (ignore bar) (speed 0)))))))
(is (equalp '(:declare ((declare (ignore :defun-1))
(declare (speed 0))))
(fifth (representer:represent
'defun '(defun foo (bar)
(declare (ignore bar))
(declare (speed 0)))))))))
(test defun-represents-body
(with-fixture with-placeholders-initialized ("defun")
(is (equalp '((list :DEFUN-1 :DEFUN-2))
(sixth (representer:represent
'defun '(defun foo (a b) (list a b))))))))
(test dotted-pair
;; quote here used as example symbol...
(with-fixture with-placeholders-initialized ("dotted-pair")
(is (equalp '(QUOTE (1 2 . 3))
(representer:represent 'quote '(quote (1 2 . 3)))))))
(test circular-list
(with-fixture with-placeholders-initialized ("circular")
(let ((repr (with-output-to-string (str)
(write (representer:represent nil '#0=(1 2 . #0#))
:stream str :circle t))))
(is (string= "#1=(1 2 . #1#)" repr)))))
| 6,492 | Common Lisp | .lisp | 140 | 31.914286 | 89 | 0.483581 | exercism/common-lisp-representer | 2 | 5 | 4 | AGPL-3.0 | 9/19/2024, 11:28:00 AM (Europe/Amsterdam) | f383d4fedbc6bcc465f60297ae5c86a90d107163464db8484980a84e63434e75 | 19,007 | [
-1
] |
19,008 | end-to-end.lisp | exercism_common-lisp-representer/test/end-to-end.lisp | (in-package :representer-test)
(def-suite end-to-end :in all-tests)
(in-suite end-to-end)
(defun load-expected-values (directory)
(let ((repr-file (representer/main::representation-file directory))
(mapping-file (representer/main::mapping-file directory)))
(values (uiop:read-file-forms repr-file)
(alexandria:hash-table-plist
(yason:parse (uiop:read-file-string mapping-file))))))
(defun get-actual-values (slug directory)
(let ((actual-repr-stream (make-string-output-stream))
(actual-mapping-stream (make-string-output-stream))
(solution-file (representer/main::solution-file slug directory)))
(with-open-file (solution-stream solution-file :direction :input)
(representer/main::produce-representation
slug solution-stream
actual-repr-stream actual-mapping-stream))
(let ((actual-repr-str (get-output-stream-string actual-repr-stream))
(actual-mapping-str (get-output-stream-string actual-mapping-stream)))
(values (uiop:slurp-stream-forms
(make-string-input-stream actual-repr-str))
(alexandria:hash-table-plist
(yason:parse actual-mapping-str))))))
(defun end-to-end-test (slug)
(let ((directory (make-pathname :directory (list :relative "test" "files" slug))))
(multiple-value-bind (expected-repr expected-mapping)
(load-expected-values directory)
(multiple-value-bind (actual-repr actual-mapping)
(get-actual-values slug directory)
(is (equalp++ expected-repr actual-repr))
(is (equalp++ expected-mapping actual-mapping))))))
(test two-fer
(end-to-end-test "two-fer"))
(test end-of-file (end-to-end-test "end-of-file"))
#-sbcl (format t "~&NO END-TO-END testing for READER-ERROR cases~&")
#+sbcl
(test reader-error
(end-to-end-test "reader-error")
(end-to-end-test "sharpsign-dot"))
| 1,899 | Common Lisp | .lisp | 39 | 42.333333 | 84 | 0.690476 | exercism/common-lisp-representer | 2 | 5 | 4 | AGPL-3.0 | 9/19/2024, 11:28:00 AM (Europe/Amsterdam) | cdac2a2a3ccbf74eed8912f8e3229e26372f6d57370632f322e17534dd04fb0c | 19,008 | [
-1
] |
19,009 | io.lisp | exercism_common-lisp-representer/test/io.lisp | (in-package :representer-test)
(def-suite* io-tests :in all-tests)
(test empty-mapping
(is (string= "{}"
(with-output-to-string (stream) (io:write-mapping '() stream)))))
(test slurp-solution
(is (equal '((list 1 2 3))
(io:slurp-solution (make-string-input-stream "(list 1 2 3)"))))
(is (equal '((list 1 2 3)
(list a b c))
(io:slurp-solution (make-string-input-stream (format nil "~A~&~A"
"(list 1 2 3)"
"(list a b c)"))))))
(test slurp-solution-invalid-sexpr
(signals end-of-file
(io:slurp-solution (make-string-input-stream "(list "))))
(test slurp-solution-reader-error
(signals reader-error
(io:slurp-solution (make-string-input-stream "#<foo>"))))
(test slurp-solution-sharpsign-dot
(signals reader-error
(io:slurp-solution (make-string-input-stream "#.(+ 1 1)"))))
(test write-circular
(is (string= "#1=(1 2 . #1#)"
(with-output-to-string (stream) (io:write-repr '#0=(1 2 . #0#) stream)))))
| 1,133 | Common Lisp | .lisp | 25 | 34.88 | 89 | 0.546776 | exercism/common-lisp-representer | 2 | 5 | 4 | AGPL-3.0 | 9/19/2024, 11:28:00 AM (Europe/Amsterdam) | d798b3a3260164ceb8de59b8ffb428251989973a6f69bffa252fd9c90ed71b5d | 19,009 | [
-1
] |
19,010 | suite.lisp | exercism_common-lisp-representer/test/suite.lisp | (in-package :representer-test)
(def-suite all-tests)
(in-suite all-tests)
(defun run-tests (&optional (suite 'all-tests))
(run! suite))
(defun equalp++ (x y)
"EQUALP++ extends EQUALP to include checking uninterned symbols.
Two uninterned symbols are EQUALP++ if their their symbol names are STRING=."
(flet ((uninterned-symbol-equal (x y)
(and (symbolp x) (symbolp y)
(null (symbol-package x)) (null (symbol-package y))
(string= (symbol-name x) (symbol-name y)))))
(or (equalp x y)
(cond ((and (null x) (null y)) t)
((or (null x) (null y)) nil)
((and (atom x) (atom y)) (uninterned-symbol-equal x y))
(t (and (equalp++ (car x) (car y))
(equalp++ (cdr x) (cdr y))))))))
| 797 | Common Lisp | .lisp | 18 | 36.166667 | 77 | 0.573454 | exercism/common-lisp-representer | 2 | 5 | 4 | AGPL-3.0 | 9/19/2024, 11:28:00 AM (Europe/Amsterdam) | 7ce2a673ddc7c79a65a0ecc323449a1407f7d34fd5b587f72143f3cb575dd4c4 | 19,010 | [
-1
] |
19,011 | placeholder.lisp | exercism_common-lisp-representer/test/placeholder.lisp | (in-package :representer-test)
(def-suite placeholder-tests :in all-tests)
(in-suite placeholder-tests)
(defun test-cleanup () (placeholder:init "outside-of-a-test"))
(def-fixture init-with-slug (slug)
(placeholder:init slug)
(&body)
(test-cleanup))
(test starting-conditions
(with-fixture init-with-slug ("slug")
(is (equal (placeholder:->alist) (list)))
(is (equal (placeholder:new) :slug-0))
(is (equal (placeholder:new) :slug-1))
(is (null (placeholder:assoc :slug-0)))
(is (null (placeholder:rassoc 'some-symbol)))))
(test adding-a-mapping
(with-fixture init-with-slug ("mapping")
(let* ((symbol 'a-symbol)
(mapped (placeholder:add symbol))
(lookup (placeholder:assoc mapped))
(rev-lookup (placeholder:rassoc symbol)))
(is (eq lookup symbol)
"lookup of '~A' resulted in '~A' not '~A'" mapped lookup symbol)
(is (eq rev-lookup mapped)
"reverse lookup of '~A' result in '~A' not '~A'" symbol rev-lookup mapped)
(is (equal (placeholder:->alist) `((,(write-to-string mapped) .
,(write-to-string symbol))))))))
(test does-not-add-nil
(with-fixture init-with-slug ("nil")
(is (eq nil (placeholder:add nil)))
(is (eq '() (placeholder:->alist)))))
(test does-not-add-non-symbol
;; a non-exhaustive test
(with-fixture init-with-slug ("non-symbol")
(is (= 5 (placeholder:add 5)))
(let ((some-list (list 'x 'y 1 2))
(some-string "blahblah"))
(is (eq some-list (placeholder:add some-list)))
(is (eq some-string (placeholder:add some-string))))
(is (equal '() (placeholder:->alist)))))
(test rassoc-of-uninterned-symbol
(with-fixture init-with-slug ("uninterned")
(let ((mapped (placeholder:add '#:foo)))
(is (eq mapped (placeholder:rassoc '#:foo))))))
(def-fixture init-with-existing-symbols (slug symbols)
(placeholder:init slug)
(dolist (sym symbols) (placeholder:add sym))
(&body)
(test-cleanup))
(test adding-already-existing-symbol
(let ((existing-symbols '(:foo :bar)))
(with-fixture init-with-existing-symbols ("mapping" existing-symbols)
(is (= #1=(length (placeholder:->alist)) #2= (length existing-symbols))
"length should still be ~D not ~D" #2# #1#)
(let ((existing-placeholder (placeholder:rassoc :foo))
(add-result (placeholder:add :foo)))
(is (eq add-result existing-placeholder)
"result of add should have been '~A' not '~A'"
existing-placeholder add-result)))))
(test alist-always-sorted-by-placeholder
(with-fixture init-with-slug ("someslug")
(let* ((symbol1 'one)
(symbol2 'two)
(symbol3 'three)
(first-mapping (placeholder:add symbol1))
(second-mapping (placeholder:add symbol2))
(third-mapping (placeholder:add symbol3))
(expected-alist `((,(write-to-string first-mapping) .
,(write-to-string symbol1))
(,(write-to-string second-mapping) .
,(write-to-string symbol2))
(,(write-to-string third-mapping) .
,(write-to-string symbol3)))))
(is (equal (placeholder:->alist) expected-alist))
;; add symbol2 again!
(placeholder:add symbol2)
(is (equal (placeholder:->alist) expected-alist)
"alist should still be in correct order after adding symbol again (was ~A)"
(placeholder:->alist)))))
| 3,569 | Common Lisp | .lisp | 79 | 36.974684 | 85 | 0.610759 | exercism/common-lisp-representer | 2 | 5 | 4 | AGPL-3.0 | 9/19/2024, 11:28:00 AM (Europe/Amsterdam) | 02f231cae1c29eefeac8dea298e56a5deb166fff8a229a6dca8688bfd1752a87 | 19,011 | [
-1
] |
19,012 | two-fer.lisp | exercism_common-lisp-representer/test/files/two-fer/two-fer.lisp | (defpackage :two-fer
(:use :cl)
(:export :twofer))
(in-package :two-fer)
(defun twofer (&optional name)
(format nil "One for ~a, one for me." (or name "you")))
| 167 | Common Lisp | .lisp | 6 | 25.666667 | 57 | 0.65 | exercism/common-lisp-representer | 2 | 5 | 4 | AGPL-3.0 | 9/19/2024, 11:28:00 AM (Europe/Amsterdam) | 13183aaf12709b238d9042378c43ce3631a970b645d8d0ee2d23466dc9736192 | 19,012 | [
-1
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.