From 16a5b1c177ea744139fc1cd7066941ed646c61e6 Mon Sep 17 00:00:00 2001 From: Luke Shumaker Date: Wed, 14 Jan 2015 01:32:00 -0500 Subject: These changes were sitting here --- .config/X11/modmap | 2 + .config/cron/alarm | 14 + .config/cron/offlineimap | 2 +- .config/emacs/bison-mode.el | 989 ++++++++++++++++++++++++++++++++++++++ .config/emacs/games/snake-scores | 2 + .config/emacs/games/tetris-scores | 117 +++++ .config/emacs/init.el | 2 +- .config/emacs/tetris.el | 641 ++++++++++++++++++++++++ .config/gtk-3.0/bookmarks | 1 + .config/okular/.gitignore | 1 - .config/ssh/known_hosts | 32 +- 11 files changed, 1786 insertions(+), 17 deletions(-) create mode 100644 .config/cron/alarm create mode 100644 .config/emacs/bison-mode.el create mode 100644 .config/emacs/games/snake-scores create mode 100644 .config/emacs/games/tetris-scores create mode 100644 .config/emacs/tetris.el delete mode 100644 .config/okular/.gitignore diff --git a/.config/X11/modmap b/.config/X11/modmap index 1736e09..7c4699f 100644 --- a/.config/X11/modmap +++ b/.config/X11/modmap @@ -7,6 +7,8 @@ keysym Caps_Lock = Super_L Multi_key clear mod4 add mod4 = Super_L Super_R Hyper_L Hyper_R Menu +! Make page down be dead greek +keysym Next = dead_greek NoSymbol Next ! Note to future me: ! The modifiers are: << Shift, Lock, Control, Mod{1..5} >> and are NOT case sensitive diff --git a/.config/cron/alarm b/.config/cron/alarm new file mode 100644 index 0000000..a08434f --- /dev/null +++ b/.config/cron/alarm @@ -0,0 +1,14 @@ +# m h dom mon dow command +#0 9 * * * cronic bash -c 'while true; do /home/luke/.local/bin/state-the-time; sleep .5; done' +#30 8 * * * cronic bash -c 'while true; do /home/luke/.local/bin/state-the-time; sleep .5; done' +#25 1 * * * cronic bash -c 'while true; do /home/luke/.local/bin/state-the-time; sleep .5; done' + +# 6:30 MWF +30 6 * * 1 cronic bash -c 'while true; do /home/luke/.local/bin/state-the-time; sleep .5; done' +30 6 * * 3 cronic bash -c 'while true; do /home/luke/.local/bin/state-the-time; sleep .5; done' +30 6 * * 5 cronic bash -c 'while true; do /home/luke/.local/bin/state-the-time; sleep .5; done' +# 7:00 TR +0 7 * * 2 cronic bash -c 'while true; do /home/luke/.local/bin/state-the-time; sleep .5; done' +0 7 * * 4 cronic bash -c 'while true; do /home/luke/.local/bin/state-the-time; sleep .5; done' + +30 7 * * 3 cronic bash -c 'while true; do /home/luke/.local/bin/state-the-time; sleep .5; done' \ No newline at end of file diff --git a/.config/cron/offlineimap b/.config/cron/offlineimap index 9de9de1..76e1537 100644 --- a/.config/cron/offlineimap +++ b/.config/cron/offlineimap @@ -1,2 +1,2 @@ # m h dom mon dow command -*/5 * * * * offlineimap-runner 2 -u quiet +*/5 * * * * offlineimap -u quiet diff --git a/.config/emacs/bison-mode.el b/.config/emacs/bison-mode.el new file mode 100644 index 0000000..5f99106 --- /dev/null +++ b/.config/emacs/bison-mode.el @@ -0,0 +1,989 @@ +; -*- Mode: Emacs-Lisp; -*- + +;;;; bison-mode.el --- Major mode for editing bison/yacc files +;;;; Copyright (C) 1998 Eric Beuscher + +;; Author: Eric Beuscher +;; Created: 2 Feb 1998 +;; Version: .1 (why not start somewhere besides 1.) +;; Keywords: bison-mode, yacc-mode + +;; This program 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. + +;; This program 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. + +;;;;Commentary + +;;;; I wrote this since I saw one mode for yacc files out there roaming the +;;;; world. I was daunted by the fact the it was written in 1990, and emacs +;;;; has evolved so much since then (this I assume based on its evolution since +;;;; i started using it). So I figured if i wanted one, I should make it +;;;; myself. Please excuse idiosyncrasies, as this was my first major mode +;;;; of this kind. The indentation code may be a bit weird, I am not sure, +;;;; it was my first go at doing emacs indentation, so I look at how other +;;;; modes did it, but then basically did what I thought was right + +;;;; I hope this is useful to other hackers, and happy Bison/Yacc hacking +;;;; If you have ideas/suggestions/problems with this code, I can be reached at +;;;; beuscher@eecs.tulane.edu + +;;;; Eric --- Sat Mar 7 1:40:20 CDT 1998 + + +;;;; Bison Sections: +;;;; there are five sections to a bison file (if you include the area above the +;;;; C declarations section. most everything in this file either does +;;;; actions based on which section you are deemed to be in, or based on an +;;;; assumption that the function will only be called from certain sections. +;;;; the function `bison--section-p' is the section parser + +;;;; Indentation: +;;;; indentations are done based on the section of code you are in. there is +;;;; a procedure `bison--within-braced-c-expression-p' that checks for being in +;;;; C code. if you are within c-code, indentations should occur based on +;;;; how you have your C indentation set up. i am pretty sure this is the +;;;; case. +;;;; there are four variables, which control bison indentation within either +;;;; the bison declarations section or the bison grammar section +;;;; `bison-rule-separator-column' +;;;; `bison-rule-separator-column' +;;;; `bison-decl-type-column' +;;;; `bison-decl-token-column' + +;;;; flaw: indentation works on a per-line basis, unless within braced C sexp, +;;;; i should fix this someday +;;;; and to make matters worse, i never took out c-indent-region, so that is +;;;; still the state of the `indent-region-function' variable + +;;;; Electricity: +;;;; by default, there are electric -colon, -pipe, -open-brace, -close-brace, +;;;; -semicolon, -percent, -less-than, -greater-than +;;;; the indentation caused by these work closely with the 4 indentation +;;;; variables mentioned above. +;;;; any of these can be turned off individually by setting the appropriate +;;;; `bison-electric-...' variable. or all of them can be turned off by +;;;; setting `bison-all-electricity-off' + +;;;; todo: should make available a way to use C-electricity if in C sexps + + +;;;; these are the lines i use to set up correct auto-ing +;;(autoload 'bison-mode "bison-mode.el") +;;(add-to-set! auto-mode-alist '("\\.y$" . bison-mode)) + +;;(autoload 'flex-mode "flex-mode") +;;(add-to-set! auto-mode-alist '("\\.l$" . flex-mode)) + + + +;; *************** dependencies *************** + +(require 'derived) ;; define-derived-mode +;(require 'flex-mode) ;; for flex-mode derivation +(require 'make-regexp) ;; make-regexp + + +;; *************** internal vars *************** + +(defvar bison--declarers '("%union" "%token" "%type" + "%left" "%right" "%nonassoc") + "commands which can declare a token or state type") + +(defvar bison--word-constituent-re "\\(\\sw\\|_\\)") +(defvar bison--production-re + (concat "^" bison--word-constituent-re "+:")) + +(defvar bison--pre-c-decls-section 0 + "section before c-declarations-section, if that section exists") +(defvar bison--c-decls-section 1 + "section denoted by %{ and $} for c-declarations at the top of a bison file") +(defvar bison--bison-decls-section 2 + "section before the rules section") +(defvar bison--grammar-rules-section 3 + "section delimited by %%'s where productions and rules are enumerated") +(defvar bison--c-code-section 4 + "section after the second %% where c-code can be placed") + +(defvar bison--c-decls-section-opener "%{") +(defvar bison--c-decls-section-closer "%}") +(defvar bison--grammar-rules-section-delimeter "%%") + + +;; *************** user-definable vars *************** + +(defvar bison-rule-separator-column 8 + "column for rule and production separators \"|\" and \";\"") +(defvar bison-rule-enumeration-column 16 + "column for beginning enumeration of a production's rules") +(defvar bison-decl-type-column 8 + "columnn in which tokens' and states' types should be when declared") +(defvar bison-decl-token-column 24 + "column in which tokens and states are listed when declared, +as with %token, %type, ...") + + +(defvar bison-all-electricity-off nil + "non-nil means all electric keys will be disabled, +nil means that a bison-electric-* key will be on or off based on the individual +key's electric variable") + +;;; i know lisp has the dual name spaces, but i find it more aesthetically +;;; pleasing to not take advantage of that +(defvar bison-electric-colon-v t + "non-nil means use an electric colon") +(defvar bison-electric-pipe-v t + "non-nil means use an electric pipe") +(defvar bison-electric-open-brace-v t + "non-nil means use an electric open-brace") +(defvar bison-electric-close-brace-v t + "non-nil means use an electric close-brace") +(defvar bison-electric-semicolon-v t + "non-nil means use an electric semicolon") +(defvar bison-electric-percent-v t + "non-nil means use an electric percent") +(defvar bison-electric-less-than-v t + "non-nil means use an electric less-than") +(defvar bison-electric-greater-than-v t + "non-nil means use an electric greater-than") + + +(defvar bison-font-lock-keywords-1 c-font-lock-keywords + "Basic highlighting for Bison mode.") + +(defvar bison-font-lock-keywords-2 + (append + (list + (cons (concat "^\\(" (make-regexp bison--declarers) "\\)") + '(1 font-lock-keyword-face)) + ) + bison-font-lock-keywords-1) + "Gaudy highlighting for Bison mode.") + +(defvar bison-font-lock-keywords bison-font-lock-keywords-2 + "Default expressions to highlight in Bison mode") + + +;; *************** utilities *************** + +(defun copy-list (ls) + "return a new list with the same elements as LS" + (cond ((null ls) '()) + (t (cons (car ls) (copy-list (cdr ls)))))) + +(defun same-line-p (pt1 pt2 &optional bol eol) + (let ((bol (or bol (save-excursion (beginning-of-line) (point)))) + (eol (or eol (save-excursion (end-of-line) (point))))) + (and (<= bol pt1) (<= bol pt2) + (>= eol pt1) (>= eol pt2)))) + +(defun just-no-space () + "Delete all spaces and tabs around point, leaving no spaces." + (interactive "*") + (skip-chars-backward " \t") + (delete-region (point) (progn (skip-chars-forward " \t") (point))) + t) + +(defun white-space-separation (pt1 pt2) + "return t if there is nothing but whitespace between pt1 and pt2 not +inclusive" + (save-excursion + (goto-char (+ pt1 1)) + (not (re-search-forward "[^ \t\n]" pt2 t)))) + +(defun previous-white-space-p () + "return t if there is whitespace between the beginning of the line and the +current (point)" + (save-excursion + (let ((current-point (point))) + (beginning-of-line) + (if (re-search-forward "\\s " current-point t) + t + nil)))) + +(defun previous-non-ws-p () + "return t if there are non-whitespace characters between beginning of line +and \(point\)" + (save-excursion + (let ((current-point (point))) + (beginning-of-line) + (re-search-forward "[^ \t]" current-point t) + ))) + +(defun following-non-ws-p () + "return t if there are non-whitespace characters on the line" + (save-excursion + (let ((current-point (point))) + (end-of-line) + (re-search-backward "[^ \t]+" current-point t) + ))) + +(defun line-of-whitespace-p () + "return t if the line consists of nothiing but whitespace, nil otherwise" + (save-excursion + (let ((eol (progn (end-of-line) (point)))) + (beginning-of-line) ;; should already be there anyway + (not (re-search-forward "[^ \t\n]" eol t))))) + + +(defun goto-next-non-ws () + "goto and return pt of next non-whitespace character") + +;; *************** bison-mode *************** + +(define-derived-mode bison-mode flex-mode "Bison" + "Major mode for editing bison/yacc files + +" + ;; try to set the indentation correctly + (setq-default c-basic-offset 4) + (make-variable-buffer-local 'c-basic-offset) + + (c-set-offset 'knr-argdecl-intro 0) + (make-variable-buffer-local 'c-offsets-alist) + + ;; remove auto and hungry anything + (c-toggle-auto-hungry-state -1) + (c-toggle-auto-state -1) + (c-toggle-hungry-state -1) + + (use-local-map bison-mode-map) + + (define-key bison-mode-map ":" 'bison-electric-colon) + (define-key bison-mode-map "|" 'bison-electric-pipe) + (define-key bison-mode-map "{" 'bison-electric-open-brace) + (define-key bison-mode-map "}" 'bison-electric-close-brace) + (define-key bison-mode-map ";" 'bison-electric-semicolon) + (define-key bison-mode-map "%" 'bison-electric-percent) + (define-key bison-mode-map "<" 'bison-electric-less-than) + (define-key bison-mode-map ">" 'bison-electric-greater-than) + + ;(define-key bison-mode-map [tab] 'bison-indent-command) + (define-key bison-mode-map [tab] 'bison-indent-line) + ;(define-key bison-mode-map [f10] 'c-indent-command) + + (make-local-variable 'indent-line-function) + (setq indent-line-function 'bison-indent-new-line) + (make-local-variable 'comment-start) + (make-local-variable 'comment-end) + (setq comment-start "/*" + comment-end "*/") + (make-local-variable 'font-lock-keywords) + (setq font-lock-keywords nil) + (make-local-variable 'font-lock-defaults) + (setq font-lock-defaults '((bison-font-lock-keywords + bison-font-lock-keywords-1 + bison-font-lock-keywords-2) + nil nil nil)) + +) + + +;; *************** section parsers *************** + +(defun bison--section-p () + "Return the section that user is currently in" + (save-excursion + (let ((bound (point))) + (beginning-of-buffer) + (bison--section-p-helper bound)))) + +(defun bison--section-p-helper (bound) + (if (re-search-forward + (concat "^" bison--c-decls-section-opener) + bound t) + (if (re-search-forward + (concat "^" bison--c-decls-section-closer) + bound t) + (if (re-search-forward + (concat "^" bison--grammar-rules-section-delimeter) + bound t) + (if (re-search-forward + (concat "^" bison--grammar-rules-section-delimeter) + bound t) + bison--c-code-section + bison--grammar-rules-section) + bison--bison-decls-section) + bison--c-decls-section) + (if (re-search-forward + (concat "^" bison--grammar-rules-section-delimeter) + bound t) + (if (re-search-forward + (concat "^" bison--grammar-rules-section-delimeter) + bound t) + bison--c-code-section + bison--grammar-rules-section) + (if (re-search-forward + (concat "^" bison--c-decls-section-opener) + nil t) + bison--pre-c-decls-section + (if (re-search-forward + (concat "^" bison--grammar-rules-section-delimeter) + nil t) + bison--bison-decls-section + bison--pre-c-decls-section))))) + + +;; *************** syntax parsers *************** + +(defun bison--production-p () + "return t if the \(point\) rests immediately after a production" + (save-excursion + (let ((current-point (point))) + (beginning-of-line) + (let ((position (re-search-forward + bison--production-re current-point t))) + (and position + (not (previous-white-space-p)) + (= position current-point)))))) + +(defun bison--find-production-opener () + "return and goto the point of the nearest production opener above \(point\)" + (re-search-backward bison--production-re nil t)) + + +(defun bison--find-next-production () + "return the position of the beginning of the next production, +or nil if there isnt one" + (save-excursion + (if (re-search-forward bison--production-re nil t) + (progn + (beginning-of-line) + (point)) + nil))) + +(defun bison--find-grammar-end () + "return the position of the end of the grammar rules (assuming we are within +the grammar rules section), or nil if there isnt one" + (save-excursion + (if (re-search-forward + (concat "^" bison--grammar-rules-section-delimeter) + nil t) + (progn + (beginning-of-line) + (point)) + nil))) + +(defun bison--find-grammar-begin () + "return the position of the beginning of the grammar rules (assuming we are +within the grammar rules section), or nil if there isnt one" + (save-excursion + (if (re-search-backward + (concat "^" bison--grammar-rules-section-delimeter) + nil t) + (point) + nil))) + +(defun bison--within-started-production-p () + "is used by bison-electric-* functions to determine actions +return t if within a production, nil if not + +a point is within a production if there is some non whitespace text before +either the beginnings of another production or the end of the grammar rules" + (save-excursion + (let ((bound (cond ((bison--find-next-production)) + ((bison--find-grammar-end)) + (t nil)))) + (if bound + (let ((sval (re-search-forward + (concat "\\(\\s \\|" ;; whitespace or + ;; comments + (regexp-quote comment-start) + "\\(.\\|\n\\)*" ;; comment body + (regexp-quote comment-end) + "\\)+") ;; end or + bound t))) + (if sval + (not (= sval bound)) + nil)) + nil)))) + +(defun bison--within-some-sexp-p (starter ender) + "return t if the \(point\) is within the sexp marked by the re's STARTER and +ENDER" + (save-excursion + (let ((current-point (point))) + (if (re-search-backward starter nil t) ;; find nearest starter + ;; look for ender, if found, then not within sexp + (progn + (goto-char (match-end 0)) + (not (re-search-forward ender current-point t))))))) + +(defun bison--within-c-comment-p () + "return t if the point is within a c comment delimited by \"/*\" \"*/\"" + (bison--within-some-sexp-p (regexp-quote comment-start) + (regexp-quote comment-end))) + + +(defun bison--within-string-p (&optional point) + " +start from the beginning of the buffer and toggle state as un-escaped \"'s are +found." + (let ((point (or point (point))) + (in-p nil)) + (save-excursion + (beginning-of-buffer) + + (while (re-search-forward "[^\\]\"" point t) + (setq in-p (not in-p))) + + in-p))) + +;;; bison--within-braced-c-expression-p +;;; new and improved, no more recursion, does not break when literal strings +;;; contain un-matched braces +(defun bison--within-braced-c-expression-p (section) + "return t if the point is within an sexp delimited by braces \({,}\) +" + ;;(debug) + (save-excursion + (bison--within-braced-c-expression-p-h section (point)))) + +(defun bison--within-braced-c-expression-p-h (section low-pt) + " +Notes: +save excursion is done higher up, so i dont concern myself here. +" + (cond ((= section bison--pre-c-decls-section) nil) + ((= section bison--c-decls-section) + (let ((opener (save-excursion (search-backward "%{")))) + (bison--within-braced-c-expression-p-h-h opener low-pt))) + ((= section bison--bison-decls-section) + (let ((opener (save-excursion + (or (search-backward "%}" nil t) + (point-min))))) + (bison--within-braced-c-expression-p-h-h opener low-pt))) + ((= section bison--grammar-rules-section) + (let ((opener (save-excursion (bison--find-production-opener)))) + (if opener + (bison--within-braced-c-expression-p-h-h opener low-pt) + nil))) + ((= section bison--c-code-section) + t) +;; (let ((opener (save-excursion (bison--find-production-opener)))) +;; (if opener +;; (bison--within-braced-c-expression-p-h-h +;; opener low-pt 1)))) + )) + +(defun bison--within-braced-c-expression-p-h-h (high-pt low-pt) + " +Notes: +HIGH-PT goes toward (point-min), LOW-PT goes toward (point-max) +save excursion is done higher up, so i dont concern myself here. +" + (let ((pt (point))) + (let ((success nil) (count 1) (done nil)) + ;; loop until open brace found, that is not in comment or string literal + (while (and (not done) + (re-search-backward "[^%]{" high-pt t count)) ;find nearest + ;starter + (goto-char (match-end 0)) + (if (or (bison--within-c-comment-p) + (bison--within-string-p)) + + (setq count (+ count 1)) + (progn + (setq success t) + (setq done t)))) + + (if success + (let ((end-pt + (condition-case nil + (progn (forward-sexp) (point)) + (error nil)))) + (if end-pt + (if (> end-pt low-pt) + t ; then in braced-c-exp + nil) + t)) ; if no sexp close brace, then w/in + nil)))) + + +(defun bison--bison-decl-opener-p (bol eol) + "return t if the current line is a bison declaration starter +\(i.e. has a %type, %token, %right, ...\)" + (save-excursion + (goto-char bol) + (re-search-forward + (concat "^" (make-regexp (copy-list bison--declarers))) eol t))) + +(defun bison--production-opener-p (bol eol) + "return t if the current line is a line that introduces a new production" + (save-excursion + (goto-char bol) + (re-search-forward bison--production-re eol t))) + +(defun bison--find-bison-semicolon () + "return the position of next semicolon not within braces, nil otherwise" + (save-excursion + (if (search-forward ";" nil t) + (if (not (bison--within-braced-c-expression-p (bison--section-p))) + (point) + (bison--find-bison-semicolon)) + nil))) + +(defun bison--within-production-body-p (section) + "return t if the \(point\) is within the body of a production + +this procedure will fail if it is in a production header" + (save-excursion + (if (= section bison--grammar-rules-section) + (let ((current-point (point))) + (if (re-search-backward bison--production-re nil t) + t + nil)) + nil))) + +(defun bison--production-alternative-p (bol eol section) + "return t if the current line contains a \"|\" used to designate a rule +alternative" + (save-excursion + (goto-char bol) + (if (search-forward "|" eol t) + (not (bison--within-braced-c-expression-p section)) + nil))) + + +;; *************** indent functions *************** + +(defun bison--handle-indent-c-sexp (section indent-column bol) + (let* ((o-brace (re-search-backward "[^%]{" bol t)) + ) + (if o-brace + (if (save-excursion + (goto-char o-brace) + (bison--within-braced-c-expression-p section)) + (c-indent-line) + (if (= (current-indentation) o-brace) ;; if o-brace is first char + (if (not (= o-brace indent-column)) ;; but not in right spot + (progn + (back-to-indentation) + (just-no-space) + (indent-to-column indent-column)) + ;; else all is good + ) + ;; else, non-ws before o-brace, leave it alone + )) + (c-indent-line)))) + +(defun bison-indent-new-line (&optional c-sexp) + "Indent a fresh line of bison code + +assumes indenting a new line, i.e. at column 0 +" + (interactive) + + ;;(message "indent new line") + (let* ((section (bison--section-p)) + (c-sexp (or c-sexp (bison--within-braced-c-expression-p section))) + ) + (cond + (c-sexp + (cond + ((= section bison--grammar-rules-section) + (c-indent-line + (save-excursion + (forward-line -1) + (let ((bol (save-excursion (beginning-of-line) (point))) + (eol (save-excursion (end-of-line) (point)))) + (if (bison--production-opener-p bol eol) + (list + (cons 'defun-block-intro + (progn + (re-search-forward bison--production-re) ; SIGERR + (- (re-search-forward "[^ \t]") ; SIGERR + 1)))) + nil))))) + (t (c-indent-line)))) + ((= section bison--pre-c-decls-section) + (c-indent-line)) +;;; ((= section bison--c-decls-section) ; is on column 0 anyway +;;; (indent-to-column 0) +;;; ) + ((= section bison--bison-decls-section) + (indent-to-column bison-decl-token-column)) + ((= section bison--grammar-rules-section) + (indent-to-column + (save-excursion + (let* ((bound (or (save-excursion (bison--find-production-opener)) + (bison--find-grammar-begin))) + (prev-semi (search-backward ";" bound t)) + ) + (if prev-semi + (if (bison--within-braced-c-expression-p section) ; CRACK + bison-rule-enumeration-column + 0) + (if (save-excursion (bison--find-production-opener)) + bison-rule-enumeration-column + 0)))))) + ((= section bison--c-code-section)) ;;leave-alone + ))) + +(defun bison-indent-line () + "Indent a line of bison code +" + (interactive) + + ;;(message "indent-line") + (let* ((pos (- (point-max) (point))) + (reset-pt (function (lambda () + (if (> (- (point-max) pos) (point)) + (goto-char (- (point-max) pos)))))) + (bol (save-excursion (beginning-of-line) (point))) + (eol (save-excursion (end-of-line) (point))) + ) + (let* ((section (bison--section-p)) + (c-sexp (bison--within-braced-c-expression-p section)) + (ws-line (line-of-whitespace-p)) + ) + (cond + ;; if you are a line of whitespace, let indent-new-line take care of it + (ws-line + (bison-indent-new-line c-sexp)) + + ((= section bison--pre-c-decls-section) + ;; leave things alone + ) + + ((= section bison--c-decls-section) + (if c-sexp + (bison--handle-indent-c-sexp section 0 bol) + (if (not (= (current-indentation) 0)) + (progn + (back-to-indentation) + (just-no-space) + (function reset-pt))))) + + ((= section bison--bison-decls-section) + (let ((opener (bison--bison-decl-opener-p bol eol))) + (cond + (opener + (goto-char opener) + (skip-chars-forward " \t" eol) + (if (looking-at "{") + (save-excursion + (if (following-non-ws-p) + (progn + (forward-char 1) + (just-no-space) + (newline) + (bison-indent-new-line t)))) + (let ((complete-type t)) + (if (looking-at "<") + (progn + (setq complete-type nil) + (if (not (= (current-column) bison-decl-type-column)) + (progn + (just-no-space) + (indent-to-column bison-decl-type-column)) + (and (re-search-forward + (concat "<" bison--word-constituent-re "+>") + eol t) + (setq complete-type t))))) + (and complete-type + (skip-chars-forward " \t" eol) + (looking-at + (concat "\\(" bison--word-constituent-re "\\|'\\)")) + (if (not (= (current-column) bison-decl-token-column)) + (progn + (just-no-space) + (indent-to-column bison-decl-token-column)))))) + (funcall reset-pt)) + (c-sexp + (bison--handle-indent-c-sexp section 0 bol)) + (t + (back-to-indentation) + ;; only tab in names, leave comments alone + (cond (;; put word-constiuents in bison-decl-token-column + (looking-at bison--word-constituent-re) + (if (not (= (current-column) bison-decl-token-column)) + (progn + (just-no-space) + (indent-to-column bison-decl-token-column)))) + ;; put/keep close-brace in the 0 column + ((looking-at "}") + (if (not (= (current-column) 0)) + (just-no-space))) + ;; leave comments alone + ((looking-at (regexp-quote comment-start)) nil) + ;; else do nothing + ) + (funcall reset-pt))))) + ((= section bison--grammar-rules-section) + (cond + ((bison--production-opener-p bol eol) + (beginning-of-line) + (re-search-forward bison--production-re);; SIGERR + (if (following-non-ws-p) + (if (> (current-column) bison-rule-enumeration-column) + (progn + (just-no-space) + (newline) + (indent-to-column bison-rule-enumeration-column)) + (save-excursion + (re-search-forward bison--word-constituent-re);; SIGERR + (let ((col (current-column))) + (cond ((> col (+ 1 bison-rule-enumeration-column)) + (forward-char -1) + (just-no-space) + (indent-to-column bison-rule-enumeration-column)) + ((< col (+ 1 bison-rule-enumeration-column)) + (forward-char -1) + (indent-to-column + bison-rule-enumeration-column))))))) + (funcall reset-pt)) + ((bison--production-alternative-p bol eol section) + (back-to-indentation);; should put point on "|" + (if (not (= (current-column) bison-rule-separator-column)) + (progn + (just-no-space) + (indent-to-column bison-rule-separator-column))) + (forward-char 1) + (if (following-non-ws-p) + (save-excursion + (re-search-forward bison--word-constituent-re);; SIGERR + (let ((col (current-column))) + (cond ((> col (+ 1 bison-rule-enumeration-column)) + (forward-char -1) + (just-no-space) + (indent-to-column bison-rule-enumeration-column)) + ((< col (+ 1 bison-rule-enumeration-column)) + (forward-char -1) + (indent-to-column + bison-rule-enumeration-column)))))) + (funcall reset-pt)) + (c-sexp + (bison--handle-indent-c-sexp + section bison-rule-enumeration-column bol) + (funcall reset-pt)) + ((bison--within-production-body-p section) + (back-to-indentation) + (if (not (= (current-column) bison-rule-enumeration-column)) + (progn + (just-no-space) + (indent-to-column + bison-rule-enumeration-column))) + (funcall reset-pt)) + (t + (let ((cur-ind (current-indentation))) + (if (eq (save-excursion (search-backward "}" bol t)) + cur-ind) + (if (not (= cur-ind bison-rule-enumeration-column)) + (progn + (back-to-indentation) + (just-no-space) + (indent-to-column bison-rule-enumeration-column) + (funcall reset-pt))) + ;; else leave alone + ))))) + ((= section bison--c-code-section) + (c-indent-line)) + )))) + +;; *************** electric-functions *************** + +(defun bison-electric-colon (arg) + "If the colon <:> delineates a production, + then insert a semicolon on the next line in the BISON-RULE-SEPARATOR-COLUMN, + put the cursor in the BISON-RULE-ENUMERATION-COLUMN for the beginning + of the rule + else just run self-insert-command +A colon delineates a production by the fact that it is immediately preceded by +a word(alphanumerics or '_''s), and there is no previous white space. +" + (interactive "P") + + (self-insert-command (prefix-numeric-value arg)) + (if (and bison-electric-colon-v + (not bison-all-electricity-off)) + (if (and (= bison--grammar-rules-section (bison--section-p)) + (bison--production-p) + (not (bison--within-started-production-p))) + (progn + (save-excursion ; put in a closing semicolon + (newline) + (indent-to-column bison-rule-separator-column) + (insert ";")) + (save-excursion ; remove opening whitespace + (if (re-search-backward + "\\s " + (save-excursion (beginning-of-line) (point)) + t) + (just-no-space))) + (if (not (< (current-column) bison-rule-enumeration-column)) + (newline)) + (indent-to-column bison-rule-enumeration-column))) + )) + +(defun bison-electric-pipe (arg) + "If the pipe <|> is used as a rule separator within a production, + then move it into BISON-RULE-SEPARATOR-COLUMN + indent to BISON-RULE-ENUMERATION-COLUMN on the same line + else just run self-insert-command +" + (interactive "P") + + (if (and bison-electric-pipe-v + (not bison-all-electricity-off) + (= bison--grammar-rules-section (bison--section-p)) + (line-of-whitespace-p) + ) + (progn + (beginning-of-line) + (just-no-space) + (indent-to-column bison-rule-separator-column) + (self-insert-command (prefix-numeric-value arg)) + (indent-to-column bison-rule-enumeration-column) + ) + (self-insert-command (prefix-numeric-value arg)))) + +(defun bison-electric-open-brace (arg) + "used for the opening brace of a C action definition for production rules, +if there is only whitespace before \(point\), then put open-brace in +bison-rule-enumeration-column" + (interactive "P") + + (if (and bison-electric-open-brace-v + (not bison-all-electricity-off)) + (let ((section (bison--section-p))) + (cond ((and (= section bison--grammar-rules-section) + (not (bison--within-braced-c-expression-p section)) + (not (previous-non-ws-p))) + (if (not (= (current-column) bison-rule-enumeration-column)) + (progn + (just-no-space) + (indent-to-column bison-rule-enumeration-column)))) + ((and (= section bison--bison-decls-section) + (not (bison--within-braced-c-expression-p section)) + (not (previous-non-ws-p))) + (if (not (= (current-column) 0)) + (progn + (just-no-space) + (indent-to-column 0))))))) + + (self-insert-command (prefix-numeric-value arg))) + + +(defun bison-electric-close-brace (arg) + "If the close-brace \"}\" is used as the c-declarations section closer +in \"%}\", then make sure the \"%}\" indents to the beginning of the line" + (interactive "P") + + (self-insert-command (prefix-numeric-value arg)) + + (if (and bison-electric-close-brace-v + (not bison-all-electricity-off)) + (cond ((search-backward "%}" (- (point) 2) t) + (if (= (bison--section-p) bison--c-decls-section) + (progn + (just-no-space) + (forward-char 2)) ; for "%}" + (forward-char 1))) + ))) + +(defun bison-electric-semicolon (arg) + "if the semicolon is used to end a production, then place it in +bison-rule-separator-column + +a semicolon is deemed to be used for ending a production if it is not found +within braces + +this is just self-insert-command as i have yet to write the actual +bison-electric-semicolon function yet +" + (interactive "P") + + (self-insert-command (prefix-numeric-value arg))) + +(defun bison-electric-percent (arg) + "if the percent is a declarer in the bison declaration's section, +then put it in the 0 column +" + (interactive "P") + + (if (and bison-electric-percent-v + (not bison-all-electricity-off)) + (let ((section (bison--section-p))) + (if (and (= section bison--bison-decls-section) + (not (bison--within-braced-c-expression-p section)) + (not (previous-non-ws-p)) + (not (= (current-column) 0))) + (just-no-space)))) + + (self-insert-command (prefix-numeric-value arg))) + +(defun bison-electric-less-than (arg) + "if the less-than is a type declarer opener for tokens in the bison +declaration section, then put it in the bison-decl-type-column column +" + (interactive "P") + + (if (and bison-electric-less-than-v + (not bison-all-electricity-off)) + (if (and (= (bison--section-p) bison--bison-decls-section) + (bison--bison-decl-opener-p + (save-excursion (beginning-of-line) (point)) + (point))) + (progn + (just-no-space) + (indent-to-column bison-decl-type-column)))) + + (self-insert-command (prefix-numeric-value arg))) + +(defun bison-electric-greater-than (arg) + "if the greater-than is a type declarer closer for tokens in the bison +declaration section, then indent to bison-decl-token-column +" + (interactive "P") + + (self-insert-command (prefix-numeric-value arg)) + + (if (and bison-electric-greater-than-v + (not bison-all-electricity-off)) + (let ((current-pt (point)) + (bol (save-excursion (beginning-of-line) (point)))) + (if (and (= (bison--section-p) bison--bison-decls-section) + (bison--bison-decl-opener-p bol (point))) + (if (search-backward "<" bol t) + (if (re-search-forward + (concat "<" bison--word-constituent-re "+>") + current-pt t) + (if (not (following-non-ws-p)) + (progn + (just-no-space) + (indent-to-column bison-decl-token-column))))))))) + +;(defun bison-electric-semicolon (arg) +; "if the semicolon is used to end a production, then place it in +;bison-rule-separator-column + +;a semicolon is deemed to be used for ending a production if it is not found +;within braces +;" +; (interactive "P") +; (if (and (not (bison--within-braced-c-expression-p)) +; (line-of-whitespace-p) +; ( +; (progn +; (just-no-space) ;; remove extraneous whitespace +; (indent-to-column bison-rule-separator-column))) + +; (self-insert-command (prefix-numeric-value arg))) + +;; *************** other *************** + +;(defun bison--confirm-productions-closed () +; (save-excursion +; (goto-char (point-max)) +; (if (re-search-forward "^%%" nil t) + + +(provide 'bison-mode) + +;; *************** end of code *************** \ No newline at end of file diff --git a/.config/emacs/games/snake-scores b/.config/emacs/games/snake-scores new file mode 100644 index 0000000..f240b45 --- /dev/null +++ b/.config/emacs/games/snake-scores @@ -0,0 +1,2 @@ +49 luke Luke T. Shumaker Tue Feb 11 09:24:43 2014 +21 luke Luke T. Shumaker Tue Feb 11 09:25:26 2014 diff --git a/.config/emacs/games/tetris-scores b/.config/emacs/games/tetris-scores new file mode 100644 index 0000000..1d0a5dd --- /dev/null +++ b/.config/emacs/games/tetris-scores @@ -0,0 +1,117 @@ +1568 luke Luke T. Shumaker Mon Mar 24 16:13:39 2014 +1562 luke Luke T. Shumaker Mon Mar 24 16:13:39 2014 +1556 luke Luke T. Shumaker Mon Mar 24 16:13:39 2014 +1550 luke Luke T. Shumaker Mon Mar 24 16:13:39 2014 +1290 luke Luke T. Shumaker Sat Feb 15 23:25:37 2014 +1222 luke Luke T. Shumaker Wed Feb 12 09:43:00 2014 +1182 luke Luke T. Shumaker Thu Jan 30 08:36:01 2014 +1176 luke Luke T. Shumaker Thu Jan 30 08:36:01 2014 +1176 luke Luke T. Shumaker Fri Feb 7 15:22:51 2014 +1171 luke Luke T. Shumaker Fri Feb 7 15:22:51 2014 +1170 luke Luke T. Shumaker Thu Jan 30 08:36:01 2014 +1166 luke Luke T. Shumaker Fri Feb 7 15:22:51 2014 +1165 luke Luke T. Shumaker Thu Jan 30 08:36:01 2014 +1161 luke Luke T. Shumaker Fri Feb 7 15:22:50 2014 +1124 luke Luke T. Shumaker Tue Feb 18 22:12:36 2014 +1118 luke Luke T. Shumaker Tue Feb 18 22:12:36 2014 +1113 luke Luke T. Shumaker Tue Feb 18 22:12:36 2014 +1107 luke Luke T. Shumaker Tue Feb 18 22:12:36 2014 +1103 luke Luke T. Shumaker Tue Feb 11 09:15:22 2014 +1102 luke Luke T. Shumaker Tue Jan 28 19:22:11 2014 +1101 luke Luke T. Shumaker Tue Feb 18 22:12:35 2014 +1095 luke Luke T. Shumaker Tue Feb 18 22:12:35 2014 +1090 luke Luke T. Shumaker Tue Feb 18 22:12:35 2014 +1084 luke Luke T. Shumaker Tue Feb 18 22:12:35 2014 +1078 luke Luke T. Shumaker Tue Feb 18 22:12:35 2014 +1077 luke Luke T. Shumaker Tue Jan 28 09:29:45 2014 +1072 luke Luke T. Shumaker Tue Feb 18 22:12:35 2014 +1067 luke Luke T. Shumaker Tue Feb 18 22:12:35 2014 +1061 luke Luke T. Shumaker Tue Feb 18 22:12:35 2014 +1055 luke Luke T. Shumaker Tue Feb 18 22:12:34 2014 +1005 luke Luke T. Shumaker Tue Feb 11 08:54:47 2014 +999 luke Luke T. Shumaker Tue Feb 11 08:54:47 2014 +994 luke Luke T. Shumaker Tue Feb 11 08:54:47 2014 +992 luke Luke T. Shumaker Mon Mar 24 13:43:08 2014 +988 luke Luke T. Shumaker Tue Feb 11 08:54:47 2014 +986 luke Luke T. Shumaker Mon Mar 24 13:43:08 2014 +975 luke Luke T. Shumaker Mon Mar 24 13:43:07 2014 +919 luke Luke T. Shumaker Sat Jan 25 11:23:58 2014 +914 luke Luke T. Shumaker Sat Jan 25 11:23:57 2014 +913 luke Luke T. Shumaker Mon Jan 13 11:11:55 2014 +908 luke Luke T. Shumaker Sat Jan 25 11:23:57 2014 +902 luke Luke T. Shumaker Sat Jan 25 11:23:57 2014 +897 luke Luke T. Shumaker Sat Jan 25 11:23:56 2014 +896 luke Luke T. Shumaker Wed Jan 29 09:43:19 2014 +891 luke Luke T. Shumaker Sat Jan 25 11:23:56 2014 +885 luke Luke T. Shumaker Sat Jan 25 11:23:56 2014 +879 luke Luke T. Shumaker Sat Jan 25 11:23:56 2014 +874 luke Luke T. Shumaker Sat Jan 25 11:23:56 2014 +868 luke Luke T. Shumaker Sat Jan 25 11:23:48 2014 +862 luke Luke T. Shumaker Sat Jan 25 11:23:48 2014 +856 luke Luke T. Shumaker Sat Jan 25 11:23:48 2014 +809 luke Luke T. Shumaker Tue Jan 28 18:37:25 2014 +778 luke Luke T. Shumaker Fri Feb 14 11:05:16 2014 +775 luke Luke T. Shumaker Tue Jan 28 18:01:57 2014 +773 luke Luke T. Shumaker Mon Jan 13 10:47:30 2014 +772 luke Luke T. Shumaker Fri Feb 14 11:05:15 2014 +770 luke Luke T. Shumaker Tue Jan 28 18:01:57 2014 +769 luke Luke T. Shumaker Tue Jan 28 18:07:12 2014 +766 luke Luke T. Shumaker Fri Feb 14 11:05:15 2014 +765 luke Luke T. Shumaker Tue Jan 28 18:01:53 2014 +760 luke Luke T. Shumaker Tue Jan 28 18:01:53 2014 +760 luke Luke T. Shumaker Fri Feb 14 11:05:14 2014 +755 luke Luke T. Shumaker Fri Feb 14 11:05:13 2014 +754 luke Luke T. Shumaker Tue Jan 28 18:01:52 2014 +749 luke Luke T. Shumaker Tue Jan 28 18:01:52 2014 +749 luke Luke T. Shumaker Fri Feb 14 11:05:13 2014 +744 luke Luke T. Shumaker Fri Feb 14 11:05:13 2014 +743 luke Luke T. Shumaker Tue Jan 28 18:01:52 2014 +742 luke Luke T. Shumaker Thu Feb 6 09:05:53 2014 +738 luke Luke T. Shumaker Tue Jan 28 18:01:51 2014 +738 luke Luke T. Shumaker Fri Feb 14 11:05:13 2014 +736 luke Luke T. Shumaker Thu Feb 6 09:05:52 2014 +733 luke Luke T. Shumaker Tue Jan 28 18:01:51 2014 +732 luke Luke T. Shumaker Fri Feb 14 11:05:13 2014 +730 luke Luke T. Shumaker Thu Feb 6 09:05:51 2014 +727 luke Luke T. Shumaker Tue Jan 28 18:01:51 2014 +727 luke Luke T. Shumaker Fri Feb 14 11:05:12 2014 +724 luke Luke T. Shumaker Thu Feb 6 09:05:51 2014 +721 luke Luke T. Shumaker Tue Jan 28 18:01:51 2014 +718 luke Luke T. Shumaker Thu Feb 6 09:05:51 2014 +715 luke Luke T. Shumaker Tue Jan 28 18:01:51 2014 +712 luke Luke T. Shumaker Thu Feb 6 09:05:51 2014 +709 luke Luke T. Shumaker Tue Jan 28 18:01:50 2014 +706 luke Luke T. Shumaker Thu Feb 6 09:05:49 2014 +700 luke Luke T. Shumaker Thu Feb 6 09:05:49 2014 +695 luke Luke T. Shumaker Thu Feb 6 09:05:49 2014 +689 luke Luke T. Shumaker Thu Feb 6 09:05:49 2014 +684 luke Luke T. Shumaker Thu Feb 6 09:05:48 2014 +679 luke Luke T. Shumaker Thu Feb 6 09:05:48 2014 +674 luke Luke T. Shumaker Thu Feb 6 09:05:48 2014 +668 luke Luke T. Shumaker Thu Feb 6 09:05:48 2014 +662 luke Luke T. Shumaker Thu Feb 6 09:05:47 2014 +477 luke Luke T. Shumaker Wed Jan 29 09:27:06 2014 +471 luke Luke T. Shumaker Wed Jan 29 09:27:06 2014 +465 luke Luke T. Shumaker Wed Jan 29 09:27:05 2014 +460 luke Luke T. Shumaker Wed Jan 29 09:27:05 2014 +455 luke Luke T. Shumaker Wed Jan 29 09:27:04 2014 +451 luke Luke T. Shumaker Mon Mar 24 10:01:11 2014 +449 luke Luke T. Shumaker Wed Jan 29 09:27:04 2014 +445 luke Luke T. Shumaker Mon Mar 24 10:01:11 2014 +443 luke Luke T. Shumaker Wed Jan 29 09:27:03 2014 +439 luke Luke T. Shumaker Mon Mar 24 10:01:11 2014 +437 luke Luke T. Shumaker Wed Jan 29 09:27:03 2014 +433 luke Luke T. Shumaker Mon Mar 24 10:01:10 2014 +431 luke Luke T. Shumaker Wed Jan 29 09:27:02 2014 +425 luke Luke T. Shumaker Wed Jan 29 09:27:02 2014 +419 luke Luke T. Shumaker Wed Jan 29 09:26:58 2014 +414 luke Luke T. Shumaker Wed Jan 29 09:26:58 2014 +408 luke Luke T. Shumaker Wed Jan 29 09:26:58 2014 +397 luke Luke T. Shumaker Sat Feb 22 00:58:33 2014 +143 luke Luke T. Shumaker Tue Jan 28 08:59:20 2014 +64 luke Luke T. Shumaker Mon Jan 13 10:42:46 2014 +19 luke Luke T. Shumaker Tue Jan 14 08:59:55 2014 +0 luke Luke T. Shumaker Mon Jan 13 10:47:31 2014 +0 luke Luke T. Shumaker Wed Jan 15 15:18:32 2014 +0 luke Luke T. Shumaker Tue Jan 28 09:29:48 2014 +0 luke Luke T. Shumaker Fri Feb 7 15:22:51 2014 diff --git a/.config/emacs/init.el b/.config/emacs/init.el index 2dfa5cb..7471fd0 100644 --- a/.config/emacs/init.el +++ b/.config/emacs/init.el @@ -4,7 +4,7 @@ (setq notify-method 'notify-via-libnotify) (add-to-list 'load-path "~/.emacs.d/") (add-to-list 'load-path "~/.emacs.d/el-get/el-get") -(setq server-auth-dir (locate-user-emacs-file "server/") (getenv "HOSTNAME")) +;(setq server-auth-dir (locate-user-emacs-file "server/") (getenv "HOSTNAME")) (setq custom-file "~/.emacs.d/custom.el") ; derived from ELPA installation diff --git a/.config/emacs/tetris.el b/.config/emacs/tetris.el new file mode 100644 index 0000000..25fc61b --- /dev/null +++ b/.config/emacs/tetris.el @@ -0,0 +1,641 @@ +;;; tetris.el --- implementation of Tetris for Emacs + +;; Copyright (C) 1997, 2001-2013 Free Software Foundation, Inc. + +;; Author: Glynn Clements +;; Version: 2.01 +;; Created: 1997-08-13 +;; Keywords: games + +;; This file is part of GNU Emacs. + +;; GNU Emacs 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 3 of the License, or +;; (at your option) any later version. + +;; GNU Emacs 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 GNU Emacs. If not, see . + +;;; Commentary: + +;;; Code: + +(eval-when-compile (require 'cl-lib)) + +(require 'gamegrid) + +;; ;;;;;;;;;;;;; customization variables ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +(defgroup tetris nil + "Play a game of Tetris." + :prefix "tetris-" + :group 'games) + +(defcustom tetris-use-glyphs t + "Non-nil means use glyphs when available." + :group 'tetris + :type 'boolean) + +(defcustom tetris-use-color t + "Non-nil means use color when available." + :group 'tetris + :type 'boolean) + +(defcustom tetris-draw-border-with-glyphs t + "Non-nil means draw a border even when using glyphs." + :group 'tetris + :type 'boolean) + +(defcustom tetris-default-tick-period 0.3 + "The default time taken for a shape to drop one row." + :group 'tetris + :type 'number) + +(defcustom tetris-update-speed-function + 'tetris-default-update-speed-function + "Function run whenever the Tetris score changes. +Called with two arguments: (SHAPES ROWS) +SHAPES is the number of shapes which have been dropped. +ROWS is the number of rows which have been completed. + +If the return value is a number, it is used as the timer period." + :group 'tetris + :type 'function) + +(defcustom tetris-mode-hook nil + "Hook run upon starting Tetris." + :group 'tetris + :type 'hook) + +(defcustom tetris-tty-colors + ["blue" "white" "yellow" "magenta" "cyan" "green" "red"] + "Vector of colors of the various shapes in text mode." + :group 'tetris + :type (let ((names `("Shape 1" "Shape 2" "Shape 3" + "Shape 4" "Shape 5" "Shape 6" "Shape 7")) + (result nil)) + (while names + (add-to-list 'result + (cons 'choice + (cons :tag + (cons (car names) + (mapcar (lambda (color) + (list 'const color)) + (defined-colors))))) + t) + (setq names (cdr names))) + result)) + +(defcustom tetris-x-colors + [[0 0 1] [0.7 0 1] [1 1 0] [1 0 1] [0 1 1] [0 1 0] [1 0 0]] + "Vector of colors of the various shapes." + :group 'tetris + :type 'sexp) + +(defcustom tetris-buffer-name "*Tetris*" + "Name used for Tetris buffer." + :group 'tetris + :type 'string) + +(defcustom tetris-buffer-width 30 + "Width of used portion of buffer." + :group 'tetris + :type 'number) + +(defcustom tetris-buffer-height 22 + "Height of used portion of buffer." + :group 'tetris + :type 'number) + +(defcustom tetris-width 10 + "Width of playing area." + :group 'tetris + :type 'number) + +(defcustom tetris-height 20 + "Height of playing area." + :group 'tetris + :type 'number) + +(defcustom tetris-top-left-x 3 + "X position of top left of playing area." + :group 'tetris + :type 'number) + +(defcustom tetris-top-left-y 1 + "Y position of top left of playing area." + :group 'tetris + :type 'number) + +(defvar tetris-next-x (+ (* 2 tetris-top-left-x) tetris-width) + "X position of next shape.") + +(defvar tetris-next-y tetris-top-left-y + "Y position of next shape.") + +(defvar tetris-score-x tetris-next-x + "X position of score.") + +(defvar tetris-score-y (+ tetris-next-y 6) + "Y position of score.") + +;; It is not safe to put this in /tmp. +;; Someone could make a symlink in /tmp +;; pointing to a file you don't want to clobber. +(defvar tetris-score-file "tetris-scores" +;; anybody with a well-connected server want to host this? +;(defvar tetris-score-file "/anonymous@ftp.pgt.com:/pub/cgw/tetris-scores" + "File for holding high scores.") + +;; ;;;;;;;;;;;;; display options ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +(defvar tetris-blank-options + '(((glyph colorize) + (t ?\040)) + ((color-x color-x) + (mono-x grid-x) + (color-tty color-tty)) + (((glyph color-x) [0 0 0]) + (color-tty "black")))) + +(defvar tetris-cell-options + '(((glyph colorize) + (emacs-tty ?O) + (t ?\040)) + ((color-x color-x) + (mono-x mono-x) + (color-tty color-tty) + (mono-tty mono-tty)) + ;; color information is taken from tetris-x-colors and tetris-tty-colors + )) + +(defvar tetris-border-options + '(((glyph colorize) + (t ?\+)) + ((color-x color-x) + (mono-x grid-x) + (color-tty color-tty)) + (((glyph color-x) [0.5 0.5 0.5]) + (color-tty "white")))) + +(defvar tetris-space-options + '(((t ?\040)) + nil + nil)) + +;; ;;;;;;;;;;;;; constants ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +(defconst tetris-shapes + [[[[0 0] [1 0] [0 1] [1 1]]] + + [[[0 0] [1 0] [2 0] [2 1]] + [[1 -1] [1 0] [1 1] [0 1]] + [[0 -1] [0 0] [1 0] [2 0]] + [[1 -1] [2 -1] [1 0] [1 1]]] + + [[[0 0] [1 0] [2 0] [0 1]] + [[0 -1] [1 -1] [1 0] [1 1]] + [[2 -1] [0 0] [1 0] [2 0]] + [[1 -1] [1 0] [1 1] [2 1]]] + + [[[0 0] [1 0] [1 1] [2 1]] + [[1 0] [0 1] [1 1] [0 2]]] + + [[[1 0] [2 0] [0 1] [1 1]] + [[0 0] [0 1] [1 1] [1 2]]] + + [[[1 0] [0 1] [1 1] [2 1]] + [[1 0] [1 1] [2 1] [1 2]] + [[0 1] [1 1] [2 1] [1 2]] + [[1 0] [0 1] [1 1] [1 2]]] + + [[[0 0] [1 0] [2 0] [3 0]] + [[1 -1] [1 0] [1 1] [1 2]]]] + "Each shape is described by a vector that contains the coordinates of +each one of its four blocks.") + +;;the scoring rules were taken from "xtetris". Blocks score differently +;;depending on their rotation + +(defconst tetris-shape-scores + [[6] [6 7 6 7] [6 7 6 7] [6 7] [6 7] [5 5 6 5] [5 8]] ) + +(defconst tetris-shape-dimensions + [[2 2] [3 2] [3 2] [3 2] [3 2] [3 2] [4 1]]) + +(defconst tetris-blank 7) + +(defconst tetris-border 8) + +(defconst tetris-space 9) + +(defun tetris-default-update-speed-function (_shapes rows) + (/ 20.0 (+ 50.0 rows))) + +;; ;;;;;;;;;;;;; variables ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +(defvar tetris-shape 0) +(defvar tetris-rot 0) +(defvar tetris-next-shape 0) +(defvar tetris-n-shapes 0) +(defvar tetris-n-rows 0) +(defvar tetris-score 0) +(defvar tetris-pos-x 0) +(defvar tetris-pos-y 0) +(defvar tetris-pos-y-final 0) +(defvar tetris-paused nil) + +(make-variable-buffer-local 'tetris-shape) +(make-variable-buffer-local 'tetris-rot) +(make-variable-buffer-local 'tetris-next-shape) +(make-variable-buffer-local 'tetris-n-shapes) +(make-variable-buffer-local 'tetris-n-rows) +(make-variable-buffer-local 'tetris-score) +(make-variable-buffer-local 'tetris-pos-x) +(make-variable-buffer-local 'tetris-pos-y) +(make-variable-buffer-local 'tetris-paused) + +;; ;;;;;;;;;;;;; keymaps ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +(defvar tetris-mode-map + (let ((map (make-sparse-keymap 'tetris-mode-map))) + (define-key map "n" 'tetris-start-game) + (define-key map "q" 'tetris-end-game) + (define-key map "p" 'tetris-pause-game) + + (define-key map " " 'tetris-move-bottom) + (define-key map [left] 'tetris-move-left) + (define-key map [right] 'tetris-move-right) + (define-key map [up] 'tetris-rotate-prev) + (define-key map [down] 'tetris-rotate-next) + map)) + +(defvar tetris-null-map + (let ((map (make-sparse-keymap 'tetris-null-map))) + (define-key map "n" 'tetris-start-game) + map)) + +;; ;;;;;;;;;;;;;;;; game functions ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +(defun tetris-display-options () + (let ((options (make-vector 256 nil))) + (dotimes (c 256) + (aset options c + (cond ((= c tetris-blank) + tetris-blank-options) + ((and (>= c 0) (<= c 6)) + (append + tetris-cell-options + `((((glyph color-x) ,(aref tetris-x-colors c)) + (color-tty ,(aref tetris-tty-colors c)) + (t nil))))) + ((= c tetris-border) + tetris-border-options) + ((= c tetris-space) + tetris-space-options) + (t + '(nil nil nil))))) + options)) + +(defun tetris-get-tick-period () + (if (boundp 'tetris-update-speed-function) + (let ((period (apply tetris-update-speed-function + tetris-n-shapes + tetris-n-rows nil))) + (and (numberp period) period)))) + +(defun tetris-get-shape-cell (block) + (aref (aref (aref tetris-shapes + tetris-shape) tetris-rot) + block)) + +(defun tetris-shape-width () + (aref (aref tetris-shape-dimensions tetris-shape) 0)) + +(defun tetris-shape-rotations () + (length (aref tetris-shapes tetris-shape))) + +(defun tetris-draw-score () + (let ((strings (vector (format "Shapes: %05d" tetris-n-shapes) + (format "Rows: %05d" tetris-n-rows) + (format "Score: %05d" tetris-score)))) + (dotimes (y 3) + (let* ((string (aref strings y)) + (len (length string))) + (dotimes (x len) + (gamegrid-set-cell (+ tetris-score-x x) + (+ tetris-score-y y) + (aref string x))))))) + +(defun tetris-update-score () + (tetris-draw-score) + (let ((period (tetris-get-tick-period))) + (if period (gamegrid-set-timer period)))) + +(defun tetris-new-shape () + (setq tetris-shape tetris-next-shape) + (setq tetris-rot 0) + (setq tetris-next-shape (random 7)) + (setq tetris-pos-x (/ (- tetris-width (tetris-shape-width)) 2)) + (setq tetris-pos-y 0) + (if (tetris-test-shape) + (tetris-end-game) + (tetris-draw-shape) + (tetris-draw-next-shape) + (tetris-update-score))) + +(defun tetris-draw-next-shape () + (dotimes (x 4) + (dotimes (y 4) + (gamegrid-set-cell (+ tetris-next-x x) + (+ tetris-next-y y) + tetris-blank))) + (dotimes (i 4) + (let ((tetris-shape tetris-next-shape) + (tetris-rot 0)) + (gamegrid-set-cell (+ tetris-next-x + (aref (tetris-get-shape-cell i) 0)) + (+ tetris-next-y + (aref (tetris-get-shape-cell i) 1)) + tetris-shape)))) + +(defun tetris-draw-shape () + (dotimes (i 4) + (let ((c (tetris-get-shape-cell i))) + (gamegrid-set-cell (+ tetris-top-left-x + tetris-pos-x + (aref c 0)) + (+ tetris-top-left-y + tetris-pos-y + (aref c 1)) + tetris-shape)))) + +(defun tetris-erase-shape () + (dotimes (i 4) + (let ((c (tetris-get-shape-cell i))) + (gamegrid-set-cell (+ tetris-top-left-x + tetris-pos-x + (aref c 0)) + (+ tetris-top-left-y + tetris-pos-y + (aref c 1)) + tetris-blank)))) + +(defun tetris-test-shape () + (let ((hit nil)) + (dotimes (i 4) + (unless hit + (setq hit + (let* ((c (tetris-get-shape-cell i)) + (xx (+ tetris-pos-x + (aref c 0))) + (yy (+ tetris-pos-y + (aref c 1)))) + (or (>= xx tetris-width) + (>= yy tetris-height) + (/= (gamegrid-get-cell + (+ xx tetris-top-left-x) + (+ yy tetris-top-left-y)) + tetris-blank)))))) + hit)) + +(defun tetris-full-row (y) + (let ((full t)) + (dotimes (x tetris-width) + (if (= (gamegrid-get-cell (+ tetris-top-left-x x) + (+ tetris-top-left-y y)) + tetris-blank) + (setq full nil))) + full)) + +(defun tetris-shift-row (y) + (if (= y 0) + (dotimes (x tetris-width) + (gamegrid-set-cell (+ tetris-top-left-x x) + (+ tetris-top-left-y y) + tetris-blank)) + (dotimes (x tetris-width) + (let ((c (gamegrid-get-cell (+ tetris-top-left-x x) + (+ tetris-top-left-y y -1)))) + (gamegrid-set-cell (+ tetris-top-left-x x) + (+ tetris-top-left-y y) + c))))) + +(defun tetris-shift-down () + (dotimes (y0 tetris-height) + (when (tetris-full-row y0) + (setq tetris-n-rows (1+ tetris-n-rows)) + (cl-loop for y from y0 downto 0 do + (tetris-shift-row y))))) + +(defun tetris-draw-border-p () + (or (not (eq gamegrid-display-mode 'glyph)) + tetris-draw-border-with-glyphs)) + +(defun tetris-init-buffer () + (gamegrid-init-buffer tetris-buffer-width + tetris-buffer-height + tetris-space) + (let ((buffer-read-only nil)) + (if (tetris-draw-border-p) + (cl-loop for y from -1 to tetris-height do + (cl-loop for x from -1 to tetris-width do + (gamegrid-set-cell (+ tetris-top-left-x x) + (+ tetris-top-left-y y) + tetris-border)))) + (dotimes (y tetris-height) + (dotimes (x tetris-width) + (gamegrid-set-cell (+ tetris-top-left-x x) + (+ tetris-top-left-y y) + tetris-blank))) + (if (tetris-draw-border-p) + (cl-loop for y from -1 to 4 do + (cl-loop for x from -1 to 4 do + (gamegrid-set-cell (+ tetris-next-x x) + (+ tetris-next-y y) + tetris-border)))))) + +(defun tetris-reset-game () + (gamegrid-kill-timer) + (tetris-init-buffer) + (setq tetris-next-shape (random 7)) + (setq tetris-shape 0 + tetris-rot 0 + tetris-pos-x 0 + tetris-pos-y 0 + tetris-n-shapes 0 + tetris-n-rows 0 + tetris-score 0 + tetris-paused nil) + (tetris-new-shape)) + +(defun tetris-shape-done () + (tetris-shift-down) + (setq tetris-n-shapes (1+ tetris-n-shapes)) + (setq tetris-score + (+ tetris-score + (aref (aref tetris-shape-scores tetris-shape) tetris-rot))) + (tetris-update-score) + (tetris-new-shape)) + +(defun tetris-update-game (tetris-buffer) + "Called on each clock tick. +Drops the shape one square, testing for collision." + (if (and (not tetris-paused) + (eq (current-buffer) tetris-buffer)) + (let (hit) + (tetris-erase-shape) + (setq tetris-pos-y (1+ tetris-pos-y)) + (setq hit (tetris-test-shape)) + (if hit + (setq tetris-pos-y (1- tetris-pos-y))) + (tetris-draw-shape) + (if hit + (tetris-shape-done))))) + +(defun tetris-move-bottom () + "Drop the shape to the bottom of the playing area." + (interactive) + (unless tetris-paused + (let ((hit nil)) + (tetris-erase-shape) + (while (not hit) + (setq tetris-pos-y (1+ tetris-pos-y)) + (setq hit (tetris-test-shape))) + (setq tetris-pos-y (1- tetris-pos-y)) + (tetris-draw-shape) + (tetris-shape-done)))) + +(defun tetris-move-left () + "Move the shape one square to the left." + (interactive) + (unless tetris-paused + (tetris-erase-shape) + (setq tetris-pos-x (1- tetris-pos-x)) + (if (tetris-test-shape) + (setq tetris-pos-x (1+ tetris-pos-x))) + (tetris-draw-shape))) + +(defun tetris-move-right () + "Move the shape one square to the right." + (interactive) + (unless tetris-paused + (tetris-erase-shape) + (setq tetris-pos-x (1+ tetris-pos-x)) + (if (tetris-test-shape) + (setq tetris-pos-x (1- tetris-pos-x))) + (tetris-draw-shape))) + +(defun tetris-rotate-prev () + "Rotate the shape clockwise." + (interactive) + (unless tetris-paused + (tetris-erase-shape) + (setq tetris-rot (% (+ 1 tetris-rot) + (tetris-shape-rotations))) + (if (tetris-test-shape) + (setq tetris-rot (% (+ 3 tetris-rot) + (tetris-shape-rotations)))) + (tetris-draw-shape))) + +(defun tetris-rotate-next () + "Rotate the shape anticlockwise." + (interactive) + (unless tetris-paused + (tetris-erase-shape) + (setq tetris-rot (% (+ 3 tetris-rot) + (tetris-shape-rotations))) + (if (tetris-test-shape) + (setq tetris-rot (% (+ 1 tetris-rot) + (tetris-shape-rotations)))) + (tetris-draw-shape))) + +(defun tetris-end-game () + "Terminate the current game." + (interactive) + (gamegrid-kill-timer) + (use-local-map tetris-null-map) + (gamegrid-add-score tetris-score-file tetris-score)) + +(defun tetris-start-game () + "Start a new game of Tetris." + (interactive) + (tetris-reset-game) + (use-local-map tetris-mode-map) + (let ((period (or (tetris-get-tick-period) + tetris-default-tick-period))) + (gamegrid-start-timer period 'tetris-update-game))) + +(defun tetris-pause-game () + "Pause (or resume) the current game." + (interactive) + (setq tetris-paused (not tetris-paused)) + (message (and tetris-paused "Game paused (press p to resume)"))) + +(defun tetris-active-p () + (eq (current-local-map) tetris-mode-map)) + +(put 'tetris-mode 'mode-class 'special) + +(define-derived-mode tetris-mode nil "Tetris" + "A mode for playing Tetris." + + (add-hook 'kill-buffer-hook 'gamegrid-kill-timer nil t) + + (use-local-map tetris-null-map) + + (unless (featurep 'emacs) + (setq mode-popup-menu + '("Tetris Commands" + ["Start new game" tetris-start-game] + ["End game" tetris-end-game + (tetris-active-p)] + ["Pause" tetris-pause-game + (and (tetris-active-p) (not tetris-paused))] + ["Resume" tetris-pause-game + (and (tetris-active-p) tetris-paused)]))) + + (setq show-trailing-whitespace nil) + + (setq gamegrid-use-glyphs tetris-use-glyphs) + (setq gamegrid-use-color tetris-use-color) + + (gamegrid-init (tetris-display-options))) + +;;;###autoload +(defun tetris () + "Play the Tetris game. +Shapes drop from the top of the screen, and the user has to move and +rotate the shape to fit in with those at the bottom of the screen so +as to form complete rows. + +tetris-mode keybindings: + \\ +\\[tetris-start-game] Starts a new game of Tetris +\\[tetris-end-game] Terminates the current game +\\[tetris-pause-game] Pauses (or resumes) the current game +\\[tetris-move-left] Moves the shape one square to the left +\\[tetris-move-right] Moves the shape one square to the right +\\[tetris-rotate-prev] Rotates the shape clockwise +\\[tetris-rotate-next] Rotates the shape anticlockwise +\\[tetris-move-bottom] Drops the shape to the bottom of the playing area + +" + (interactive) + + (select-window (or (get-buffer-window tetris-buffer-name) + (selected-window))) + (switch-to-buffer tetris-buffer-name) + (gamegrid-kill-timer) + (tetris-mode) + (tetris-start-game)) + +(provide 'tetris) + +;;; tetris.el ends here diff --git a/.config/gtk-3.0/bookmarks b/.config/gtk-3.0/bookmarks index 85af107..e309295 100644 --- a/.config/gtk-3.0/bookmarks +++ b/.config/gtk-3.0/bookmarks @@ -3,3 +3,4 @@ file:///home/luke/Music file:///home/luke/Pictures file:///home/luke/Videos file:///home/luke/Downloads +file:///home/luke/Documents/school/2014.1 diff --git a/.config/okular/.gitignore b/.config/okular/.gitignore deleted file mode 100644 index 4e33b14..0000000 --- a/.config/okular/.gitignore +++ /dev/null @@ -1 +0,0 @@ -docdata diff --git a/.config/ssh/known_hosts b/.config/ssh/known_hosts index 05249dc..ec8e1f9 100644 --- a/.config/ssh/known_hosts +++ b/.config/ssh/known_hosts @@ -15,7 +15,8 @@ localhost ecdsa-sha2-nistp256 AAAAE2VjZHNhLXNoYTItbmlzdHAyNTYAAAAIbmlzdHAyNTYAAABBBOSvqkBsdEjQ2XBhUl0+zQvhsliQNv+EwWyPAVPZA0FcEHBXc5Bo7/QDPotN+jn6hU/Ri8hihH3LSvc6MsyzDRU= #TL-WR740N-v1,192.168.1.1 ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAAAgm18Q4WoIZt9WT8qNL5eolEEc3CvLAzgcAQfIDbrSRtumIUOSsJcaCy/Avg2c1rT3pVUc+5amnSavqGTZAW+r0F07cAn+/TAAFjz39ZjrjXNHu65KcCiOjOHUWfrnG/KZHsNw7B+o0I7RCVVKU82GIUecM9kGIpDIaYH2vYzaRxEqAk= TL-WR740N-v4,192.168.2.1,192.168.1.2 ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAAAglvfI+QX0vhuSjv1kSCgxrsUUtk2/ibnWkN0yBDn3bBvD22ob5OY4SujAKu6AD96Xn4oSU7YwM7X/FaA1d5Av2iLK8v2Bz1bMWsL1LGLtLg9FpiOgix11mjnEIGZoXfsrARjkAyiFaRpETiOSfV4gGUxLhgEzWLHpOU4koHQD3Jf4Ys= -build64-par,192.168.2.161 ecdsa-sha2-nistp256 AAAAE2VjZHNhLXNoYTItbmlzdHAyNTYAAAAIbmlzdHAyNTYAAABBBIAGyEB6rfXZc71rZ/p+9wh50VZOC3KHlqJiLtbK9KWMFkBmSOqm3FvuqA0fl7Z1+XqxZY69vJ2ZmQ8G/UIZtIw= +[lukeshu.com]:1863,[199.180.255.147]:1863,[projectleaguer.net]:1863 ecdsa-sha2-nistp256 AAAAE2VjZHNhLXNoYTItbmlzdHAyNTYAAAAIbmlzdHAyNTYAAABBBJ7RUMtkyw4vL6AnDaTe9BQnJcrfZ3wgE1Y2zOaQ7IN76faZ0NhlKPSmwykEZxAHRD3f/2RgFDN/nWsJO7rwZSU= +[lukeshu.com]:1864,[199.180.255.147]:1864,build64-par,192.168.1.161,192.168.2.161 ecdsa-sha2-nistp256 AAAAE2VjZHNhLXNoYTItbmlzdHAyNTYAAAAIbmlzdHAyNTYAAABBBIAGyEB6rfXZc71rZ/p+9wh50VZOC3KHlqJiLtbK9KWMFkBmSOqm3FvuqA0fl7Z1+XqxZY69vJ2ZmQ8G/UIZtIw= # Parabola boxes [rshg054.dnsready.net]:1863 ecdsa-sha2-nistp256 AAAAE2VjZHNhLXNoYTItbmlzdHAyNTYAAAAIbmlzdHAyNTYAAABBBAiQk3J39s6vsfkDo7Y63FfTiHCyT97gCC+GbUa9wUuRZt2+wv8Ds9M8lOUsTQH5z/5zgfZst0qUrsN+ijusUGs= @@ -23,10 +24,21 @@ build64-par,192.168.2.161 [repo.parabolagnulinux.org]:1863,[wiki.parabolagnulinux.org]:1863,[80.87.131.252]:1863 ecdsa-sha2-nistp256 AAAAE2VjZHNhLXNoYTItbmlzdHAyNTYAAAAIbmlzdHAyNTYAAABBBK4pzgrqj2qrklFpDZrg56bjVHJyodEtvdU/QUQNPgErfjfn0BJRi4N2zL19VK5ab3kJ6zJrfY7YWOv/Ky+MqUw= # Purdue boxes -data.cs.purdue.edu,128.10.3.13,128.10.12.13,128.10.19.13,128.10.25.13 ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDCtyfydMrSci3BMTrS6GO9gKTxVMrM+7+ZI7t+pI7k+kRnz6prOftFZ3ySLD+4GDrxTKZkRnIr7pB6IPuSDg+++AAJ/isR5j0NhI+zfdMvNdAzw1j0d4EnFE3VLslR98VInxZaLTLm6QokotzIcxjqylzTca/GKwmcsBtSDMdRDp5xI+zlwacUlFUM8J2QNji/6uYCdU19YEbWzyYYWgNqopTAT04SExBnWuPi/ktpnSd0BPbfX51Bzc2Tp3/ro6KF3JGq3a/NC3qwVt45ThoGskZVZxbausJa2v+3wSFbrtsfJcHBjsboFZv8lwVAuD7r4sYuVGlGblpCs7OBM6Sx +borg01.cs.purdue.edu,128.10.12.101 ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDkIEyFa1k4QSfj/Dx6Dsc71TPof23dEj6bZhHwHO8/MrETk9GC/XZVXqzktO2Rr6TMl4AuFhZ5yp9UVuCqPvHKOvf5x40wgwL5Izgd9HN84StMDkwQl/N6hPUTACZYaoByl5xEnhO6O5P7HucCSGH1bHQvjSKJYyAaJ2xlZjwE/uoHRgnfkVU7RhrpBlCtjTVG5ktePJWeAUE3XcNzZg/GL66mYJk0deu8qfILMR9fh0mPZ2LbFLhvlzcLXBR5dpekzdfs/TjRC63eewWpTER4CAKYyZ+dOXXYk+uvZt+xHm3wSS0h/YO0GHsy179HlIvMdzFSv+Txqdwx6IumaJzt +borg02.cs.purdue.edu,128.10.12.102 ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDUzl4VM51gWk1trUOJ0exymiG2AtP5PV/DRRsvZ20aY0NIRt4/QbBx8h5HBgSBuaR9X85ybyJrIGS3pnvAzr42OVj80ZMWkDkuCjFXPPThyf3LSUD0pmoKzoSC6mLy4uAVDL7NNqQo6X/aFKPxsR2eIB5IesiBSvb2/q8vIISU0gUkXlV515vCENd5I6Lpi3ZKJANZar54mU8Eh065957y4whX47LsO3mexnkzoRMwGnxDlhQfHzQUy/LW6mJIyKda050FPvImUzFusKaTn7vQzoM5AmxUtOoZe/PsDdPvfmh0mm1W01WPvY/S6YvrKM0pc1jRV7qKaYvC38c5e7fr +borg04.cs.purdue.edu,128.10.12.104 ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQCoAr3zuEMACnvJOS9oz6CfypDFWuqdIg61YGqekhxJPzSXpLTFM+KPjjmAFX7YsDjaMsWmRU9wu+yg8Bw/MtZ+qa2+K+UmS/JM/cfswmTj8cdzrJ6p9H3ZTfg22phqMjX9XgD4Ed5u5tU/My49V6VzQNyjJXU6k7/p38BDsLwBFw2cChqFp3jvmYwsQOY6LM6XVD175dSsyDaCSYXpvAvkF4xARKLF/TyarkFT/CNdrcms8PQmxk5GEtk2fjUsJKUCwoU+H8VRCRk3ypUxp92yQV+/WSuEVEFsnemkVMRoGQZE1BfnbYnoQuXPm0EipU20e+uZtvxx5BIKiSw+2Oln +borg06.cs.purdue.edu,128.10.12.106 ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDT6ACw5pc6fWnBTv6Cf13Io4b2hoUKU+TqlLNA2/YftD11gHQqNPMx5fbO8aDpArAu6WuYMFpPlZlS7fL00NgdJYnPbyaGpOUpOOtSFzkTnFOnLqQBWwLNmVLPU62iX/5iyp4kWfvfUTy3J/8ritDP4QYEzNSebeKw8W7s+y3pVjMYzcG7t4c6faJ102s7jwz7DjBzxHgpbmeNNRGVQ7wdBmK2DcYbaCyU1uK5eRuqc7Ten/uUskB4mRdqcgrRS9agl52tPjSUMxEUWtGace72GYGTTVVwRGtz+w3gUisvgtqC6C2QsE/JmL4Fwyf5X/mMj2yF3L0yU+E3FgtHIX/x +borg09.cs.purdue.edu,128.10.12.109 ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDHrYNseZSmB8jLkj3OdziXZS02rjkqP4BL7r2uNWDEhg5oa8HPs6sanT+cq2gjkJ/bDXaY2NdSJN6fKrnRM5mlFXaRC9ANuLV2JJ3mzoXSk8uC6DO2kDZRWOeoOOmM20Imsl1QdJ9G2rf5NXGdbwV3MBQCwjpZtJJ3nIUW+zteOCV+Vdvz5aq5cwA4C+e0bJEK8Llk05wWCEhm0w91mtRlRBHUXNZlKIadYvr/5CIDToFLpFaa6p8upgFkGvPJBO+KxPJJdwVM5JD2H2jg2ZavGxW2+qWldyLSJkT7LQoub1z8einzkgYtQ/CET0CUZr45mFb92ijnI6nYa1mdjk+Z +borg10.cs.purdue.edu,128.10.12.110 ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDIFc205BQT1csdqm7nfd22zR+LraDWtmMpqVqPFOlckQXeZQh4ANnmf1xc2orCl8g/PWfzJMLMYjnBdsSqusmfqDhLHZ+FYBt8Hgxe5pX7wLG7Og+7NYuoP5ktaUUg5h19Fm6tz1P/Eb5TOMtoZIwMLhnM94j87JAIVXHJgWs6JOzfJCHHce82vC916d0oEjaXeAD8z+LBKk29SDnYu/Yz5X2tRRc6FyymBD7uMQQl7hUjAcVcXAKLizCqueYpBx5PoZpQ0ficXghXwL6hNBF9AFkFC4iIn+ZxmKbXu9PH3sJCdX2eu/I7KecS3vYW3GWausTbVGysLDaArg6DoiK3 +borg11.cs.purdue.edu,128.10.12.111 ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQC3/eruxcGUuWDYP+QmWhKdViYmg9vW7JeGKLDh6/CC5SHSCGdDHF+PauvyiBDQd3otVdDljlGJHFAC2OfEqBneVaoVyQrvLdFU7nAH/h43lBLMguo7ijr1GV6PzD93HEqgVDMoyiXw2m/v71KOEZCW66WcxGlTpj+jFrju8amsq9/9SYMNBIli9SCwSMx5kD4FRUvrJF6UfJnPZHG9Ql9LXqAp9tLFKXmKExC7CzUuagX0jWUeeh4CLjwI3Koc85v1gl7rUbJfUbLrSrZx+TElx3a+1iccl5xiMqIVlz7rbfv8v6z7oPsLxvAZy4gGkm82iQw//VBg/HAoJdrUK08f +data.cs.purdue.edu,128.10.2.13,128.10.3.13,128.10.12.13,128.10.19.13,128.10.25.13 ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDCtyfydMrSci3BMTrS6GO9gKTxVMrM+7+ZI7t+pI7k+kRnz6prOftFZ3ySLD+4GDrxTKZkRnIr7pB6IPuSDg+++AAJ/isR5j0NhI+zfdMvNdAzw1j0d4EnFE3VLslR98VInxZaLTLm6QokotzIcxjqylzTca/GKwmcsBtSDMdRDp5xI+zlwacUlFUM8J2QNji/6uYCdU19YEbWzyYYWgNqopTAT04SExBnWuPi/ktpnSd0BPbfX51Bzc2Tp3/ro6KF3JGq3a/NC3qwVt45ThoGskZVZxbausJa2v+3wSFbrtsfJcHBjsboFZv8lwVAuD7r4sYuVGlGblpCs7OBM6Sx lore.cs.purdue.edu,128.10.19.16,128.10.12.16,128.10.2.16 ssh-rsa AAAAB3NzaC1yc2EAAAABIwAAAIEAwUosAIGVQllz1G63GNL9azhBefzXdLgvbMY4e/yENMkIACyz0dfZwdQ3cMTFEsUW1y5FjVx/V272KwmdfG9aS+jyHpRAiZGz8vDa9NrleAvhvpQtAIXsQILjeWqtVAVjbm5J5Su73J98UITUr62ZJCYgt621BSS0ooZEo8UKjk8= sage.ics.purdue.edu,128.210.10.101 ssh-rsa AAAAB3NzaC1yc2EAAAABIwAAAIEA1MzqxWILPbf4voIPXLSf8oDHxgKpq8UlWAyy6EoYeZ7NjQoirMmLvl8TBHz54+gVEjDhDHdoKkXvF/DYvwm3Zo8ezGyNPZ++fRkKCq0gcjOJ/0hotI3xZi397KywlbzYiQt6hDn68ojMnjPZsKOPaBLW3Q6SBWw2b4hGIYVn13s= sslab01.cs.purdue.edu,128.10.25.101 ssh-rsa AAAAB3NzaC1yc2EAAAABIwAAAIEAtG71s38pNzCH/UTPrAUecaSTrSRokSBYPM7Xmts/jbzyadKePGCjMafODc3YSHtSvBbK6uCKPyv+dkH8a4FZ7IBeTtR6Q/30eijyeFdCizqs3THljWZG5zP6NBU7GnP+0FXPqIlvpnaD+6Unj8aW66AER+BBhF2IAK9H/Uxl7cM= +sslab02.cs.purdue.edu,128.10.25.102 ssh-rsa AAAAB3NzaC1yc2EAAAABIwAAAIEAunmGlLKqSIYZAMYlAVVnc1rM9ml5YGjoaOHSiuNhdx0S0ZpTus985lT1Piu/LVrjF/WGNWnxVwvFcdIpCXIpOMQzuA6Ys8zsn4CdbaApYgMGQVcFOhNp6Iw/7aDqV7tud3cq7K1RdnLgdpi2Qw8TcKp3ChF/YWvro2xbZjEzQhk= +sslab14.cs.purdue.edu,128.10.25.114 ssh-rsa AAAAB3NzaC1yc2EAAAABIwAAAIEAuLhRZpjP/NlE1vZMZOHkCCvsK5qg2W67qtFbR//5INnu2Z4Vn14jRpJhT5HeX9fedROWMrOvaYWcSB7GEFilc5klb2xrIU1AKrFwjRfEEYQW9iN22O5WrS+qtftWulWeOn49ZNodaCW29M4FHcn2TGUGDXrtMttf1iJHEGYPFF8= +sslab15.cs.purdue.edu,128.10.25.115 ssh-rsa AAAAB3NzaC1yc2EAAAABIwAAAIEAugZ5wO3dUWugYhf3D/t5BcA7JC0SgPWLvhw9nzcfxQXIkw402eSiwVinr2+LuQN+WW7Mg5WGPUspeEGchpjTBftN+eTfMyD0WJFtW+QHusSiroCMqgzrqSD09/uA1EYV1GkAlcrAk+PCdypUeXoNSPiPUNNlxP1TdDQMmAzR4AE= +sslab23.cs.purdue.edu,128.10.25.123 ssh-rsa AAAAB3NzaC1yc2EAAAABIwAAAQEA0IoqibnOlNzCsSKGSbiK4re22WxFSaG6/qO1zqHzWqBMj/VOWvdPmxsGefdBEShke6YMxKduZGtQp3ET2ozF6kzCrFbcsjzNuwIX6UW/TqGz10rJnCYAll79R/DxpsaLH+z2h+zdWRLZFbOi00VPq+gLh511otvhgmJKRqeUn491/rwZSxlvhXoRJOv/1poWuwT+MRx3AB8+DlrTE1J69XoP1s5HartD6dyJ2jwdN3S5sdvLEif6yLkpVCmzKkkMc0i9VL2t5p8XRZrwHKEUjbvCrhks1wRSuWXU3mFtpqiXm+I3mcj3uSRDWIK58ZKuZ3yts9v0R98IGQSSdMkKRQ== # TigerTech boxes mckenzierobotics.org,mckenzierobotics.org.customers.tigertech.net,64.62.209.14,208.80.4.102 ssh-rsa AAAAB3NzaC1yc2EAAAABIwAAAIEAwcC508sMM/yiVjrYYHA2bIPRlmMVrIvUzIg9NC3X3iqUF2r6YKO1WUbTDEBv3mDdCggwGuRlkjlPIhF4jAWiOUqzzVqbMy+Vq6AVQTAbx1xPTB18OvrR61LcIuQu1Rw4b+60ufQRjChHCPTnJbSwbUrizdHjxh+qe+2omzDUfDs= @@ -38,15 +50,7 @@ github.com,192.30.252.129,192.30.252.131,204.232.175.90,207.97.227.239 teenteam.biz,50.63.32.1 ssh-dss AAAAB3NzaC1kc3MAAACBAImo1tvV5/AxMKvit1Iv1WqgQ/30fyHjmtnDbhiYv53lLPAEFevB59zZ65/94AFd/ZyUoy62Qv3nMFvKaZmAto96mvsgE9w3BU96Y2hxFIje/hmMwkfFMO2sJ9Gi6Rn4NA8ZK31dnoazzPberbluvNZOlBL1jPZczVStW+RtGyM7AAAAFQDQ3dx1MJ3eXuee4tUP3D+oj/jWQQAAAIA29gAWOcSWMHfUb1F6n6fIcpQ4aCZZLVRNOzpoCIsJOiqxZTN/HEelYnE/Tf7SoUTORot4bJDEwifm0i96B9zeqJeJzc56Tmw5EtIJYyJbTyUF02Cl3OqAUpbEf+bA7dtcYIims+QJzyCN7lWkczvMf0dSUPZtN/B3MxjWDRKEMgAAAIAG6+Rw+OvOJvKsZlkFd3wGD6w8tVKQ7LfcagWLL4MzJzEAN2UXBycCc1UPmZTmPWHDiyB7syoVmDTw78OOMqDTtXrmXDnNm+sPTqPlbgeUtIKMVWFGQmmXjghOeNxqqs+2iGnqdpM390Mm4D4qXGbZu6d7BluYBfUISU+5+i5hHQ== gitorious.org,87.238.52.168 ssh-rsa AAAAB3NzaC1yc2EAAAABIwAAAQEAwurz6NXf01Lc2HTGvPGN2RRIjW5zZ4qI8dCTdhr6R241VXO30X29EpBPRFTe3K9Zx7BXAM1XzQaV093xT8jX6X0gP/vJD2y+vDN2IDx2GeLX1k0cevhCj2mn8Su3ZWw5s9bBhVvpSvrE9uLRho2Qe/x5hJt2804KDyRGWn3esVP2dYRbf4r4TBLX/oWziDv64x5G0SkY8YsX2ZbKSX1Biw4oQXSx5jKOaCjNS+ryJFVmiIBqHa7Voi3LgJT/lHZV39sKbMNcnsQNjtkB1eqzzvdwO5RPfF0YbwjFQ5SywmrtkAqYmDOOPUDrvDChbbrS7hge4rDK/oeVjwdV718jVw== -128.10.2.13 ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDCtyfydMrSci3BMTrS6GO9gKTxVMrM+7+ZI7t+pI7k+kRnz6prOftFZ3ySLD+4GDrxTKZkRnIr7pB6IPuSDg+++AAJ/isR5j0NhI+zfdMvNdAzw1j0d4EnFE3VLslR98VInxZaLTLm6QokotzIcxjqylzTca/GKwmcsBtSDMdRDp5xI+zlwacUlFUM8J2QNji/6uYCdU19YEbWzyYYWgNqopTAT04SExBnWuPi/ktpnSd0BPbfX51Bzc2Tp3/ro6KF3JGq3a/NC3qwVt45ThoGskZVZxbausJa2v+3wSFbrtsfJcHBjsboFZv8lwVAuD7r4sYuVGlGblpCs7OBM6Sx -borg06.cs.purdue.edu,128.10.12.106 ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDT6ACw5pc6fWnBTv6Cf13Io4b2hoUKU+TqlLNA2/YftD11gHQqNPMx5fbO8aDpArAu6WuYMFpPlZlS7fL00NgdJYnPbyaGpOUpOOtSFzkTnFOnLqQBWwLNmVLPU62iX/5iyp4kWfvfUTy3J/8ritDP4QYEzNSebeKw8W7s+y3pVjMYzcG7t4c6faJ102s7jwz7DjBzxHgpbmeNNRGVQ7wdBmK2DcYbaCyU1uK5eRuqc7Ten/uUskB4mRdqcgrRS9agl52tPjSUMxEUWtGace72GYGTTVVwRGtz+w3gUisvgtqC6C2QsE/JmL4Fwyf5X/mMj2yF3L0yU+E3FgtHIX/x -borg11.cs.purdue.edu,128.10.12.111 ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQC3/eruxcGUuWDYP+QmWhKdViYmg9vW7JeGKLDh6/CC5SHSCGdDHF+PauvyiBDQd3otVdDljlGJHFAC2OfEqBneVaoVyQrvLdFU7nAH/h43lBLMguo7ijr1GV6PzD93HEqgVDMoyiXw2m/v71KOEZCW66WcxGlTpj+jFrju8amsq9/9SYMNBIli9SCwSMx5kD4FRUvrJF6UfJnPZHG9Ql9LXqAp9tLFKXmKExC7CzUuagX0jWUeeh4CLjwI3Koc85v1gl7rUbJfUbLrSrZx+TElx3a+1iccl5xiMqIVlz7rbfv8v6z7oPsLxvAZy4gGkm82iQw//VBg/HAoJdrUK08f - -parabolagnulinux.org,142.4.205.9 ecdsa-sha2-nistp256 AAAAE2VjZHNhLXNoYTItbmlzdHAyNTYAAAAIbmlzdHAyNTYAAABBBHkqv9ewWyXjrO6P5iYiUYfEYP8ALBg9C2GxA7yOJDa/vwDtx6OS3KMNRkUgx6vL/6/D555Xdypys+lwLmcdmnM= -[lukeshu.com]:1863,[199.180.255.147]:1863 ecdsa-sha2-nistp256 AAAAE2VjZHNhLXNoYTItbmlzdHAyNTYAAAAIbmlzdHAyNTYAAABBBJ7RUMtkyw4vL6AnDaTe9BQnJcrfZ3wgE1Y2zOaQ7IN76faZ0NhlKPSmwykEZxAHRD3f/2RgFDN/nWsJO7rwZSU= -192.168.1.1 ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAAAgwCha20d/qpyDSrfa2ZV0izgwZ+91XL7TyfdHIkMfdaIlv3qxCXWV5FBzFGsg+9m4p7h1WO0J2KL53MRNaG6qtyxnLZaNe3pVxKwmNbDC4cYlwaumM17p5nnFKu9/qyreNEmbtvGExipPvYi9qULNM8vzLZcMSpDNV6WrudEfrW1hvd/ -192.30.252.130 ssh-rsa AAAAB3NzaC1yc2EAAAABIwAAAQEAq2A7hRGmdnm9tUDbO9IDSwBK6TbQa+PXYPCPy6rbTrTtw7PHkccKrpp0yVhp5HdEIcKr6pLlVDBfOLX9QUsyCOV0wzfjIJNlGEYsdlLJizHhbn2mUjvSAHQqZETYP81eFzLQNnPHt4EVVUh7VfDESU84KezmD5QlWpXLmvU31/yMf+Se8xhHTvKSCZIFImWwoG6mbUoWf9nzpIoaSjB+weqqUUmpaaasXVal72J+UX2B+2RPW3RcT0eOzQgqlJL3RKrTJvdsjE3JEAvGq3lGHSZXy28G3skua2SmVi/w4yCE6gbODqnTWlg7+wC604ydGXA8VJiS5ap43JXiUFFAaQ== -projects.parabolagnulinux.org ecdsa-sha2-nistp256 AAAAE2VjZHNhLXNoYTItbmlzdHAyNTYAAAAIbmlzdHAyNTYAAABBBHkqv9ewWyXjrO6P5iYiUYfEYP8ALBg9C2GxA7yOJDa/vwDtx6OS3KMNRkUgx6vL/6/D555Xdypys+lwLmcdmnM= -[bugs.parabolagnulinux.org]:1863,[174.142.147.197]:1863 ecdsa-sha2-nistp256 AAAAE2VjZHNhLXNoYTItbmlzdHAyNTYAAAAIbmlzdHAyNTYAAABBBAiQk3J39s6vsfkDo7Y63FfTiHCyT97gCC+GbUa9wUuRZt2+wv8Ds9M8lOUsTQH5z/5zgfZst0qUrsN+ijusUGs= -borg04.cs.purdue.edu,128.10.12.104 ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQCoAr3zuEMACnvJOS9oz6CfypDFWuqdIg61YGqekhxJPzSXpLTFM+KPjjmAFX7YsDjaMsWmRU9wu+yg8Bw/MtZ+qa2+K+UmS/JM/cfswmTj8cdzrJ6p9H3ZTfg22phqMjX9XgD4Ed5u5tU/My49V6VzQNyjJXU6k7/p38BDsLwBFw2cChqFp3jvmYwsQOY6LM6XVD175dSsyDaCSYXpvAvkF4xARKLF/TyarkFT/CNdrcms8PQmxk5GEtk2fjUsJKUCwoU+H8VRCRk3ypUxp92yQV+/WSuEVEFsnemkVMRoGQZE1BfnbYnoQuXPm0EipU20e+uZtvxx5BIKiSw+2Oln -192.30.252.128 ssh-rsa AAAAB3NzaC1yc2EAAAABIwAAAQEAq2A7hRGmdnm9tUDbO9IDSwBK6TbQa+PXYPCPy6rbTrTtw7PHkccKrpp0yVhp5HdEIcKr6pLlVDBfOLX9QUsyCOV0wzfjIJNlGEYsdlLJizHhbn2mUjvSAHQqZETYP81eFzLQNnPHt4EVVUh7VfDESU84KezmD5QlWpXLmvU31/yMf+Se8xhHTvKSCZIFImWwoG6mbUoWf9nzpIoaSjB+weqqUUmpaaasXVal72J+UX2B+2RPW3RcT0eOzQgqlJL3RKrTJvdsjE3JEAvGq3lGHSZXy28G3skua2SmVi/w4yCE6gbODqnTWlg7+wC604ydGXA8VJiS5ap43JXiUFFAaQ== +# Unsorted +192.30.252.128 ssh-rsa AAAAB3NzaC1yc2EAAAABIwAAAQEAq2A7hRGmdnm9tUDbO9IDSwBK6TbQa+PXYPCPy6rbTrTtw7PHkccKrpp0yVhp5HdEIcKr6pLlVDBfOLX9QUsyCOV0wzfjIJNlGEYsdlLJizHhbn2mUjvSAHQqZETYP81eFzLQNnPHt4EVVUh7VfDESU84KezmD5QlWpXLmvU31/yMf+Se8xhHTvKSCZIFImWwoG6mbUoWf9nzpIoaSjB+weqqUUmpaaasXVal72J+UX2B+2RPW3RcT0eOzQgqlJL3RKrTJvdsjE3JEAvGq3lGHSZXy28G3skua2SmVi/w4yCE6gbODqnTWlg7+wC604ydGXA8VJiS5ap43JXiUFFAaQ== +192.30.252.130 ssh-rsa AAAAB3NzaC1yc2EAAAABIwAAAQEAq2A7hRGmdnm9tUDbO9IDSwBK6TbQa+PXYPCPy6rbTrTtw7PHkccKrpp0yVhp5HdEIcKr6pLlVDBfOLX9QUsyCOV0wzfjIJNlGEYsdlLJizHhbn2mUjvSAHQqZETYP81eFzLQNnPHt4EVVUh7VfDESU84KezmD5QlWpXLmvU31/yMf+Se8xhHTvKSCZIFImWwoG6mbUoWf9nzpIoaSjB+weqqUUmpaaasXVal72J+UX2B+2RPW3RcT0eOzQgqlJL3RKrTJvdsjE3JEAvGq3lGHSZXy28G3skua2SmVi/w4yCE6gbODqnTWlg7+wC604ydGXA8VJiS5ap43JXiUFFAaQ== +2a02:c0:1014::1 ssh-rsa AAAAB3NzaC1yc2EAAAABIwAAAQEAwurz6NXf01Lc2HTGvPGN2RRIjW5zZ4qI8dCTdhr6R241VXO30X29EpBPRFTe3K9Zx7BXAM1XzQaV093xT8jX6X0gP/vJD2y+vDN2IDx2GeLX1k0cevhCj2mn8Su3ZWw5s9bBhVvpSvrE9uLRho2Qe/x5hJt2804KDyRGWn3esVP2dYRbf4r4TBLX/oWziDv64x5G0SkY8YsX2ZbKSX1Biw4oQXSx5jKOaCjNS+ryJFVmiIBqHa7Voi3LgJT/lHZV39sKbMNcnsQNjtkB1eqzzvdwO5RPfF0YbwjFQ5SywmrtkAqYmDOOPUDrvDChbbrS7hge4rDK/oeVjwdV718jVw== -- cgit v1.2.3