Advertisement
Not a member of Pastebin yet?
Sign Up,
it unlocks many cool features!
- (defvar haxe-folding-delimiters '(?\ ?\t ?\n)
- "Characters used to delimit the words when padding a region")
- (defvar haxe-folding-terminators '(?\- ?\. ?\, ?\? ?\! ?\; ?\: ?\) ?\] ?\")
- "Characters that terminate words when padding a region")
- (defvar haxe-folding-exceptions
- '((?\. . ?\)) (?\. . ?\") (?\. . ?\') (?\. . ?\]) (?\. . ?\.)
- (?\! . ?\)) (?\! . ?\") (?\! . ?\') (?\! . ?\]) (?\! . ?\.)
- (?\! . ?\!) (?\! . ?\?) (?\? . ?\)) (?\? . ?\") (?\? . ?\')
- (?\? . ?\]) (?\? . ?\.) (?\? . ?\!) (?\? . ?\?))
- "Character pairs that should not be split, when word-wrapping a region,
- unless there is only one word in the line")
- (defun exception-p (first-char second-char exceptions)
- "Werifies whether the EXCEPTIONS contains a pair (FIRST-CHAR SECOND-CHAR)"
- (dolist (i exceptions)
- (when (and (char-equal (car i) first-char)
- (char-equal (cdr i) second-char))
- (return t))))
- (defun read-word (input position delimiters ends exceptions)
- "Reads the first word from the INPUT, starting from position. The word
- is a substring that may be terminated by any of the ENDS characters, or
- before any of DELIMITERS characters. However, if the last character of
- the word is the `car' of any of EXCEPTION pairs and the character that follows
- that character is that same pairs `cdr', then the word is not terminated
- and the process is repeated until the next DELIMITER or END is encountered."
- (let (word char)
- (catch 't
- (while (< position (length input))
- (setq char (aref input position))
- (cond
- ((member char delimiters)
- (if (and (< position (1- (length input)))
- (exception-p char (aref input (1+ position)) exceptions))
- (setq word (cons char word))
- (throw 't t)))
- ((member char ends)
- (setq word (cons char word))
- (unless (and (< position (1- (length input)))
- (exception-p char (aref input (1+ position)) exceptions))
- (throw 't t)))
- (t (setq word (cons char word))))
- (incf position)))
- (coerce (reverse word) 'string)))
- (defun fold-string-words
- (input max-length &optional pad-left pad-right delimiters ends exceptions)
- "Creates a block of text which has no more than MAX-LENGTH characters
- in one line, is padded by PAD-LEFT characters on the left and PAD-RIGHT
- characters on the right. The text will break words only when the word is
- longer then MAX-LENGTH.
- DELIMITERS are the characters which cannot be part of the word.
- ENDS are the characters that end a word.
- EXCEPTIONS are the pairs of characters (an assoc list) that should never be
- split, unless it is the only word on the line."
- (let* ((delimiters (or delimiters haxe-folding-delimiters))
- (ends (or ends haxe-folding-terminators))
- (exceptions
- (or exceptions haxe-folding-exceptions))
- (tab-delimiter-p (member ?\t delimiters))
- (pad-left (or pad-left 0))
- (pad-right (or pad-right 0))
- (pos 0) (line-built 0) word line-has-words next-char)
- (when (> (+ pad-right pad-left) max-length)
- (error "The sum of paddings must be smaller then the line length."))
- (with-output-to-string
- (while (< pos (length input))
- (dotimes (i pad-left)
- (princ " ")
- (incf line-built))
- (setq word (read-word input pos delimiters ends exceptions))
- (if (<= (+ line-built (length word)) (- max-length pad-right))
- (progn
- (princ word)
- (setq line-has-words t)
- (incf line-built (length word))
- (incf pos (length word))
- (when (and (< pos (1- (length input)))
- (member (aref input pos) delimiters))
- (setq next-char (aref input pos))
- (cond
- ((char-equal ?\t next-char)
- (incf pos tab-width)
- (incf line-built tab-width))
- ((char-equal ?\n next-char)
- (incf pos)
- (dotimes (i (- max-length line-built))
- (princ " "))
- (setq line-built 0 line-has-words nil)
- (terpri))
- (t (incf pos)
- (incf line-built)))
- (princ (char-to-string next-char))))
- (progn
- (if line-has-words
- (dotimes (i (- max-length line-built))
- (princ " "))
- (progn
- (princ (subseq word 0 (- max-length pad-right line-built)))
- (incf pos (- max-length pad-right line-built))
- (dotimes (i pad-right)
- (princ " "))))
- (terpri)
- (setq line-built 0 line-has-words nil)))))))
- (defun haxe-pad-region (start end width &optional prefix pad-left pad-right)
- "Creates a column from the seclected region between START and END of the
- width WIDTH.
- PREFIX argument is populated when this function is called interactively.
- With default prefix argument, the column will be padded by 1 character on the
- right and on the left. If you provide numberical argument other than default,
- then you will be prompted to provide the padding for left and right sides.
- Non-interactive callers must not provide PREFIX argument if they wish to
- specify paddings other then 0.
- See also `haxe-folding-delimiters', `haxe-folding-terminators',
- `haxe-folding-exceptions' and `fold-string-words'"
- (interactive "r\nnHow wide should the created columnbe? \nP")
- (if prefix
- (if (equal prefix 4)
- (setq pad-left (read-string "Columns to pad on the left: " prefix)
- pad-right (read-string "Columns to pad on the right: " prefix))
- (setq pad-left prefix pad-right prefix))
- (setq pad-left (or pad-left 0) pad-right (or pad-right 0)))
- (let ((input (fold-string-words
- (buffer-substring start end) width pad-left pad-right)))
- (kill-region start end)
- (insert input)))
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement