emacs SKILL mode

Discussion in 'Cadence' started by Stefan Robert, Dec 10, 2004.

  1. Does anyone know if a SKILL emacs mode exists somewhere?

    Stefan
     
    Stefan Robert, Dec 10, 2004
    #1
  2. Do a search in this group (e.g. with Google), I'm sure you'll find it!
     
    Bernd Fischer, Dec 10, 2004
    #2
  3. Stefan Robert

    A. B. Guest

    I had the same question a couple of years ago, and searched and ended up
    with a ref to a site in sweeden and another one probably a mirror in
    stuttgart but both links were broken. The ftp site at cadence also did
    not work. Then, I searched at large in the webbut with no success. I
    gave up after that.
    So, if you know for a fact where I can get it please do just reply with
    the link so everybody will benefit from it.
    Thanx

    P.S. I am just curious, what cadence developpers are using? I know it
    is a matter of taste but it most likely to be (x)emacs or vi.
     
    A. B., Dec 10, 2004
    #3
  4. Hi,

    to satisfy your curiousness there are SKILL modes
    for emacs, vim and nedit.

    I personaly use nedit, but that's personal preference.

    Listed are two files which I have in a directory, because I use nedit
    you have to know how how to use them.

    Bernd

    ;; xemacs-options ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    ;; -*- Mode: Emacs-Lisp -*-

    (setq options-file-xemacs-version '(19 14))
    (setq-default case-fold-search t)
    (setq-default overwrite-mode nil)
    (setq-default case-fold-search t)
    (setq-default case-replace t)
    (setq-default zmacs-regions t)
    (setq-default mouse-yank-at-point t)
    (setq-default teach-extended-commands-p t)
    (setq-default teach-extended-commands-timeout 2)
    (setq-default debug-on-error nil)
    (setq-default debug-on-quit nil)
    (setq-default lpr-switches nil)
    (setq-default ps-print-color-p nil)
    (setq-default ps-paper-type 'ps-letter)
    (setq-default get-frame-for-buffer-default-instance-limit nil)
    ;(setq-default temp-buffer-show-function 'il-temp-buffer-show-function)
    (setq-default font-lock-auto-fontify t)
    (setq-default font-lock-use-fonts '(or (mono) (grayscale)))
    (setq-default font-lock-use-colors '(color))
    (setq-default font-lock-maximum-decoration nil)
    (setq-default font-lock-maximum-size 256000)
    (setq-default font-lock-mode-enable-list nil)
    (setq-default font-lock-mode-disable-list nil)
    (require 'font-lock)
    (remove-hook 'font-lock-mode-hook 'turn-on-fast-lock)
    (remove-hook 'font-lock-mode-hook 'turn-on-lazy-lock)
    (require 'paren)
    (paren-set-mode 'paren)
    (if (featurep 'scrollbar) (progn (add-spec-list-to-specifier scrollbar-width
    '((global (nil . 19)))) (add-spec-list-to-specifier scrollbar-height 'nil)))
    (add-spec-list-to-specifier modeline-shadow-thickness '((global (nil . 2))))
    (setq-default truncate-lines nil)
    (setq-default bar-cursor nil)
    (setq-default buffers-menu-max-size 25)
    (setq-default complex-buffers-menu-p nil)
    (setq-default buffers-menu-sort-function
    'sort-buffers-menu-by-mode-then-alphabetically)
    (setq-default buffers-menu-grouping-function
    'group-buffers-menu-by-mode-then-alphabetically)
    (setq-default buffers-menu-submenus-for-groups-p nil)
    (setq-default font-menu-ignore-scaled-fonts nil)
    (setq-default font-menu-this-frame-only-p t)
    (if (featurep 'toolbar) (progn (set-default-toolbar-position 'top)
    (add-spec-list-to-specifier default-toolbar-visible-p '((global (nil . t))))
    (add-spec-list-to-specifier toolbar-buttons-captioned-p 'nil)))
    (setq-default browse-url-browser-function 'browse-url-netscape)
    (make-face 'font-lock-variable-name-face)
    (make-face 'font-lock-comment-face)
    (make-face 'isearch)
    (make-face 'underline)
    (make-face 'pointer)
    (make-face 'red)
    (make-face 'primary-selection)
    (make-face 'font-lock-reference-face)
    (make-face 'font-lock-string-face)
    (make-face 'bold)
    (make-face 'paren-blink-off)
    (make-face 'paren-mismatch)
    (make-face 'blue)
    (make-face 'font-lock-other-emphasized-face)
    (make-face 'modeline-buffer-id)
    (make-face 'default)
    (make-face 'green)
    (make-face 'font-lock-function-name-face)
    (make-face 'text-cursor)
    (make-face 'list-mode-item-selected)
    (make-face 'bold-italic)
    (make-face 'gui-button-face)
    (make-face 'modeline-mousable-minor-mode)
    (make-face 'paren-match)
    (make-face 'font-lock-type-face)
    (make-face 'font-lock-doc-string-face)
    (make-face 'modeline)
    (make-face 'font-lock-emphasized-face)
    (make-face 'highlight)
    (make-face 'secondary-selection)
    (make-face 'left-margin)
    (make-face 'font-lock-preprocessor-face)
    (make-face 'font-lock-keyword-face)
    (make-face 'italic)
    (make-face 'font-lock-other-type-face)
    (make-face 'yellow)
    (make-face 'modeline-mousable)
    (make-face 'right-margin)
    (make-face 'zmacs-region)
    (add-spec-list-to-specifier (face-property 'font-lock-variable-name-face
    'foreground) '((global ((color) . "blue3") ((color) . "blue"))))
    (add-spec-list-to-specifier (face-property 'font-lock-variable-name-face
    'font) '((global ((mono) . [bold]) ((grayscale) . [bold]))))
    (add-spec-list-to-specifier (face-property 'font-lock-comment-face
    'foreground) '((global ((x) . "ForestGreen") ((color) . "red"))))
    (add-spec-list-to-specifier (face-property 'font-lock-comment-face 'font)
    '((global (nil . "-*-courier-medium-o-*-*-14-*") ((mono) . [italic])
    ((grayscale) . [italic]))))
    (add-spec-list-to-specifier (face-property 'font-lock-comment-face
    'underline) '((global ((mono tty)) ((grayscale tty)))))
    (add-spec-list-to-specifier (face-property 'font-lock-comment-face
    'highlight) '((global ((mono tty) . t) ((grayscale tty) . t))))
    (add-spec-list-to-specifier (face-property 'isearch 'background) '((global
    ((color) . "paleturquoise") ((color) . "green"))))
    (add-spec-list-to-specifier (face-property 'isearch 'reverse) '((global
    ((tty) . t))))
    (add-spec-list-to-specifier (face-property 'underline 'underline) '((global
    (nil . t))))
    (add-spec-list-to-specifier (face-property 'red 'foreground) '((global
    ((color) . "red"))))
    (add-spec-list-to-specifier (face-property 'primary-selection 'foreground) 'nil)
    (add-spec-list-to-specifier (face-property 'primary-selection 'background)
    '((global ((grayscale) . "gray80") ((color) . "gray"))))
    (add-spec-list-to-specifier (face-property 'primary-selection
    'background-pixmap) '((global ((mono x) . [autodetect :data "gray3"]) ((mono
    tty) . [string :data "gray3"]))))
    (add-spec-list-to-specifier (face-property 'font-lock-reference-face
    'foreground) '((global ((color) . "red3") ((color) . "red"))))
    (add-spec-list-to-specifier (face-property 'font-lock-reference-face 'font)
    '((global ((mono) . [bold]) ((grayscale) . [bold]))))
    (add-spec-list-to-specifier (face-property 'font-lock-string-face
    'foreground) '((global ((x) . "maroon") ((color) . "green4") ((color) . "green"))))
    (add-spec-list-to-specifier (face-property 'font-lock-string-face 'font)
    '((global (nil . "-*-times-medium-r-*-*-14-*") ((mono) . [italic]) ((grayscale)
    .. [italic]))))
    (add-spec-list-to-specifier (face-property 'bold 'font) '((global (nil .
    "-*-courier-bold-r-*-*-*-120-*-*-*-*-iso8859-*"))))
    (add-spec-list-to-specifier (face-property 'bold 'highlight) '((global ((tty)
    .. t))))
    (add-spec-list-to-specifier (face-property 'paren-blink-off 'foreground)
    '((global ((x) . "grey"))))
    (add-spec-list-to-specifier (face-property 'paren-mismatch 'foreground)
    '((global ((grayscale x) . [modeline foreground]) ((mono x) . [modeline
    foreground]))))
    (add-spec-list-to-specifier (face-property 'paren-mismatch 'background)
    '((global ((grayscale x) . [modeline background]) ((mono x) . [modeline
    background]) ((color x) . "DeepPink"))))
    (add-spec-list-to-specifier (face-property 'paren-mismatch 'reverse)
    '((global ((tty) . t))))
    (add-spec-list-to-specifier (face-property 'blue 'foreground) '((global
    ((color) . "blue"))))
    (add-spec-list-to-specifier (face-property 'font-lock-other-emphasized-face
    'background) '((global (nil . "lightyellow2"))))
    (add-spec-list-to-specifier (face-property 'font-lock-other-emphasized-face
    'font) '((global (nil . "-*-courier-bold-i-*-*-*-120-*-*-*-*-iso8859-*"))))
    (add-spec-list-to-specifier (face-property 'font-lock-other-emphasized-face
    'underline) '((global ((tty) . t))))
    (add-spec-list-to-specifier (face-property 'font-lock-other-emphasized-face
    'highlight) '((global ((tty) . t))))
    (add-spec-list-to-specifier (face-property 'modeline-buffer-id 'foreground)
    '((global ((color x) . "blue") (nil . [#s(face name modeline)]))))
    (add-spec-list-to-specifier (face-property 'modeline-buffer-id 'background)
    '((global (nil . [#s(face name modeline)]))))
    (add-spec-list-to-specifier (face-property 'modeline-buffer-id 'font)
    '((global ((tty) . [bold-italic]) ((grayscale x) . [bold-italic]) ((mono x) .
    [bold-italic]) (nil . [#s(face name modeline)]))))
    (add-spec-list-to-specifier (face-property 'modeline-buffer-id
    'background-pixmap) '((global ((x) . [inherit :face #s(face name modeline)])
    ((tty) . [inherit :face #s(face name modeline)]) ((stream) . [inherit :face
    #s(face name modeline)]))))
    (add-spec-list-to-specifier (face-property 'modeline-buffer-id 'underline)
    '((global (nil . [#s(face name modeline)]))))
    (add-spec-list-to-specifier (face-property 'modeline-buffer-id 'strikethru)
    '((global (nil . [#s(face name modeline)]))))
    (add-spec-list-to-specifier (face-property 'modeline-buffer-id 'highlight)
    '((global (nil . [#s(face name modeline)]))))
    (add-spec-list-to-specifier (face-property 'modeline-buffer-id 'dim)
    '((global (nil . [#s(face name modeline)]))))
    (add-spec-list-to-specifier (face-property 'modeline-buffer-id 'blinking)
    '((global (nil . [#s(face name modeline)]))))
    (add-spec-list-to-specifier (face-property 'modeline-buffer-id 'reverse)
    '((global (nil . [#s(face name modeline)]))))
    (add-spec-list-to-specifier (face-property 'default 'foreground) '((global
    ((x) . "black"))))
    (add-spec-list-to-specifier (face-property 'default 'background) '((global
    ((x) . "grey"))))
    (add-spec-list-to-specifier (face-property 'default 'font) '((global (nil .
    "-*-courier-medium-r-*-*-*-120-*-*-*-*-iso8859-*"))))
    (add-spec-list-to-specifier (face-property 'green 'foreground) '((global
    ((color) . "green"))))
    (add-spec-list-to-specifier (face-property 'font-lock-function-name-face
    'foreground) '((global ((x) . "royalblue1") ((color) . "blue3") ((color) .
    "blue"))))
    (add-spec-list-to-specifier (face-property 'font-lock-function-name-face
    'font) '((global (nil . "-*-times-medium-i-*-*-16-*") ((mono) . [bold])
    ((grayscale) . [bold]))))
    (add-spec-list-to-specifier (face-property 'text-cursor 'foreground)
    '((global (nil . [default background]))))
    (add-spec-list-to-specifier (face-property 'text-cursor 'background)
    '((global ((x) . "Red3"))))
    (add-spec-list-to-specifier (face-property 'text-cursor 'reverse) '((global
    ((tty) . t))))
    (add-spec-list-to-specifier (face-property 'list-mode-item-selected
    'foreground) '((global ((mono x) . [default background]))))
    (add-spec-list-to-specifier (face-property 'list-mode-item-selected
    'background) '((global ((mono x) . [default foreground]) ((grayscale) .
    "gray68") ((color) . "gray68"))))
    (add-spec-list-to-specifier (face-property 'list-mode-item-selected 'reverse)
    '((global ((tty) . t))))
    (add-spec-list-to-specifier (face-property 'bold-italic 'font) '((global (nil
    .. "-*-courier-bold-i-*-*-*-120-*-*-*-*-iso8859-*"))))
    (add-spec-list-to-specifier (face-property 'bold-italic 'underline) '((global
    ((tty) . t))))
    (add-spec-list-to-specifier (face-property 'bold-italic 'highlight) '((global
    ((tty) . t))))
    (add-spec-list-to-specifier (face-property 'gui-button-face 'foreground)
    '((global (nil . "black"))))
    (add-spec-list-to-specifier (face-property 'gui-button-face 'background)
    '((global (nil . "grey75"))))
    (add-spec-list-to-specifier (face-property 'modeline-mousable-minor-mode
    'foreground) '((global ((color x) . "green4") ((color x) . "green") (nil .
    [#s(face name modeline-mousable)]))))
    (add-spec-list-to-specifier (face-property 'modeline-mousable-minor-mode
    'background) '((global (nil . [#s(face name modeline-mousable)]))))
    (add-spec-list-to-specifier (face-property 'modeline-mousable-minor-mode
    'font) '((global (nil . [#s(face name modeline-mousable)]))))
    (add-spec-list-to-specifier (face-property 'modeline-mousable-minor-mode
    'background-pixmap) '((global ((x) . [inherit :face #s(face name
    modeline-mousable)]) ((tty) . [inherit :face #s(face name modeline-mousable)])
    ((stream) . [inherit :face #s(face name modeline-mousable)]))))
    (add-spec-list-to-specifier (face-property 'modeline-mousable-minor-mode
    'underline) '((global (nil . [#s(face name modeline-mousable)]))))
    (add-spec-list-to-specifier (face-property 'modeline-mousable-minor-mode
    'strikethru) '((global (nil . [#s(face name modeline-mousable)]))))
    (add-spec-list-to-specifier (face-property 'modeline-mousable-minor-mode
    'highlight) '((global (nil . [#s(face name modeline-mousable)]))))
    (add-spec-list-to-specifier (face-property 'modeline-mousable-minor-mode
    'dim) '((global (nil . [#s(face name modeline-mousable)]))))
    (add-spec-list-to-specifier (face-property 'modeline-mousable-minor-mode
    'blinking) '((global (nil . [#s(face name modeline-mousable)]))))
    (add-spec-list-to-specifier (face-property 'modeline-mousable-minor-mode
    'reverse) '((global (nil . [#s(face name modeline-mousable)]))))
    (add-spec-list-to-specifier (face-property 'paren-match 'background)
    '((global ((color) . "darkseagreen2") ((color) . "green") ((grayscale) .
    "gray53"))))
    (add-spec-list-to-specifier (face-property 'paren-match 'highlight) '((global
    ((tty) . t))))
    (add-spec-list-to-specifier (face-property 'font-lock-type-face 'foreground)
    '((global ((color) . "#6920ac"))))
    (add-spec-list-to-specifier (face-property 'font-lock-type-face 'font)
    '((global ((mono) . [italic]) ((grayscale) . [italic]))))
    (add-spec-list-to-specifier (face-property 'font-lock-doc-string-face
    'foreground) '((global ((x) . "maroon") ((color) . "green4") ((color) . "green"))))
    (add-spec-list-to-specifier (face-property 'font-lock-doc-string-face 'font)
    '((global (nil . "-*-times-medium-r-*-*-14-*") ((mono) . [italic]) ((grayscale)
    .. [italic]))))
    (add-spec-list-to-specifier (face-property 'modeline 'foreground) '((global
    ((x) . "Black"))))
    (add-spec-list-to-specifier (face-property 'modeline 'background) '((global
    ((x) . "Gray75"))))
    (add-spec-list-to-specifier (face-property 'modeline 'background-pixmap)
    '((global ((x) . [nothing]) ((tty) . [nothing]) ((stream) . [nothing]))))
    (add-spec-list-to-specifier (face-property 'modeline 'reverse) '((global
    ((tty) . t))))
    (add-spec-list-to-specifier (face-property 'font-lock-emphasized-face
    'background) '((global (nil . "lightyellow2"))))
    (add-spec-list-to-specifier (face-property 'font-lock-emphasized-face 'font)
    '((global (nil . "-*-courier-bold-r-*-*-*-120-*-*-*-*-iso8859-*"))))
    (add-spec-list-to-specifier (face-property 'font-lock-emphasized-face
    'highlight) '((global ((tty) . t))))
    (add-spec-list-to-specifier (face-property 'highlight 'background) '((global
    ((color) . "darkseagreen2") ((color) . "green") ((grayscale) . "gray53"))))
    (add-spec-list-to-specifier (face-property 'highlight 'highlight) '((global
    ((tty) . t))))
    (add-spec-list-to-specifier (face-property 'secondary-selection 'background)
    '((global ((grayscale) . "gray53") ((color) . "paleturquoise") ((color) .
    "green"))))
    (add-spec-list-to-specifier (face-property 'font-lock-preprocessor-face
    'foreground) '((global ((color) . "blue3") ((color) . "blue"))))
    (add-spec-list-to-specifier (face-property 'font-lock-preprocessor-face
    'font) '((global ((mono) . [bold-italic]) ((grayscale) . [bold-italic]))))
    (add-spec-list-to-specifier (face-property 'font-lock-keyword-face
    'foreground) '((global ((x) . "red") ((color) . "orange"))))
    (add-spec-list-to-specifier (face-property 'font-lock-keyword-face 'font)
    '((global (nil . "-*-courier-bold-r-*-*-14-*") ((mono) . [bold]) ((grayscale) .
    [bold]))))
    (add-spec-list-to-specifier (face-property 'italic 'font) '((global (nil .
    "-*-courier-medium-i-*-*-*-120-*-*-*-*-iso8859-*"))))
    (add-spec-list-to-specifier (face-property 'italic 'underline) '((global
    ((tty) . t))))
    (add-spec-list-to-specifier (face-property 'font-lock-other-type-face
    'foreground) '((global (nil . "OliveDrab") ((color) . "#6920ac"))))
    (add-spec-list-to-specifier (face-property 'font-lock-other-type-face 'font)
    '((global ((mono) . [italic]) ((grayscale) . [italic]))))
    (add-spec-list-to-specifier (face-property 'yellow 'foreground) '((global
    ((color) . "yellow"))))
    (add-spec-list-to-specifier (face-property 'modeline-mousable 'foreground)
    '((global ((color x) . "red") (nil . [#s(face name modeline)]))))
    (add-spec-list-to-specifier (face-property 'modeline-mousable 'background)
    '((global (nil . [#s(face name modeline)]))))
    (add-spec-list-to-specifier (face-property 'modeline-mousable 'font)
    '((global ((grayscale x) . [bold]) ((mono x) . [bold]) (nil . [#s(face name
    modeline)]))))
    (add-spec-list-to-specifier (face-property 'modeline-mousable
    'background-pixmap) '((global ((x) . [inherit :face #s(face name modeline)])
    ((tty) . [inherit :face #s(face name modeline)]) ((stream) . [inherit :face
    #s(face name modeline)]))))
    (add-spec-list-to-specifier (face-property 'modeline-mousable 'underline)
    '((global (nil . [#s(face name modeline)]))))
    (add-spec-list-to-specifier (face-property 'modeline-mousable 'strikethru)
    '((global (nil . [#s(face name modeline)]))))
    (add-spec-list-to-specifier (face-property 'modeline-mousable 'highlight)
    '((global (nil . [#s(face name modeline)]))))
    (add-spec-list-to-specifier (face-property 'modeline-mousable 'dim) '((global
    (nil . [#s(face name modeline)]))))
    (add-spec-list-to-specifier (face-property 'modeline-mousable 'blinking)
    '((global (nil . [#s(face name modeline)]))))
    (add-spec-list-to-specifier (face-property 'modeline-mousable 'reverse)
    '((global (nil . [#s(face name modeline)]))))
    (add-spec-list-to-specifier (face-property 'zmacs-region 'background)
    '((global ((x) . "CornflowerBlue"))))
    (add-spec-list-to-specifier (face-property 'zmacs-region 'reverse) '((global
    ((tty) . t))))






    ;; emacs ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    ;;
    ;; save backup files
    (setq make-backup-files t)
    ;;
    (line-number-mode 1)

    (setq text-mode-hook 'turn-on-auto-fill)
    (setq-default fill-column 75)
    ;;
    ;;
    (defvar running-xemacs (and (string-match "XEmacs\\|Lucid" emacs-version)
    (or (and
    (= emacs-major-version 19)
    (>= emacs-minor-version 14))
    (= emacs-major-version 20))))
    ;; Set tab stops to every 'step' spaces up to 'last' columns
    ;;
    (let* ((step 3) (last 160) (x step) (tabs nil))
    ; generate tab list
    (while (<= x last)
    (setq tabs (cons x tabs))
    (setq x (+ x step)))
    ; set tab stop list
    (setq-default tab-stop-list (reverse tabs))
    ; set tab character width to same as tab stop
    (setq-default tab-width step))
    ;; Sets overwriting of the selected text ( like DOS )
    (cond
    ((fboundp 'turn-on-pending-delete)
    (turn-on-pending-delete))
    ((fboundp 'pending-delete-on)
    (pending-delete-on t)))
    ;;
    ;; Set to insert spaces instead of tab characters
    ;;
    (setq-default indent-tabs-mode nil)
    (global-set-key "\C-xw" 'what-line)
    (global-set-key "\C-x?" 'help-for-help)
    (global-set-key 'backspace 'delete-backward-char)
    (global-set-key "\C-?" 'delete-char)
    (global-unset-key "\e\e")
    (global-set-key "\e\e" 'keyboard-quit)

    (setq auto-mode-alist (cons '("\.p$" . perl-mode) auto-mode-alist))
    (setq auto-mode-alist (cons '("\.pl$" . perl-mode) auto-mode-alist))
    (setq auto-mode-alist (cons '("\.pm$" . perl-mode) auto-mode-alist))
    (setq auto-mode-alist (cons '("\.df$" . perl-mode) auto-mode-alist))

    (cond
    (running-xemacs
    (autoload 'perl-mode "cperl-mode" "alternate mode for editing perl" t)
    (setq cperl-hairy t)
    )
    (t
    (autoload 'perl-mode "perl-mode" "alternate mode for editing perl" t)
    )
    ) ; cond


    (defun scroll-one-line-up (&optional arg)
    "Scroll the selected window up (forward in the text) one line (or N lines)."
    (interactive "p")
    (scroll-up (or arg 1)))

    (defun scroll-one-line-down (&optional arg)
    "Scroll the selected window down (backward in the text) one line (or N)."
    (interactive "p")
    (scroll-down (or arg 1)))

    (global-set-key [(shift up)] 'scroll-one-line-up)
    (global-set-key [(shift down)] 'scroll-one-line-down)

    ;(define-key "x-button-left" 'x-mouse-set-point)
    ;(define-key mouse-map "x-button-s-left" 'x-buffer-menu)
    ;(define-key mouse-map "x-button-middle" 'x-paste-text)
    ;(define-key mouse-map "x-button-c-middle" 'x-cut-and-wipe-text)
    ;(define-key mouse-map "x-button-s-middle" 'x-cut-text)
    ;(define-key mouse-map "x-button-right" 'x-mouse-keep-one-window)
    ;(define-key mouse-map "x-button-s-right" 'x-mouse-delete-win)
    ;(define-key mouse-map "x-button-c-right" 'x-mouse-select-and-split)


    ;(define-key global-map 'button1" 'x-mouse-set-point)
    ;(define-key global-map "x-button-s-left" 'x-buffer-menu)
    ;(define-key global-map 'button2 'x-insert-selection)
    ;(define-key global-map '(control button2) 'x-cut-and-wipe-text)
    ;(define-key global-map '(shift button2) 'x-cut-text)
    ;(define-key global-map "x-button-right" 'x-mouse-keep-one-window)
    ;(define-key global-map "x-button-s-right" 'x-mouse-delete-win)
    ;(define-key global-map "x-button-c-right" 'x-mouse-select-and-split)

    ;; for LUCID emacs

    (cond
    (running-xemacs

    ;(global-set-key '(meta button1) `mouse-keep-one-window) ;;
    ;(global-set-key '(button2) `mouse-track-insert) ;; select the region and copie
    it to the point
    ; Local Bindings:
    ; button binding
    ;------ -------
    ;
    ;Global Bindings:
    ;button binding
    ;------ -------
    ;
    ;button1 mouse-track
    ;button1up release-toolbar-button
    ;button2 x-insert-selection
    ;button3 popup-mode-menu
    ;C-button1 mouse-track-insert
    ;C-button2 x-cut-and-wipe-text
    ;M-button1 mouse-track-do-rectangle
    ;M-C-button3 popup-buffer-menu
    ;Sh-button1 mouse-track-adjust
    ;Sh-button2 x-cut-text
    ;C-Sh-button1 mouse-track-delete-and-insert

    ;; cmdPad Cut
    (global-set-key 'f1 'help-command)

    ;; cmdPad Cut
    (global-set-key 'f20 'kill-region)
    ;; cmdPad Find
    (global-set-key 'f19 'query-replace)
    ;; cmdPad Paste
    (global-set-key 'f18 'yank)
    ;; cmdPad Open
    (global-set-key 'f17 'delete-other-windows)
    ;; cmdPad Copy
    (global-set-key 'f16 'copy-region-as-kill)
    ;(global-set-key 'f15 ')
    ;; cmdPad Undo
    (global-set-key 'f14 'advertised-undo)
    ;; KEYPAD 1
    (global-set-key 'f33 'end-of-line)
    ;; Keypad shift 1
    (global-set-key '(shift f33) 'end-of-buffer)
    ;; keypad 3
    (global-set-key 'f35 'forward-page)
    ;; keypad 9
    (global-set-key 'f29 'backward-page)
    ;; keypad 7
    (global-set-key 'f27 'beginning-of-line)
    ;; keypad shift 7
    (global-set-key '(shift f27) 'beginning-of-buffer)
    ;; keypad shift 6
    (global-set-key 'f32 'forward-sexp)
    ;; keypad shift 4
    (global-set-key 'f30 'backward-sexp)
    ;; keypad 5
    (global-set-key 'f31 'exchange-point-and-mark)
    ;; keypad shift 5
    (global-set-key '(shift f31) 'goto-line)

    (global-set-key 'f8 'start-kbd-macro)
    (global-set-key 'f9 'end-kbd-macro)
    (global-set-key 'f10 'call-last-kbd-macro)
    ;; Uncomment this to enable "sticky modifier keys" in 19.13
    ;; and up. With sticky modifier keys enabled, you can
    ;; press and release a modifier key before pressing the
    ;; key to be modified, like how the ESC key works always.
    ;; If you hold the modifier key down, however, you still
    ;; get the standard behavior. I personally think this
    ;; is the best thing since sliced bread (and a *major*
    ;; win when it comes to reducing Emacs pinky), but it's
    ;; disorienting at first so I'm not enabling it here by
    ;; default.

    ;;(setq modifier-keys-are-sticky t)
    )
    ) ; cond

    ; (global-set-key "\033[208z" 'other-window) ;; R1
    ; ;;(global-set-key "\033[209z" 'enlarge-window) ;; R2
    ; (global-set-key "\033[210z" 'scroll-up) ;; R3
    ; (global-set-key "\033[211z" 'kill-word) ;; R4
    ; (global-set-key "\033[212z" 'delete-window) ;; R5
    ; (global-set-key "\033[213z" 'beginning-of-line) ;; R6
    ; (global-set-key "\033[214z" 'backward-word) ;; R7
    ; (global-set-key "\033[A" 'previous-line) ;; R8 up-arrow
    ; (global-set-key "\033[216z" 'forward-word) ;; R9
    ; (global-set-key "\033[D" 'backward-char) ;; R10 left-arrow
    ; (global-set-key "\033[218z" 'set-mark-command) ;; R11
    ; (global-set-key "\033[C" 'forward-char) ;; R12 right-arrow
    ; (global-set-key "\033[220z" 'end-of-buffer) ;; R13
    ; (global-set-key "\033[B" 'next-line) ;; R14 down-arrow
    ; (global-set-key "\033[222z" 'scroll-down) ;; R15 pg dn
    ; ; (global-set-key "\033[218z" 'set-mark-command) ;; R11
    ; (global-set-key "\033[C" 'forward-char) ;; R12 right-arrow
    ; (global-set-key "\033[220z" 'end-of-buffer) ;; R13
    ; (global-set-key "\033[B" 'next-line) ;; R14 down-arro

    (setq-default zmacs-regions t)
    (setq-default debug-on-error t)


    (cond (running-xemacs
    (define-key global-map '(shift tab) 'self-insert-command)

    ;; Here's a way to add scrollbar-like buttons to the menubar
    (add-menu-item nil "Top" 'beginning-of-buffer t)
    (add-menu-item nil "<<<" 'scroll-down t)
    (add-menu-item nil " . " 'recenter t)
    (add-menu-item nil ">>>" 'scroll-up t)
    (add-menu-item nil "Bot" 'end-of-buffer t)

    (require 'func-menu)
    (define-key global-map 'f8 'function-menu)
    (add-hook 'find-file-hooks 'fume-add-menubar-entry)
    (define-key global-map "\C-cl" 'fume-list-functions)
    (define-key global-map "\C-cg" 'fume-prompt-function-goto)

    ;; The Hyperbole information manager package uses (shift button2) and
    ;; (shift button3) to provide context-sensitive mouse keys. If you
    ;; use this next binding, it will conflict with Hyperbole's setup.
    ;; Choose another mouse key if you use Hyperbole.
    (define-key global-map '(shift button3) 'mouse-function-menu)

    ;; For descriptions of the following user-customizable variables,
    ;; type C-h v <variable>
    (setq fume-max-items 25
    fume-fn-window-position 3
    fume-auto-position-popup t
    fume-display-in-modeline-p t
    fume-menubar-menu-location "File"
    fume-buffer-name "*Function List*"
    fume-no-prompt-on-valid-default nil)
    ))
    (require 'dired)
    (set-face-background 'zmacs-region "red")
    (set-face-foreground 'zmacs-region "yellow")
    (setq auto-save-directory (expand-file-name "~/.autosave/")
    auto-save-directory-fallback auto-save-directory
    auto-save-hash-p nil
    ange-ftp-auto-save t
    ange-ftp-auto-save-remotely nil
    ;; now that we have auto-save-timeout, let's crank this up
    ;; for better interactive response.
    auto-save-interval 2000
    )
    ;; We load this afterwards because it checks to make sure the
    ;; auto-save-directory exists (creating it if not) when it's loaded.
    (require 'auto-save)

    ;; SKILL MODE is automatically loaded in xemacs 19.14 and above

    (defun printRegion ()
    "Enscript printing of a region"
    (interactive)
    (shell-command-on-region (point) (mark) "enscript ")
    )
    ;; Options Menu Settings
    ;; =====================
    (cond
    ((and (string-match "XEmacs" emacs-version)
    (boundp 'emacs-major-version)
    (or (and
    (= emacs-major-version 19)
    (>= emacs-minor-version 14))
    (= emacs-major-version 20))
    (fboundp 'load-options-file))
    (load-options-file "~/.xemacs-options")))
    ;; ============================
    ;; End of Options Menu Settings



    (put 'narrow-to-region 'disabled nil)
     
    Bernd Fischer, Dec 10, 2004
    #4
  5. Stefan Robert

    Guest Guest

    Some use emacs, some use vi. A few of us use vim (vi on steroids). vim is
    basically for vi users who covet some of the features of emacs but don't
    want to learn a new editor. I think it is the default on Red Hat Linux as
    well.

    It has syntax-sensitive coloration, and the version I have included a skill
    syntax file (which expands on the lisp syntax file) that I've modified for
    my own purposes (specifically for the code I work on, so it isn't generally
    useful).

    I know an emacs skill mode exists, but since I don't use emacs I don't know
    how to locate it.

    For those now using vi, I highly recommend switching to vim simply because it
    has infinite undo. That one feature makes vim so much better than vi that all
    the other features (window splitting, syntax coloration, etc.) are just window
    dressing.

    -Pete Zakel
    ()

    Spark's Sixth Rule for Managers:
    If a subordinate asks you a pertinent question, look at him as
    if he had lost his senses. When he looks down, paraphrase the
    question back at him.
     
    Guest, Dec 10, 2004
    #5
  6. Unfortunately those files are not SKILL mode files. They are merely
    files to configure emacs, not to define the SKILL mode.

    Ah well, I am looking for a good editor to do this and I guess I will
    go for nedit since finding an xemacs skill mode file is more difficult
    than I thought.

    I found the skill.pats for nedit... I had a little bit of difficulty to
    make it happen, but now it work.



     
    Stefan Robert, Dec 10, 2004
    #6
  7. A.B. could you contact me via e-mail?

    Stefan


     
    Stefan Robert, Dec 11, 2004
    #7
  8. Stefan Robert

    Jim Newton Guest

    i tried a couple of times to use the SKILL mode for
    emacs but it caused emacs to segmentation fault.

    I use the lisp-mode instead. it works very well,
    i've used it for about 15 years now.

    -jim
     
    Jim Newton, Dec 11, 2004
    #8
  9. Stefan Robert

    fogh Guest

    Hi ,
    I posted lately some code to generate tips files for nedit. Can save
    you a lot of time switching back and forth to the "finder".

    I like nedit as well, but it really lacks folds. gvim has folds , so
    you can say that vi is more a GUI based editor than nedit.

    Also, the SKILL patterns for nedit found on niki are very poor. If any
    of you guys has an improved pattern file, please post. Most wanted is
    support of both infix and procedural style, and have a smart indenter.

    I sometimes consider switching to scintilla, and even looked at
    eclipse lately. Most of these have a list or scheme mode that can be
    used as starting point. But no matter what editor I look at, it is alway
    too much work for my lazy taste to write the patterns/lex stuff. I have
    no experience in that.
     
    fogh, Dec 11, 2004
    #9
  10. A simple google using "skillmode emacs" leads to an emacs wiki which
    points to ftp://ftp.informatik.uni-stuttgart.de/pub/skill/ (which is alive).
    HTH

    -Eyck
     
    Eyck Jentzsch, Dec 16, 2004
    #10
  11. Yes I finally found this after re-discovering it a second time.

    The first time I tried this I must have made an error and it wrongfully
    showed that it was not alive anymore.

    I re-tried this and suprisingly found that it was alive...

    thanks
     
    Stefan Robert, Dec 16, 2004
    #11
  12. Stefan Robert

    evillen Guest

    I came across this thread and downloaded the Major mode for Skill
    files. I have a few questions about getting started and hope that
    someone might be able to help me.

    My background is that I am new to both Emacs and Skill/Lisp. I am a
    Cadence user and want to write some Skill programs with the benefit of
    Emacs in Skill mode.

    I am running everything on Windows XP platform, and I am concerned that
    the Skill Mode 'pattern' that I downloaded following the link can only
    be compiled for use with a Unix system - is this right?

    If skillmode3.2 can be used with Windows, how do I install it - it's
    not at all obvious to me from reading the documentation.

    Thanks for any help you can provide

     
    evillen, Feb 22, 2005
    #12
  13. Stefan Robert

    Satya Mishra Guest

    evillen> Date: 22 Feb 2005 07:31:46 -0800

    evillen> I came across this thread and downloaded the Major mode
    evillen> for Skill files. I have a few questions about getting
    evillen> started and hope that someone might be able to help me.

    evillen> My background is that I am new to both Emacs and
    evillen> Skill/Lisp. I am a Cadence user and want to write some
    evillen> Skill programs with the benefit of Emacs in Skill mode.

    evillen> I am running everything on Windows XP platform, and I am
    evillen> concerned that the Skill Mode 'pattern' that I downloaded
    evillen> following the link can only be compiled for use with a
    evillen> Unix system - is this right?

    evillen> If skillmode3.2 can be used with Windows, how do I
    evillen> install it - it's not at all obvious to me from reading
    evillen> the documentation.

    evillen> Thanks for any help you can provide

    You can get an updated version from Cadence AE. The new version works
    with emacs21. Also, skill-mode should be portable across
    platforms. You just need to copy the files to somewhere in the
    load-path and follow instructions included with the package.

    Satya
     
    Satya Mishra, Feb 22, 2005
    #13
  14. As an alternative Vim comes with excellent Skill syntax highlighting
    out-of-the-box.
     
    Stephen Chadfield, Feb 22, 2005
    #14
  15. Stefan Robert

    Satya Mishra Guest

    Stephen> Date: Tue, 22 Feb 2005 22:17:18 +0000 (UTC)


    Stephen> As an alternative Vim comes with excellent Skill syntax
    Stephen> highlighting out-of-the-box.

    Stephen> -- Stephen Chadfield http://www.chadfield.com/

    True. However, skill-mode does more than just syntax highlight. It also
    has a sort of inferior-lisp-style way of sending fragments of SKILL
    code to a running skill-interpreter session (icfb, icms, awd,
    etc.). Though it isn't quite as neat as say 'ilisp', its still pretty
    useful. I think a method using pipes would be nicer.

    I don't know if Cadence's insistence on not giving out source code for
    skill-mode is a violation of GPL.

    Satya
     
    Satya Mishra, Feb 22, 2005
    #15
  16. I don't think we have the source code, as it wasn't written by anyone in
    Cadence. If memory serves, it was written by somebody at Ericsson. I don't
    think the original author is still involved in SKILL related stuff (and
    probably not at Ericsson any more) - this is pretty old...

    So we're not violating GPL. I think to get it to work with later emacs
    versions, somebody had to twiddle some bits in the binary code to get it to
    work (as we didn't have the source code).

    Andrew.
     
    Andrew Beckett, Feb 23, 2005
    #16
  17. Stefan Robert

    Satya Mishra Guest

    Andrew> Date: Wed, 23 Feb 2005 05:47:00 +0000

    Andrew> On Tue, 22 Feb 2005 15:51:36 -0700, Satya Mishra
    Andrew> <>
    Andrew> wrote:

    Andrew> I don't think we have the source code, as it wasn't
    Andrew> written by anyone in Cadence. If memory serves, it was
    Andrew> written by somebody at Ericsson. I don't think the
    Andrew> original author is still involved in SKILL related stuff
    Andrew> (and probably not at Ericsson any more) - this is pretty
    Andrew> old...

    I see. It's a pity Cadence doesn't have the source code. The mode
    could use a bit of modernization.

    Satya
     
    Satya Mishra, Feb 23, 2005
    #17
  18. Stefan Robert

    evillen Guest

    Thanks for all the responses.

    Andrew could you please email or provide a link to the latest
    skill-mode files? I can't find anything on Sourcelink and it would
    probably be quicker than asking our AE to pursue this for me.

    Many thanks.
     
    evillen, Feb 23, 2005
    #18
  19. Actually I don't know where it is (I'm a hardened vi user).

    I'll do some digging around to see if I can find it.

    Andrew.
     
    Andrew Beckett, Feb 23, 2005
    #19
Ask a Question

Want to reply to this thread or ask your own question?

You'll need to choose a username for the site, which only take a couple of moments (here). After that, you can post your question and our members will help you out.