电脑/emacs/elisp学习笔记.html

<!DOCTYPE html>
<html>
<head>
<!-- 2016-07-30 六 23:08 -->
<meta  charset="utf-8">
<meta  name="viewport" content="width=device-width, initial-scale=1">
<title>编写emacs插件</title>
<meta  name="generator" content="Org-mode">
<meta  name="author" content="万泽(德山书生)">
<meta  name="description" content="制作者邮箱：a358003542@gmail.com"
>
<style type="text/css">
body {
    margin-right: auto;
    margin-left: auto;
}

.title {
    display: block;
    text-align: center;
    padding: 10px;
}

.center-block {
    display: block;
    margin-left: auto;
    margin-right: auto;
}

.underline{
    text-decoration: underline;
}
   html, body {
    margin: 0;
    padding: 0;
    font-family:"Microsoft YaHei",Arial,Helvetica,sans-serif,"宋体";
    font-size: 1em;
}

#content {
    display: block;
    margin-left: auto;
    margin-right: auto;
    background:#fcfcfc;
    height:100%;
    margin-left:300px;
    max-width:800px;
    min-height:100%;
    padding:1.618em 3.236em;
}

code {
    padding: 2px 4px;
    color: #c7254e;
    background-color: #f9f2f4;
    border-radius: 4px;
}

pre {
    max-width: 100%;
    display: block;
    padding: 9.5px;
    margin: 0 0 10px;
    font-size: 13px;
    line-height: 1.42857143;
    color: #333;
    background-color: #f5f5f5;
    border: 1px solid #ccc;
    border-radius: 4px;
    overflow : auto;
}


blockquote {
    padding: 10px 20px;
    margin: 0 0 20px;
    font-size: 17.5px;
    border-left: 5px solid #eee;
}

li{
    margin-top: 0.5em;
    margin-bottom: 0.5em;
}

p{
    text-indent:2em;
    line-height:150%;
}

/* dl */
dl {
    margin-top: 0;
    margin-bottom: 20px;
}
dt {
    font-weight: 700;
    line-height: 150%;
    margin-top: 0.5em;
    margin-bottom: 0.5em;
}
dd {
    line-height: 150%;
}

@media (min-width: 768px) {
  dt {
    white-space: nowrap;
  }
}

video{
    max-width: 100%;
    margin-left: auto;
    margin-right: auto;
}

figure p{
    text-indent:0em;
}
img{
    max-width: 100%;
}

embed{
    max-width: 100%;
    margin-left: auto;
    margin-right: auto;
}

figure{
    text-align: center;
}

/*  class  */
.FRAMED{
    max-width:100%;
    border:1px solid ;
    padding: 1em;
    -webkit-box-sizing: border-box;
    -moz-box-sizing: border-box;
    box-sizing: border-box;
}

.NOTECARD{
    width: 35%;
    position:relative;
    right: -30%;
    padding: 1em;
    margin:0 auto;
    border: solid 1px;
    -webkit-box-sizing: border-box;
    -moz-box-sizing: border-box;
    box-sizing: border-box;
}

/*
table
*/
table {
    border-collapse: collapse;
    border-spacing: 0;
    margin: 16px 0;
    empty-cells: show;
    border: 1px solid #ccc;
    width: 100%;
    display: table;
}

table tr {
    border-bottom: 1px solid #ddd;
}
table th,table td{
    padding:8px;
}

table tr:nth-child(even) {
    background-color: #f1f1f1;
}


ul,ol,dl{
    line-height:24px;
    list-style-image:none;
    /* list-style:none; */
    margin:0px 0px 24px 0px;
    padding:0;
}

li{
    margin-left: 24px;
}

dd{
    margin:0;
}

#content .section ul,#content .toctree-wrapper ul,article ul{
    list-style:disc;
    line-height:24px;
    margin-bottom:24px}

#content .section ul li,#content .toctree-wrapper ul li,article ul li{
    list-style:disc;
    margin-left:24px}

#content .section ul li p:last-child,#content .toctree-wrapper ul li p:last-child,article ul li p:last-child{
                                                                                                                                  margin-bottom:0}

#content .section ul li ul,#content .toctree-wrapper ul li ul,article ul li ul{
    margin-bottom:0}

#content .section ul li li,#content .toctree-wrapper ul li li,article ul li li{
    list-style:circle}

#content .section ul li li li,#content .toctree-wrapper ul li li li,article ul li li li{
    list-style:square}

#content .section ul li ol li,#content .toctree-wrapper ul li ol li,article ul li ol li{
    list-style:decimal}

#content .section ol,#content ol,article ol{
    list-style:decimal;
    line-height:24px;
    margin-bottom:24px}

#content .section ol li,#content ol li,article ol li{
    list-style:decimal;
    margin-left:24px}

#content .section ol li p:last-child,#content ol li p:last-child,article ol li p:last-child{
                                                                                                                           margin-bottom:0}

#content .section ol li ul,#content ol li ul,article ol li ul{
    margin-bottom:0}

#content .section ol li ul li,#content ol li ul li,article ol li ul li{
    list-style:disc}

dl dt{
    font-weight:bold;
}

dl p,dl table,dl ul,dl ol{
    margin-bottom:12px !important;
}

dl dd{
    margin:0 0 12px 24px;
}

@media print{
    .codeblock,pre.src{
        white-space:pre.src-wrap}
}

@media print{
    html,body,section{
        background:none !important}

    *{
        box-shadow:none !important;
        text-shadow:none !important;
        filter:none !important;
        -ms-filter:none !important}

    a,a:visited{
          text-decoration:underline}

    pre.src,blockquote{
        page-break-inside:avoid}

    thead{
        display:table-header-group}

    tr,img{
        page-break-inside:avoid}

    img{
        max-width:100% !important}

    @page{
        margin:0.5cm}

    p,h2,h3{
        orphans:3;
        widows:3}

    h2,h3{
        page-break-after:avoid}
}

@media print{
    #postamble{
        display:none}

    #content{
        margin-left:0}
}

@media print{
    #table-of-contents{
        display:none}

    @page{
        size: auto;
        margin: 25mm 25mm 25mm 25mm;}

    body {
        margin: 0px;}
}

@media screen and (max-width: 768px){
}

@media only screen and (max-width: 480px){
}

@media screen and (max-width: 768px){
    .tablet-hide{
        display:none}
}

@media screen and (max-width: 480px){
    .mobile-hide{
        display:none}
}

@media screen and (max-width: 480px){
}

@media screen and (max-width: 768px){
    #content{
        margin-left:0;
        padding: 1em 1em;}

    #content #content{
        padding:1.618em}

    #content.shift{
        position:fixed;
        min-width:100%;
        left:85%;
        top:0;
        height:100%;
        overflow:hidden}
}

@media screen and (min-width: 1400px){
    #content{
        background:rgba(0,0,0,0.05)}

    #content{
        background:#fcfcfc}
}

@media screen and (max-width: 768px){
    #copyright{
        width:85%;
        display:none}

    #copyright.shift{
        display:block}

    img{
        width:100%;
        height:auto}
}

@media screen and (max-width: 480px){
    #content .sidebar{
        width:100%}
}


.figure p{
    color:#000;
    font:italic 85%/1 arial,sans-serif;
    padding:1em 0;
}

.rotate-90{
    -webkit-transform:rotate(90deg);
    -moz-transform:rotate(90deg);
    -ms-transform:rotate(90deg);
    -o-transform:rotate(90deg);
    transform:rotate(90deg);
}

.rotate-270{
    -webkit-transform:rotate(270deg);
    -moz-transform:rotate(270deg);
    -ms-transform:rotate(270deg);
    -o-transform:rotate(270deg);
    transform:rotate(270deg);
}

#toggle-sidebar,
#table-of-contents .close-sidebar {
    display: none;
}

@media screen and (max-width: 768px) {
    #table-of-contents {
        display: none;
        width: 60%;
    }

    #table-of-contents h2 a {
        display: block;
    }

    #table-of-contents:target {
        display: block;
    }

    #copyright, #postamble {
        display: none;
    }

    #toggle-sidebar {
        background-color: #2980B9;
        display: block;
        margin-bottom: 1.6em;
        padding: 0.6em;
        text-align: center;
    }

    #toggle-sidebar h2 {
        color: white;
        font-size: 100%;
        line-height: 50px;
        margin: 0;
        padding: 0;
    }

    #table-of-contents .close-sidebar {
       color: rgba(255, 255, 255, 0.3);
       display: inline-block;
       margin: 0px 10px 0px 45px;
       padding: 10px;
    }
}

*{
    -webkit-box-sizing:border-box;
    -moz-box-sizing:border-box;
    box-sizing:border-box;
}

figcaption,figure,footer,header,hgroup,nav{
    display:block}

ins{
    background:#ff9;
    color:#000;
    text-decoration:none}

mark{
    background:#ff0;
    color:#000;
    font-style:italic;
    font-weight:bold}

small{
    font-size:85%}

sub,sup{
    font-size:75%;
    line-height:0;
    position:relative;
    vertical-align:baseline}

sup{
    top:-0.5em}

sub{
    bottom:-0.25em}

img{
    -ms-interpolation-mode:bicubic;
    vertical-align:middle;
    max-width:100%}

svg:not(:root){
    overflow:hidden}

figure{
    margin:0}

label{
    cursor:pointer}

legend{
    border:0;
    margin-left:-7px;
    padding:0;
    white-space:normal}

#content .danger,#content .error{
    background:#fdf3f2}

legend{
    display:block;
    width:100%;
    border:0;
    padding:0;
    white-space:normal;
    margin-bottom:24px;
    font-size:150%;
    *margin-left:-7px}

label{
    display:block;
    margin:0 0 0.3125em 0;
    color:#333;
    font-size:90%}

a{
    color:#2980B9;
    text-decoration:none;
    cursor:pointer}


a:hover,a:active{
    outline:0;
}

a:hover{
    color:#3091d1}

a:visited{
    color:#9B59B6}

.left{
    text-align:left}

.center{
    text-align:center}

.right{
    text-align:right}

hr{
    display:block;
    height:1px;
    border:0;
    border-top:1px solid #e1e4e5;
    margin:24px 0;
    padding:0}

#table-of-contents li{
    list-style:none;
    margin-left: 0px;
}

#table-of-contents header{
    height:32px;
    display:inline-block;
    line-height:32px;
    padding:0 1.618em;
    display:block;
    font-weight:bold;
    text-transform:uppercase;
    font-size:80%;
    color:#2980B9;
    white-space:nowrap}

#table-of-contents ul{
    margin-bottom:0}

#table-of-contents li.divide-top{
    border-top:solid 1px #404040}

#table-of-contents li.divide-bottom{
    border-bottom:solid 1px #404040}

#table-of-contents li.current{
    background:#e3e3e3}

#table-of-contents li.current a{
    color:gray;
    border-right:solid 1px #c9c9c9;
    padding:0.4045em 2.427em}

#table-of-contents li.current a:hover{
    background:#d6d6d6}

#table-of-contents li a{
    /* color:#404040; */
    padding:0.4045em 1.618em;
    position:relative;
    /* background:#fcfcfc; */
    border:none;
    /* border-bottom:solid 1px #c9c9c9; */
    /* border-top:solid 1px #c9c9c9; */
    padding-left:1.618em -4px}

#table-of-contents li.on a:hover,#table-of-contents li.current>a:hover{
    background:#fcfcfc}

#table-of-contents li ul li a{
    /* background:#c9c9c9; */
    padding:0.4045em 2.427em}

#table-of-contents li ul li ul li a{
    padding:0.4045em 3.236em}

#table-of-contents li.current ul{
    display:block}

/* #table-of-contents li ul{ */
/*     margin-bottom:0; */
/*     display:none} */

#table-of-contents .local-toc li ul{
    display:block}

#table-of-contents li ul li a{
    margin-bottom:0;
    color:#b3b3b3;
    font-weight:normal}

#table-of-contents a{
    display:inline-block;
    line-height:18px;
    padding:0.4045em 1.618em;
    display:block;
    position:relative;
    font-size:90%;
    color:#b3b3b3;
    direction: ltr;
}

#table-of-contents a:hover{
    background-color:#4e4a4a;
    cursor:pointer}

/* #text-table-of-contents { */
/*     overflow:scroll; */
/* } */

#table-of-contents{
    position:fixed;
    top:0;
    left:0;
    width:300px;
    overflow-x:hidden;
    overflow-y:scroll;
    height:100%;
    background:#343131;
    z-index:200;
    scrollbar-base-color: #1F1D1D;
    scrollbar-arrow-color: #b3b3b3;
    scrollbar-shadow-color: #1F1D1D;
    scrollbar-track-color : #343131;
}

#table-of-contents h2{
    z-index:200;
    background-color:#2980B9;
    text-align:center;
    padding:0.809em;
    display:block;
    color:#fcfcfc;
    font-size: 100%;
    margin-bottom:0.809em}

ul.nav li ul li {
    display: none;
}

ul.nav li ul li ul li {
    display: none;
}

ul.nav li.active ul li {
    display: inline;
}

ul.nav li.active ul li ul li {
    display: inline;
}

ul.nav li.active ul li a {
    background-color: #E3E3E3;
    color: #8099B0;
    border-right:solid 1px #c9c9c9 !important;
}

ul.nav li.active ul li.active a {
    background-color: #C9C9C9;
    color: black !important;
    font-weight: bold !important;
}

ul.nav li.active ul li.active ul li.active a {
    color: black !important;
    font-weight: bold !important;
    display: block !important;
}

ul.nav li.active ul li.active ul li a {
    color: #808080 !important;
    font-weight: normal !important;
    display: block !important;
}

ul.nav li.active ul li ul li a {
    display: none !important;
}


ul.nav li ul li ul li ul li {
    display: none !important; /* as long as nav is on multiple levels of ul */
    /* display: none; /* as long as nav is on multiple levels of ul *\/ */
}

ul.nav li.active > a {
    border-bottom:solid 1px #c9c9c9 !important; /* XXX Restrict it to 2nd level */
    border-right:solid 1px #c9c9c9 !important;
}

ul.nav li.active a {
    color: gray !important;
    font-weight:bold;
    background-color: white;
    border-right:solid 0px white !important;
}

ul.nav > li.active > a {
    color: black !important;
}

footer{
    color:#999}

footer p{
    margin-bottom:12px}

#copyright, #postamble{
    position:fixed;
    bottom:0;
    left:0;
    width:300px;
    color:#fcfcfc;
    background:#1f1d1d;
    border-top:solid 10px #343131;
    font-family:"Lato","proxima-nova","Helvetica Neue",Arial,sans-serif;
    font-size: 90%;
    z-index:400;
    padding:12px;
}

#postamble .author {
    font-size: 100%;
    margin-bottom: 0px;
}

#postamble .date {
    font-size: 90%;
    margin-bottom: 0px;
    color: #27AE60;
}

#postamble .creator,#postamble .validation {
    display:none;
}

#copyright a{
    color:#2980B9;
    text-decoration:none}

#copyright .rst-current-version{
    padding:12px;
    background-color:#272525;
    display:block;
    text-align:right;
    font-size:90%;
    cursor:pointer;
    color:#27AE60;
    *zoom:1}

#content img{
    max-width:100%;
    height:auto !important}

#content div.figure{
    margin-bottom:24px}

#content div.figure.align-center{
    text-align:center}

#content .section>img,#content .section>a>img{
    margin-bottom:24px}

.verse{
    border-left:5px solid #6AB0DE;
    background-color: #E7F2FA;
    padding: 6px 20px;
    font-style:italic;
}

#content .note .last,#content .attention .last,#content .caution .last,#content .danger .last,#content .error .last,#content .hint .last,#content .important .last,#content .tip .last,#content .warning .last,#content .seealso .last,#content .admonitiontodo .last{
    margin-bottom:0}

#content .admonition-title:before{
    margin-right:4px}

#content .section ol p,#content .section ul p{
    margin-bottom:12px}

#content h1 .headerlink,#content h2 .headerlink,#content h3 .headerlink,#content h4 .headerlink,#content h5 .headerlink,#content h6 .headerlink,#content dl dt .headerlink{
    display:none;
    visibility:hidden;
    font-size:14px}

#content h1 .headerlink:after,#content h2 .headerlink:after,#content h3 .headerlink:after,#content h4 .headerlink:after,#content h5 .headerlink:after,#content h6 .headerlink:after,#content dl dt .headerlink:after{
    visibility:visible;
    content:"";
    font-family:FontAwesome;
    display:inline-block}

#content h1:hover .headerlink,#content h2:hover .headerlink,#content h3:hover .headerlink,#content h4:hover .headerlink,#content h5:hover .headerlink,#content h6:hover .headerlink,#content dl dt:hover .headerlink{
    display:inline-block}

#content .sidebar{
    float:right;
    width:40%;
    display:block;
    margin:0 0 24px 24px;
    padding:24px;
    background:#f3f6f6;
    border:solid 1px #e1e4e5}

#content .sidebar p,#content .sidebar ul,#content .sidebar dl{
    font-size:90%}

#content .sidebar .last{
    margin-bottom:0}

#content .sidebar .sidebar-title{
    display:block;
    font-family:"Roboto Slab","ff-tisa-web-pro","Georgia",Arial,sans-serif;
    font-weight:bold;
    background:#e1e4e5;
    padding:6px 12px;
    margin:-24px;
    margin-bottom:24px;
    font-size:100%}

#content .footnote-reference,#content .citation-reference{
    vertical-align:super;
    font-size:90%}

span[id*='MathJax-Span']{
    color:#404040}

.math{
    text-align:center}

#footnotes{
    border-top:1px solid #e1e4e5;
    padding-top: 36px;
}

h2.footnotes{
    display:none;
}


.footnum:before, .footref:before{
    content:"[";
}

.footnum:after, .footref:after{
    content:"]";
}

.footpara {
    color: #999;
    font-size: 90%;
    font-family:"Lato","proxima-nova","Helvetica Neue",Arial,sans-serif;
    padding-bottom: 8px;
    padding-left: 16px;
    padding-right: 16px;
    padding-top: 8px;
    line-height: 1.25em;
    /* display: inline; */
}
.highlight .hll { background-color: #ffffcc }
.highlight  { background: #f8f8f8; }
.highlight .c { color: #8f5902; font-style: italic } /* Comment */
.highlight .err { color: #a40000; border: 1px solid #ef2929 } /* Error */
.highlight .g { color: #000000 } /* Generic */
.highlight .k { color: #204a87; font-weight: bold } /* Keyword */
.highlight .l { color: #000000 } /* Literal */
.highlight .n { color: #000000 } /* Name */
.highlight .o { color: #ce5c00; font-weight: bold } /* Operator */
.highlight .x { color: #000000 } /* Other */
.highlight .p { color: #000000; font-weight: bold } /* Punctuation */
.highlight .ch { color: #8f5902; font-style: italic } /* Comment.Hashbang */
.highlight .cm { color: #8f5902; font-style: italic } /* Comment.Multiline */
.highlight .cp { color: #8f5902; font-style: italic } /* Comment.Preproc */
.highlight .cpf { color: #8f5902; font-style: italic } /* Comment.PreprocFile */
.highlight .c1 { color: #8f5902; font-style: italic } /* Comment.Single */
.highlight .cs { color: #8f5902; font-style: italic } /* Comment.Special */
.highlight .gd { color: #a40000 } /* Generic.Deleted */
.highlight .ge { color: #000000; font-style: italic } /* Generic.Emph */
.highlight .gr { color: #ef2929 } /* Generic.Error */
.highlight .gh { color: #000080; font-weight: bold } /* Generic.Heading */
.highlight .gi { color: #00A000 } /* Generic.Inserted */
.highlight .go { color: #000000; font-style: italic } /* Generic.Output */
.highlight .gp { color: #8f5902 } /* Generic.Prompt */
.highlight .gs { color: #000000; font-weight: bold } /* Generic.Strong */
.highlight .gu { color: #800080; font-weight: bold } /* Generic.Subheading */
.highlight .gt { color: #a40000; font-weight: bold } /* Generic.Traceback */
.highlight .kc { color: #204a87; font-weight: bold } /* Keyword.Constant */
.highlight .kd { color: #204a87; font-weight: bold } /* Keyword.Declaration */
.highlight .kn { color: #204a87; font-weight: bold } /* Keyword.Namespace */
.highlight .kp { color: #204a87; font-weight: bold } /* Keyword.Pseudo */
.highlight .kr { color: #204a87; font-weight: bold } /* Keyword.Reserved */
.highlight .kt { color: #204a87; font-weight: bold } /* Keyword.Type */
.highlight .ld { color: #000000 } /* Literal.Date */
.highlight .m { color: #0000cf; font-weight: bold } /* Literal.Number */
.highlight .s { color: #4e9a06 } /* Literal.String */
.highlight .na { color: #c4a000 } /* Name.Attribute */
.highlight .nb { color: #204a87 } /* Name.Builtin */
.highlight .nc { color: #000000 } /* Name.Class */
.highlight .no { color: #000000 } /* Name.Constant */
.highlight .nd { color: #5c35cc; font-weight: bold } /* Name.Decorator */
.highlight .ni { color: #ce5c00 } /* Name.Entity */
.highlight .ne { color: #cc0000; font-weight: bold } /* Name.Exception */
.highlight .nf { color: #000000 } /* Name.Function */
.highlight .nl { color: #f57900 } /* Name.Label */
.highlight .nn { color: #000000 } /* Name.Namespace */
.highlight .nx { color: #000000 } /* Name.Other */
.highlight .py { color: #000000 } /* Name.Property */
.highlight .nt { color: #204a87; font-weight: bold } /* Name.Tag */
.highlight .nv { color: #000000 } /* Name.Variable */
.highlight .ow { color: #204a87; font-weight: bold } /* Operator.Word */
.highlight .w { color: #f8f8f8; text-decoration: underline } /* Text.Whitespace */
.highlight .mb { color: #0000cf; font-weight: bold } /* Literal.Number.Bin */
.highlight .mf { color: #0000cf; font-weight: bold } /* Literal.Number.Float */
.highlight .mh { color: #0000cf; font-weight: bold } /* Literal.Number.Hex */
.highlight .mi { color: #0000cf; font-weight: bold } /* Literal.Number.Integer */
.highlight .mo { color: #0000cf; font-weight: bold } /* Literal.Number.Oct */
.highlight .sb { color: #4e9a06 } /* Literal.String.Backtick */
.highlight .sc { color: #4e9a06 } /* Literal.String.Char */
.highlight .sd { color: #8f5902; font-style: italic } /* Literal.String.Doc */
.highlight .s2 { color: #4e9a06 } /* Literal.String.Double */
.highlight .se { color: #4e9a06 } /* Literal.String.Escape */
.highlight .sh { color: #4e9a06 } /* Literal.String.Heredoc */
.highlight .si { color: #4e9a06 } /* Literal.String.Interpol */
.highlight .sx { color: #4e9a06 } /* Literal.String.Other */
.highlight .sr { color: #4e9a06 } /* Literal.String.Regex */
.highlight .s1 { color: #4e9a06 } /* Literal.String.Single */
.highlight .ss { color: #4e9a06 } /* Literal.String.Symbol */
.highlight .bp { color: #3465a4 } /* Name.Builtin.Pseudo */
.highlight .vc { color: #000000 } /* Name.Variable.Class */
.highlight .vg { color: #000000 } /* Name.Variable.Global */
.highlight .vi { color: #000000 } /* Name.Variable.Instance */
.highlight .il { color: #0000cf; font-weight: bold } /* Literal.Number.Integer.Long */
</style>
</head>
<body>
<div id="content">
<header>
<h1 class="title">编写emacs插件</h1>
</header><nav id="table-of-contents">
<h2>Table of Contents</h2>
<div id="text-table-of-contents">
<ul>
<li><a href="#orgheadline3">1. 前言</a>
<ul>
<li><a href="#orgheadline1">1.1. quote函数</a></li>
<li><a href="#orgheadline2">1.2. 链表结构</a></li>
</ul>
</li>
<li><a href="#orgheadline48">2. elisp基础</a>
<ul>
<li><a href="#orgheadline4">2.1. 注释</a></li>
<li><a href="#orgheadline5">2.2. 程序中的操作对象</a></li>
<li><a href="#orgheadline8">2.3. 类型检测</a>
<ul>
<li><a href="#orgheadline6">2.3.1. type-of</a></li>
<li><a href="#orgheadline7">2.3.2. 其他p型函数</a></li>
</ul>
</li>
<li><a href="#orgheadline11">2.4. 相等判断</a>
<ul>
<li><a href="#orgheadline9">2.4.1. eq</a></li>
<li><a href="#orgheadline10">2.4.2. equal</a></li>
</ul>
</li>
<li><a href="#orgheadline16">2.5. 定义变量</a>
<ul>
<li><a href="#orgheadline12">2.5.1. defvar</a></li>
<li><a href="#orgheadline13">2.5.2. defconst</a></li>
<li><a href="#orgheadline14">2.5.3. defcustom</a></li>
<li><a href="#orgheadline15">2.5.4. defgroup</a></li>
</ul>
</li>
<li><a href="#orgheadline17">2.6. eval-last-sexp</a></li>
<li><a href="#orgheadline18">2.7. concat函数</a></li>
<li><a href="#orgheadline19">2.8. substring函数</a></li>
<li><a href="#orgheadline20">2.9. buffer-name</a></li>
<li><a href="#orgheadline21">2.10. buffer-file-name</a></li>
<li><a href="#orgheadline22">2.11. load-file-name</a></li>
<li><a href="#orgheadline23">2.12. file-name-directory</a></li>
<li><a href="#orgheadline24">2.13. 读取某个文件内容</a></li>
<li><a href="#orgheadline25">2.14. if函数</a></li>
<li><a href="#orgheadline26">2.15. and</a></li>
<li><a href="#orgheadline27">2.16. or</a></li>
<li><a href="#orgheadline28">2.17. cond</a></li>
<li><a href="#orgheadline29">2.18. defun定义自己的函数</a></li>
<li><a href="#orgheadline30">2.19. let创建局部变量</a></li>
<li><a href="#orgheadline31">2.20. 基本lisp链表操作元函数</a></li>
<li><a href="#orgheadline35">2.21. alist和plist</a>
<ul>
<li><a href="#orgheadline32">2.21.1. plist-get</a></li>
<li><a href="#orgheadline33">2.21.2. assoc</a></li>
<li><a href="#orgheadline34">2.21.3. assq</a></li>
</ul>
</li>
<li><a href="#orgheadline36">2.22. reverse函数</a></li>
<li><a href="#orgheadline37">2.23. nth</a></li>
<li><a href="#orgheadline38">2.24. nthcdr</a></li>
<li><a href="#orgheadline39">2.25. last</a></li>
<li><a href="#orgheadline40">2.26. remove</a></li>
<li><a href="#orgheadline47">2.27. 集合相关函数</a>
<ul>
<li><a href="#orgheadline41">2.27.1. member</a></li>
<li><a href="#orgheadline42">2.27.2. intersection</a></li>
<li><a href="#orgheadline43">2.27.3. union</a></li>
<li><a href="#orgheadline44">2.27.4. set-difference</a></li>
<li><a href="#orgheadline45">2.27.5. subsetp</a></li>
<li><a href="#orgheadline46">2.27.6. set-exclusive-or</a></li>
</ul>
</li>
</ul>
</li>
<li><a href="#orgheadline76">3. elisp进阶</a>
<ul>
<li><a href="#orgheadline49">3.1. current-buffer</a></li>
<li><a href="#orgheadline50">3.2. other-buffer</a></li>
<li><a href="#orgheadline51">3.3. switch-to-buffer</a></li>
<li><a href="#orgheadline52">3.4. buffer-size</a></li>
<li><a href="#orgheadline53">3.5. point对象</a></li>
<li><a href="#orgheadline54">3.6. interactive</a></li>
<li><a href="#orgheadline55">3.7. save-excursion</a></li>
<li><a href="#orgheadline56">3.8. next-line</a></li>
<li><a href="#orgheadline57">3.9. mark-whole-buffer</a></li>
<li><a href="#orgheadline58">3.10. subst</a></li>
<li><a href="#orgheadline59">3.11. sublis</a></li>
<li><a href="#orgheadline60">3.12. funcall</a></li>
<li><a href="#orgheadline61">3.13. mapcar</a></li>
<li><a href="#orgheadline62">3.14. lambda</a></li>
<li><a href="#orgheadline63">3.15. find-if</a></li>
<li><a href="#orgheadline64">3.16. remove-if-not</a></li>
<li><a href="#orgheadline65">3.17. remove-if</a></li>
<li><a href="#orgheadline66">3.18. reduce</a></li>
<li><a href="#orgheadline67">3.19. every</a></li>
<li><a href="#orgheadline68">3.20. incf</a></li>
<li><a href="#orgheadline69">3.21. decf</a></li>
<li><a href="#orgheadline70">3.22. push</a></li>
<li><a href="#orgheadline71">3.23. pop</a></li>
<li><a href="#orgheadline72">3.24. when</a></li>
<li><a href="#orgheadline73">3.25. unless</a></li>
<li><a href="#orgheadline74">3.26. dotimes 和dolist函数</a></li>
<li><a href="#orgheadline75">3.27. 理解递归</a></li>
</ul>
</li>
<li><a href="#orgheadline77">4. 定义自己的包</a></li>
<li><a href="#orgheadline81">5. 附录</a>
<ul>
<li><a href="#orgheadline78">5.1. emacs中使用common-lisp</a></li>
<li><a href="#orgheadline79">5.2. 命令行执行emacs里面的命令</a></li>
<li><a href="#orgheadline80">5.3. 参考资料</a></li>
</ul>
</li>
</ul>
</div>
</nav>


<div class="outline-2">
<h2 id="orgheadline3">前言</h2>
<div class="outline-text-2" id="text-1">
<p>
编写emacs插件的过程实际上就是熟悉elisp这门语言的过程。lisp语言在很多方面都和我们接触的其他大部分语言与众不同。要理解这点最关键的就是要理解lisp语言的链表数据结构。
</p>

<p>
因为我以前折腾过一段时间的common-lisp了，所以下面的谈论就大致回顾一下lisp的最核心的一些特性（也不会拘泥于某些语法细节）:
</p>

<p>
lisp语言里面最基本的元素是atom的，是atom类型的元素可以直接eval，你可以在emacs下输入 <code>M-x ielm</code> 来进入elisp的交互环境试着输入 1 或者 "abc" 来看一下。你可以如下来看看某个元素是不是数字:
</p>

<div class="highlight"><pre><span></span><span class="nv">ELISP&gt;</span> <span class="p">(</span><span class="nf">numberp</span> <span class="mf">1.1</span><span class="p">)</span>
<span class="no">t</span>
</pre></div>

<p>
类似的我们有 <code>stringp</code> 来判断目标元素是不是字符串。lisp的 <code>t</code> 和 <code>nil</code> 就是布尔真和布尔假。然后空表()也表示nil，然后其他所有东西都看作真。除开上面讲的有具体值atom元素，第二大类元素就是符号(symbol)，所谓symbol就是你在lisp里面简单输入一个x，其就是一个符号，这个符号具体的值可以对应为某个函数，或者某个值。
</p>

<p>
然后接下来lisp的第二大概念就是列表，lisp的一个表达式就是一个列表。比如:
</p>
<div class="highlight"><pre><span></span><span class="nv">ELISP&gt;</span> <span class="p">(</span><span class="nf">+</span> <span class="mi">2</span> <span class="mi">5</span><span class="p">)</span>
<span class="mi">7</span>
<span class="nv">ELISP&gt;</span> <span class="p">(</span><span class="nf">*</span> <span class="mi">5</span> <span class="mi">5</span><span class="p">)</span>
<span class="mi">25</span>
</pre></div>

<p>
若这个列表被eval执行，也就是如上输入，则该列表第一个元素总认为是一个函数，然后后面的都是该函数的各个参数。具体函数定义细节这里略过。
</p>
</div>

<div class="outline-3">
<h3 id="orgheadline1">quote函数</h3>
<div class="outline-text-3" id="text-1-1">
<p>
在lisp系统中，quote是一个特殊的函数，其意思是:
</p>
<pre>
(eval (quote x)) = x
</pre>

<p>
也就是后面的元素跳过eval，直接返回自身。上面的 (quote x) 还有一种简写形式 'x ，你可以直接输入'x来返回某个符号对象。
</p>

<div class="highlight"><pre><span></span><span class="nv">ELISP&gt;</span> <span class="ss">&#39;x</span>
<span class="nv">x</span>
<span class="nv">ELISP&gt;</span> <span class="o">&#39;</span><span class="p">(</span><span class="mi">1</span> <span class="mi">2</span> <span class="mi">3</span><span class="p">)</span>
<span class="p">(</span><span class="mi">1</span> <span class="mi">2</span> <span class="mi">3</span><span class="p">)</span>
</pre></div>

<p>
这里需要读者深刻理解，因为在lisp语言中，任何一个列表都将被eval的，而具体就是递归遍历列表内的各个元素，将各个元素都求出值出来，这里所谓的求出值，就是最终元素为上面讲的atom元素类型，或者数字或者字符串。如果是列表套列表结构（或者说得不规范点，括号套括号结构），那么里面的子列表可以看作大列表内的子元素，然后其又将继续eval之。如此递归循环，直到得出某个结果。然后对于每个列表的eval都将其内的第一个元素视作函数。
</p>

<p>
因此quote函数被lisp语言里面广泛使用，被用作表达本符号自身，然后出了第一个eval列表之后，到达父列表，其就是x也就是被eval出该符号对应的值了。所以我们也可以把引用包装某个符号看作将该符号的值传递给父环境列表中。
</p>

<p>
因为其他编程语言的列表和lisp语言里面的列表相去甚远，所以最好称之为链表。下面将介绍一下lisp语言的链表结构，理解这点对于理解lisp语言和编程模式是很关键的。
</p>
</div>
</div>


<div class="outline-3">
<h3 id="orgheadline2">链表结构</h3>
<div class="outline-text-3" id="text-1-2">
<p>
本小节的例子使用的是common-lisp，但这里具体是要理解lisp语言底层的链表结构，这一点各个lisp方言包括emacs-lisp都是一致的。
</p>

<p>
首先推荐读者到 <a href="http://www.cs.cmu.edu/~dst/Lisp/sdraw/sdraw.generic">这里</a> 下载该网页文件保存为 <code>sdraw.lisp</code> 。然后在slime中加载如下所示:
</p>
<div class="highlight"><pre><span></span><span class="nv">CL-USER&gt;</span> <span class="p">(</span><span class="nb">load</span> <span class="s">&quot;~/sdraw.lisp&quot;</span><span class="p">)</span>
<span class="c1">;; Loading file /home/wanze/sdraw.lisp ...</span>
<span class="c1">;; Loaded file /home/wanze/sdraw.lisp</span>
<span class="no">T</span>
<span class="nv">CL-USER&gt;</span> <span class="p">(</span><span class="nv">sdraw</span> <span class="o">&#39;</span><span class="p">(</span><span class="s">&quot;a&quot;</span><span class="p">))</span>

<span class="nv">[*|*]---&gt;NIL</span>
<span class="nv"> |</span>
 <span class="nv">v</span>
<span class="s">&quot;a&quot;</span>
<span class="c1">; No value</span>
</pre></div>

<p>
这里 <strong>load</strong> 函数就是加载某个lisp脚本，这个lisp脚本提供了一个 <strong>sdraw</strong> 函数，其可以画出你给出的链表的结构图，是个不错的工具。
</p>

<p>
我们看到上面的例子，链表("a")里面就一个元素，其实际上是由两个部分组成的，第一个是car，也就是链表头，第二个是cdr，也就是链表尾。如下所示:
</p>

<div class="highlight"><pre><span></span><span class="nv">CL-USER&gt;</span> <span class="p">(</span><span class="nb">car</span> <span class="o">&#39;</span><span class="p">(</span><span class="s">&quot;a&quot;</span><span class="p">))</span>
<span class="s">&quot;a&quot;</span>
<span class="nv">CL-USER&gt;</span> <span class="p">(</span><span class="nb">cdr</span> <span class="o">&#39;</span><span class="p">(</span><span class="s">&quot;a&quot;</span><span class="p">))</span>
<span class="no">NIL</span>
<span class="nv">CL-USER&gt;</span>
</pre></div>

<p>
然后我们再来看两个元素的情况:
</p>
<div class="highlight"><pre><span></span><span class="nv">CL-USER&gt;</span> <span class="p">(</span><span class="nv">sdraw</span> <span class="o">&#39;</span><span class="p">(</span><span class="s">&quot;a&quot;</span> <span class="s">&quot;b&quot;</span><span class="p">))</span>

<span class="nv">[*|*]---&gt;[*|*]---&gt;NIL</span>
 <span class="nv">|        |</span>
 <span class="nv">v</span>        <span class="nv">v</span>
<span class="s">&quot;a&quot;</span>      <span class="s">&quot;b&quot;</span>
</pre></div>

<p>
我们看到lisp的链表大致由叫做cons cell的东西链接起来的，这个cons cell分为两部分，一个头（car），一个尾（cdr），然后头或尾可以具体指向某个值，其中头或者尾指向某个具体的值则表明该链接终止了。一般的链表就如同上面所示，头指向某个具体的值，尾链接其他cons cell或者最终指向nil终止。但实际上还有一种结构:
</p>

<div class="highlight"><pre><span></span><span class="nv">CL-USER&gt;</span> <span class="p">(</span><span class="nv">sdraw</span> <span class="o">&#39;</span><span class="p">(</span><span class="s">&quot;a&quot;</span> <span class="o">.</span> <span class="s">&quot;b&quot;</span><span class="p">))</span>

<span class="nv">[*|*]---&gt;&quot;b&quot;</span>
<span class="nv"> |</span>
 <span class="nv">v</span>
<span class="s">&quot;a&quot;</span>
</pre></div>


<p>
下面再贴一个链表之内还有一个链表的情况:
</p>
<div class="highlight"><pre><span></span><span class="nv">CL-USER&gt;</span> <span class="p">(</span><span class="nv">sdraw</span> <span class="o">&#39;</span><span class="p">(</span><span class="s">&quot;a&quot;</span> <span class="p">(</span><span class="s">&quot;b&quot;</span> <span class="s">&quot;c&quot;</span><span class="p">)))</span>

<span class="nv">[*|*]---&gt;[*|*]---&gt;NIL</span>
 <span class="nv">|        |</span>
 <span class="nv">v</span>        <span class="nv">v</span>
<span class="s">&quot;a&quot;</span>      <span class="nv">[*|*]---&gt;[*|*]---&gt;NIL</span>
          <span class="nv">|        |</span>
          <span class="nv">v</span>        <span class="nv">v</span>
         <span class="s">&quot;b&quot;</span>      <span class="s">&quot;c&quot;</span>
</pre></div>

<p>
实际上这里所谓的 cons cell 的cons是英文单词链接concatenate的缩写，你可以如下来自己构建一个链表结构:
</p>
<div class="highlight"><pre><span></span><span class="nv">CL-USER&gt;</span> <span class="p">(</span><span class="nb">cons</span> <span class="s">&quot;a&quot;</span> <span class="no">nil</span><span class="p">)</span>
<span class="p">(</span><span class="s">&quot;a&quot;</span><span class="p">)</span>
<span class="nv">CL-USER&gt;</span> <span class="p">(</span><span class="nb">cons</span> <span class="s">&quot;a&quot;</span> <span class="o">&#39;</span><span class="p">(</span><span class="s">&quot;b&quot;</span> <span class="s">&quot;c&quot;</span><span class="p">))</span>
<span class="p">(</span><span class="s">&quot;a&quot;</span> <span class="s">&quot;b&quot;</span> <span class="s">&quot;c&quot;</span><span class="p">)</span>
<span class="nv">CL-USER&gt;</span> <span class="p">(</span><span class="nb">cons</span> <span class="s">&quot;a&quot;</span> <span class="o">&#39;</span><span class="p">((</span><span class="s">&quot;b&quot;</span> <span class="s">&quot;c&quot;</span><span class="p">)))</span>
<span class="p">(</span><span class="s">&quot;a&quot;</span> <span class="p">(</span><span class="s">&quot;b&quot;</span> <span class="s">&quot;c&quot;</span><span class="p">))</span>
<span class="nv">CL-USER&gt;</span>
</pre></div>

<p>
这里就是构建一个cons cell，car指向第一个参数，cdr指向第二个参数。
</p>

<p>
上面谈及的lisp语言系最通用的一些概念，具有普适性。然后接下来lisp编程的故事就是各种各样的函数——官方内置的或者你自己定义的了。这其中各个lisp方言之间差异就很大了。我们后面再详细讨论之。
</p>
</div>
</div>
</div>


<div class="outline-2">
<h2 id="orgheadline48">elisp基础</h2>
<div class="outline-text-2" id="text-2">
</div><div class="outline-3">
<h3 id="orgheadline4">注释</h3>
<div class="outline-text-3" id="text-2-1">
<p>
注释用 <code>;</code> 符号开始。
</p>
</div>
</div>

<div class="outline-3">
<h3 id="orgheadline5">程序中的操作对象</h3>
<div class="outline-text-3" id="text-2-2">
<ul class="org-ul">
<li>integer float 同样存在数值范围限制，这个程序员注意点就可以了</li>

<li>character 这个比较特殊，不是 'a' 这样的表达，而是 ?a 这样的输入，然后字符实际上就是一个数值，此外特殊的字符还有:</li>
</ul>
<pre>
?\a ⇒ 7    ; control-g, C-g
?\b ⇒ 8    ; backspace, BS, C-h
?\t ⇒ 9    ; tab, TAB, C-i
?\n ⇒ 10   ; newline, C-j
?\v ⇒ 11   ; vertical tab, C-k
?\f ⇒ 12   ; formfeed character, C-l
?\r ⇒ 13   ; carriage return, RET, C-m
?\e ⇒ 27   ; escape character, ESC, C-[
?\s ⇒ 32   ; space character, SPC
?\\ ⇒ 92   ; backslash character, \
?\d ⇒ 127  ; delete character, DEL
</pre>

<p>
特殊符号的转义，这些符号应该用 \ 来进行转义:
</p>
<pre>
( ) \ | ; " # . ,
</pre>
<p>
官方文档还有单左引号和单右引号 ’‘ ，似乎在英文中并没使用这两个符号啊？
</p>

<ul class="org-ul">
<li>symbol 可以看作其他语言的变量名</li>

<li>sequence 其包括 list（） 和 array（arrayp） 。array是定长数组，其又可以分为: string vector char-table（char-table-p） bool-table 。sequence不可以读两次？
<ul class="org-ul">
<li>string 一大段字符串可以用 \ 换行  char-or-string-p</li>
<li><p>
vertor  
</p>
<pre>
ELISP&gt; [1 2 3]
[1 2 3]
</pre></li>
</ul></li>
</ul>

<p>
bool-vector-p
</p>

<ul class="org-ul">
<li>cons cell 结构，这个就是lisp语言的底层了。 consp</li>
<li>dotted pair notation 其实也是一种更 cons cell 结构，只是两端都有值 (a . b)</li>
<li>association list  基于前面的dotted pair notation:</li>
</ul>
</div>
</div>


<div class="outline-3">
<h3 id="orgheadline8">类型检测</h3>
<div class="outline-text-3" id="text-2-3">
</div><div class="outline-4">
<h4 id="orgheadline6">type-of</h4>
</div>

<div class="outline-4">
<h4 id="orgheadline7">其他p型函数</h4>
<div class="outline-text-4" id="text-2-3-2">
<p>
atom
arrayp
bool-vector-p
bufferp
byte-code-function-p
case-table-p
char-or-string-p
char-table-p
commandp 
consp 
custom-variable-p
display-table-p
floatp
fontp
frame-configuration-p
frame-live-p
framep
functionp
hash-table-p
integer-or-marker-p
integerp
keymapp 
keywordp
listp 
markerp
wholenump
nlistp 
numberp 
number-or-marker-p
overlayp
processp
sequencep
stringp 
subrp 
symbolp
syntax-table-p
vectorp
window-configuration-p
window-live-p
windowp 
booleanp
string-or-null-p
</p>
</div>
</div>
</div>


<div class="outline-3">
<h3 id="orgheadline11">相等判断</h3>
<div class="outline-text-3" id="text-2-4">
<p>
相等判断：equal   eq   eql  =  equalp
eq是运算最快的了，它只比较地址。
equal比较内容。
eql类似eq，比较地址，还专门针对不同类型的数字。
= 专门针对不同类型的数字
equalp和equal差不多，但是忽略字符中的大小写。
</p>
</div>


<div class="outline-4">
<h4 id="orgheadline9">eq</h4>
<div class="outline-text-4" id="text-2-4-1">
<p>
test if the same object
</p>
<pre>
(eq object1 object2)
</pre>
</div>
</div>

<div class="outline-4">
<h4 id="orgheadline10">equal</h4>
<div class="outline-text-4" id="text-2-4-2">
<p>
test if has the same components
</p>
<pre>
(equal object1 object2)
</pre>

<p>
equal-including-properties object1 object2
</p>
</div>
</div>
</div>


<div class="outline-3">
<h3 id="orgheadline16">定义变量</h3>
<div class="outline-text-3" id="text-2-5">
<p>
setq是最基本的，上面已经有所介绍了。然后是defvar和defconst，一般推荐使用defvar和defconst，其中defvar用于声明变量，然后defconst用于声明常量，此外还有defcustom，defcustom比较复杂，等下再详细讨论，其和defvar，defconst的区别是defcustom适用于接口开放给用户的变量，好方便用户来定制。defvar和defconst和setq的区别是其可以接受一段字符串作为自身的描述信息，所以一般推荐使用这个。然后这几个本质上应该都是基于setq的，也就是都是定义的全局变量。
</p>
</div>

<div class="outline-4">
<h4 id="orgheadline12">defvar</h4>
<div class="outline-text-4" id="text-2-5-1">
<pre>
defvar symbol [ value [ doc-string ]]
</pre>
</div>
</div>

<div class="outline-4">
<h4 id="orgheadline13">defconst</h4>
<div class="outline-text-4" id="text-2-5-2">
<pre>
defconst symbol value [ doc-string ]
</pre>
</div>
</div>


<div class="outline-4">
<h4 id="orgheadline14">defcustom</h4>
<div class="outline-text-4" id="text-2-5-3">
<p>
defcustom参数和defvar比较起来多了一些可选项关键词参数可以填，然后前面三个意思是变量名字，初始值和说明文档。
</p>
<pre>
defcustom option standard doc [ keyword value ]
</pre>

<p>
凡是需要对外开放给用户配置的变量都推荐使用defcustom，然后通过 <code>custom-set-variables</code> 来配置这些变量。如下所示:
</p>
<pre>
(custom-set-variables
 '(cua-mode t nil (cua-base))
 '(custom-enabled-themes (quote (tango-dark))))
</pre>

<p>
<code>custom-set-variables</code> 里面定制的格式，第一个是变量名，第二个是具体的值，这都是好理解的。然后后面是一些可选的参数，now request和comment。其中now如果non-nil则该变量的值没有evaluate也进行赋值，然后request是一个feature列表，这个后面再说。comment就是一些定制说明了。
</p>


<p>
defcustom的大致格式如下:
</p>
<pre>
(defcustom org-html-use-infojs 'when-configured
  "Non-nil when Sebastian Rose's Java Script org-info.js should be active.
This option can be nil or t to never or always use the script.
It can also be the symbol `when-configured', meaning that the
script will be linked into the export file if and only if there
is a \"#+INFOJS_OPT:\" line in the buffer.  See also the variable
`org-html-infojs-options'."
  :group 'org-export-html
  :version "24.4"
  :package-version '(Org . "8.0")
  :type '(choice
	  (const :tag "Never" nil)
	  (const :tag "When configured in buffer" when-configured)
	  (const :tag "Always" t)))
</pre>

<p>
每一个关键词前面都应该加上 <code>:</code> ，下面详细讨论这些关键词:
</p>

<ul class="org-ul">
<li>:type 数据类型定义</li>
<li>:options 关于该变量的一系列的建议值</li>
<li>:group 该变量属于那个群组</li>
</ul>
</div>
</div>


<div class="outline-4">
<h4 id="orgheadline15">defgroup</h4>
<div class="outline-text-4" id="text-2-5-4">
<p>
定义一个群组
</p>
<pre>
defgroup group members doc [ keyword value ]
</pre>

<p>
如果其接受 :group ，则表示该群组属于那个群组。
</p>
</div>
</div>
</div>


<div class="outline-3">
<h3 id="orgheadline17">eval-last-sexp</h3>
<div class="outline-text-3" id="text-2-6">
<p>
eval最后一个s表达式，这个快捷键很常用 <code>C-x C-e</code> ，用来执行最后一个S表达式，方便快速测试。然后还有 <code>C-:</code> 在minibuffer下进行互动。比如下面写上这么一行，然后在行尾执行 <code>C-x C-e</code>
</p>

<p>
(defun hello () (message "hello world"))
</p>

<p>
这个定义的hello命令就进入elisp环境了，然后输入 <code>C-:</code> ，在minibuffer下来输入 (hello) 来看一下效果。
</p>
</div>
</div>


<div class="outline-3">
<h3 id="orgheadline18">concat函数</h3>
<div class="outline-text-3" id="text-2-7">
<p>
字符串拼接函数
(concat "abc" "abc")
</p>
</div>
</div>


<div class="outline-3">
<h3 id="orgheadline19">substring函数</h3>
<div class="outline-text-3" id="text-2-8">
<p>
(substring "test" 0 2)
相当于python的 "test"[0:2]
</p>
</div>
</div>

<div class="outline-3">
<h3 id="orgheadline20">buffer-name</h3>
<div class="outline-text-3" id="text-2-9">
<p>
(buffer-name)
目前buffer的name
</p>
</div>
</div>

<div class="outline-3">
<h3 id="orgheadline21">buffer-file-name</h3>
<div class="outline-text-3" id="text-2-10">
<p>
(buffer-file-name)
目前buffer在系统的中的文件路径名
</p>
</div>
</div>


<div class="outline-3">
<h3 id="orgheadline22">load-file-name</h3>
<div class="outline-text-3" id="text-2-11">
<p>
load-file-name 返回该脚本所在的文件路径名，参考了 <a href="http://stackoverflow.com/questions/4088681/get-path-to-current-emacs-script-file-when-loaded-with-l-parameter">这个网页</a> 。
</p>
</div>
</div>

<div class="outline-3">
<h3 id="orgheadline23">file-name-directory</h3>
<div class="outline-text-3" id="text-2-12">
<p>
如下面的代码将返回本脚本所在的目录路径，字符串形式。
</p>
<div class="highlight"><pre><span></span><span class="p">(</span><span class="nf">file-name-directory</span> <span class="nv">load-file-name</span><span class="p">)</span>
</pre></div>

<p>
如果你需要将这个值存储进某个变量中，那么推荐使用defvar或defcustom。
</p>
</div>
</div>


<div class="outline-3">
<h3 id="orgheadline24">读取某个文件内容</h3>
<div class="outline-text-3" id="text-2-13">
<p>
参考了 <a href="http://ergoemacs.org/emacs/elisp_read_file_content.html">这个网页</a> 。
</p>

<div class="highlight"><pre><span></span><span class="p">(</span><span class="nb">defun</span> <span class="nv">get-string-from-file</span> <span class="p">(</span><span class="nv">filePath</span><span class="p">)</span>
  <span class="s">&quot;Return filePath&#39;s file content.&quot;</span>
  <span class="p">(</span><span class="nb">with-temp-buffer</span>
    <span class="p">(</span><span class="nf">insert-file-contents</span> <span class="nv">filePath</span><span class="p">)</span>
    <span class="p">(</span><span class="nf">buffer-string</span><span class="p">)))</span>
</pre></div>
</div>
</div>


<div class="outline-3">
<h3 id="orgheadline25">if函数</h3>
<div class="outline-text-3" id="text-2-14">
<p>
if函数最简单的理解如下所示:
</p>
<div class="highlight"><pre><span></span><span class="nv">CL-USER&gt;</span> <span class="p">(</span><span class="k">if</span> <span class="no">t</span> <span class="mi">5</span> <span class="mi">3</span><span class="p">)</span>
<span class="mi">5</span>
<span class="nv">CL-USER&gt;</span> <span class="p">(</span><span class="k">if</span> <span class="no">nil</span> <span class="mi">5</span> <span class="mi">3</span><span class="p">)</span>
<span class="mi">3</span>
<span class="nv">CL-USER&gt;</span>
</pre></div>
<p>
如果第二个元素估值为t，则返回第三个元素的值，如果是nil则返回第四个元素的值。然后第四个元素可以不填，也就是nil的时候什么都不做或者说返回nil。
</p>
</div>
</div>

<div class="outline-3">
<h3 id="orgheadline26">and</h3>
<div class="outline-text-3" id="text-2-15">
<p>
and是先evaluate一个，如果是真，那么going on to evaluate，如果是nil，那么返回nil。
and还有一个有趣的性质，那就是如果都为真，那么最后返回的不是t，而是最后那个信息的结果。
</p>
</div>
</div>


<div class="outline-3">
<h3 id="orgheadline27">or</h3>
<div class="outline-text-3" id="text-2-16">
<p>
or是先evaluate一个，如果是真就report，同样返回这个信息的结果，如果是nil，keep going on to search。
(or nil nil 'apple 'blue)-&#x2014;&gt;apple
</p>
</div>
</div>


<div class="outline-3">
<h3 id="orgheadline28">cond</h3>
<div class="outline-text-3" id="text-2-17">
<p>
cond函数相当于c语言的switch语句。
</p>
</div>
</div>


<div class="outline-3">
<h3 id="orgheadline29">defun定义自己的函数</h3>
<div class="outline-text-3" id="text-2-18">
<p>
在lisp中讲到定义函数就不得不提lambda表达式，对lambda表达式有兴趣的请上网搜索相关信息了解之。简单来说就是如这样的 <code>(lambda (x) (* x x))</code> 一种匿名函数表示方法。该列表第二项定义的该函数的入口参数，然后第三项定义的是该函数的结果返回形式。对应的通过 <strong>defun</strong> 来定义自己的函数如下所示:
</p>

<div class="highlight"><pre><span></span><span class="p">(</span><span class="nb">defun</span> <span class="nv">square</span> <span class="p">(</span><span class="nv">x</span><span class="p">)</span> <span class="p">(</span><span class="nb">*</span> <span class="nv">x</span> <span class="nv">x</span><span class="p">))</span>
</pre></div>

<p>
通过defun定义的有名函数，底层实质就是lambda函数机制，不过是给具体的那个lambda函数对象赋了一个名字罢了。我们前面说道lisp在eval一个链表的时候，其第一项将被默认认为是一个函数对象，其实质就是指向了一个lambda函数对象。
</p>

<p>
elisp下的defun多了两个内容，一是文档，其实可选的:
</p>
<pre>
(defun multiply-by-seven (number)
"Multiply NUMBER by seven."
(* 7 number))
</pre>

<p>
二是对用户接口的开放，其也是可选的，interactive函数，这个后面再谈论。
</p>
<pre>
(defun function-name (arguments...)
"optional-documentation..."
(interactive argument-passing-info)
body...)
</pre>
</div>
</div>

<div class="outline-3">
<h3 id="orgheadline30">let创建局部变量</h3>
<div class="outline-text-3" id="text-2-19">
<p>
let 主要用于创造local  variables
</p>

<p>
let 在body中遇到不认识的变量了，首先在自己内部找，如果找不到，那么在global variable中找。
然后没定义一个defun其函数内部都有自己独立的语境，即用自己的局域变量，找不到就用广义变量。还找不到就说出现错误
</p>

<p>
let*和let的区别就是一次只运算赋值一个本地变量，然后再第二个。也就是说如果第二个的赋值依赖于第一个的话，那么推荐用let*。比如说我先赋值r，然后赋值面积等于2 * pai*r，那么第二个赋值就依赖于第二个。这种情况用let就会出现错误。但是编程一般用let，为了竟可能减少程序间的依赖关系，方便理解
</p>
</div>
</div>


<div class="outline-3">
<h3 id="orgheadline31">基本lisp链表操作元函数</h3>
<div class="outline-text-3" id="text-2-20">
<p>
也就是car cdr caddr 之类的，elisp同样也是支持的。
</p>

<p>
(cadr '(1 2 3))
=&gt; 2
</p>

<p>
cadr 等于 second 
</p>

<p>
(second '(1 2 3))
</p>

<p>
caddr 等于 third 
</p>

<p>
(third '(1 2 3))
=&gt; 3
</p>

<p>
然后 cons list append 函数，这些也是很基本的，elisp同样也支持。
</p>

<p>
cons这个命令就是创建cons cell结构，通常用于把元素添加到列表头上。
(cons "a" '("b" "c"))
=&gt; ("a" "b" "c")
</p>


<p>
list命令就是创建一个列表，将这些元素用括号包围起来:
(list 1 2 3)
=&gt; (1 2 3)
</p>

<p>
append命令用于往列表后面加入某个元素:
(append '(5 4) '(3))
=&gt; (5 4 3)
需要注意的是第二个元素必须是列表，所以append命令对应可以看作python中的两个列表的extend或者+操作。
</p>

<p>
值得一提的是append命令第二个元素如果不是列表，而是一个元素的话，程序不会出错，而是返回这样的dot list。
(append '("a") 1)
=&gt; ("a" . 1)
</p>

<p>
这可以用于构建alist，然后cons命令如果第二个参数是元素，构建的也是这样的dot list:
(cons "a" 1)
=&gt; ("a" . 1) 
</p>

<p>
然后append命令第一个元素必须是列表，否则会出现错误。
(append 'a '(b c))&#x2014;&gt;error!!
</p>
</div>
</div>

<div class="outline-3">
<h3 id="orgheadline35">alist和plist</h3>
<div class="outline-text-3" id="text-2-21">
<p>
alist是这样的结构:
alist  ((key1 . value1)
  (key2 . value2)
  (key3 . value3))
</p>

<p>
plist 是这样的结构:
plist 
(key1 value1
  key2 value2
  key3 value3)
</p>

<p>
参看了 <a href="http://www.emacswiki.org/emacs/AlistVsPlist">这个网页</a> ，alist可以简单来模拟类似python语言的字典结构，但如果需要考虑效率了，则推荐使用hash table结构。然后plist一般推荐在key不变的情况下使用。
</p>
</div>


<div class="outline-4">
<h4 id="orgheadline32">plist-get</h4>
<div class="outline-text-4" id="text-2-21-1">
<p>
提取plist的某个值:
(plist-get '(foo 4) 'foo)
=&gt; 4
</p>
</div>
</div>

<div class="outline-4">
<h4 id="orgheadline33">assoc</h4>
<div class="outline-text-4" id="text-2-21-2">
<p>
提取alist的某个值:
(assoc 'key alist)
</p>
</div>
</div>

<div class="outline-4">
<h4 id="orgheadline34">assq</h4>
<div class="outline-text-4" id="text-2-21-3">
<p>
assq  alist的配套查询函数  类似 assoc 只是用 'eq' 替代了 'equal'
</p>
</div>
</div>
</div>


<div class="outline-3">
<h3 id="orgheadline36">reverse函数</h3>
<div class="outline-text-3" id="text-2-22">
<p>
reverse函数，列表翻转函数，这里强调的是列表的第一层元素:
(reverse '((a b) (c d) (e f)))
=&gt; ((e f) (c d) (a b))
</p>

<p>
(reverse '(1 2 3))
=&gt; (3 2 1)
</p>
</div>
</div>

<div class="outline-3">
<h3 id="orgheadline37">nth</h3>
<div class="outline-text-3" id="text-2-23">
<p>
提取列表的第几个元素:
(nth 0 '(a b c))
=&gt; a
</p>
</div>
</div>

<div class="outline-3">
<h3 id="orgheadline38">nthcdr</h3>
<div class="outline-text-3" id="text-2-24">
<p>
cdr命令我们是知道的，nth就是做几次cdr命令。所以做0次就是原列表，做一次cdr等等。
需要注意的就是：
(cdr nil)
=&gt; nil
</p>

<p>
也就是对空列表cdr还是空列表，所以如果cdr过头了就会得到nil，但是有一个例外，那就是dotted list。
因为dotted list是以一个元素作结尾，这样将会导致错误。因为cdr只能对列表进行操作。
(nthcdr 2 '(a b c))
=&gt; (c)
</p>
</div>
</div>


<div class="outline-3">
<h3 id="orgheadline39">last</h3>
<div class="outline-text-3" id="text-2-25">
<p>
last返回的是列表的最后一个cons cell结构。
(last nil)&#x2014;&gt;nil
</p>

<p>
对于正常的列表就是返回最后一个元素，不过是加了列表符号的。
(last '(a b c))&#x2014;&gt;(c)
</p>

<p>
对于dotted list则是所谓的最后一个cons cell:
(last '("a" . 1)) -&gt; '("a" . 1)
这是因为(c) 的完整结构是 [c|nil] 
</p>
</div>
</div>


<div class="outline-3">
<h3 id="orgheadline40">remove</h3>
<div class="outline-text-3" id="text-2-26">
<p>
remove就是把某个列表中出现的某个元素给移去。
(remove 'a '(b a n a n a))&#x2014;&gt;(b n n)
</p>
</div>
</div>

<div class="outline-3">
<h3 id="orgheadline47">集合相关函数</h3>
<div class="outline-text-3" id="text-2-27">
</div><div class="outline-4">
<h4 id="orgheadline41">member</h4>
<div class="outline-text-4" id="text-2-27-1">
<p>
member函数的作用就是核对某个value值是不是在后面列表中。如果是那么返回真值，包括开始为真的那个值也包括后面的元素。是假那么返回nil。
</p>
</div>
</div>

<div class="outline-4">
<h4 id="orgheadline42">intersection</h4>
<div class="outline-text-4" id="text-2-27-2">
<p>
交集
</p>
</div>
</div>
<div class="outline-4">
<h4 id="orgheadline43">union</h4>
<div class="outline-text-4" id="text-2-27-3">
<p>
补集
</p>
</div>
</div>
<div class="outline-4">
<h4 id="orgheadline44">set-difference</h4>
<div class="outline-text-4" id="text-2-27-4">
<p>
差集
</p>
</div>
</div>

<div class="outline-4">
<h4 id="orgheadline45">subsetp</h4>
<div class="outline-text-4" id="text-2-27-5">
<p>
判断第一个集合是不是第二个集合的子集，是就返回T，这里是确定的t。假返回nil。
</p>
</div>
</div>

<div class="outline-4">
<h4 id="orgheadline46">set-exclusive-or</h4>
<div class="outline-text-4" id="text-2-27-6">
<p>
XOR逻辑
</p>
</div>
</div>
</div>
</div>


<div class="outline-2">
<h2 id="orgheadline76">elisp进阶</h2>
<div class="outline-text-2" id="text-3">
</div><div class="outline-3">
<h3 id="orgheadline49">current-buffer</h3>
<div class="outline-text-3" id="text-3-1">
<p>
(current-buffer)
返回目前的buffer对象，(buffer-name)返回的只是当前buffer的名字。
</p>
</div>
</div>


<div class="outline-3">
<h3 id="orgheadline50">other-buffer</h3>
<div class="outline-text-3" id="text-3-2">
<p>
(other-buffer)
下一个buffer对象
</p>
</div>
</div>

<div class="outline-3">
<h3 id="orgheadline51">switch-to-buffer</h3>
<div class="outline-text-3" id="text-3-3">
<p>
编辑器切换buffer，这个函数是面向用户的，elisp程序员推荐使用 set-buffer。
(switch-to-buffer (other-buffer))
</p>

<p>
对应的快捷键是 C-x b
</p>
</div>
</div>

<div class="outline-3">
<h3 id="orgheadline52">buffer-size</h3>
<div class="outline-text-3" id="text-3-4">
<p>
(buffer-size)
当前buffer的size
</p>
</div>
</div>

<div class="outline-3">
<h3 id="orgheadline53">point对象</h3>
<div class="outline-text-3" id="text-3-5">
<p>
(point)
</p>

<p>
(point)其返回的(point)计数是从buffer的开始到目前cursor所做所包含的字符数。
12185  &#x2013; 12196 = 11 （这显示中文字符也是只占一个字符位，奇怪。）
</p>

<p>
(point-min)  1 一般都是1
(point-max)
</p>

<p>
通常用 (point-min) 到 (point-max) 来选中整个buffer的文本内容。
</p>
</div>
</div>

<div class="outline-3">
<h3 id="orgheadline54">interactive</h3>
<div class="outline-text-3" id="text-3-6">
<p>
(interactive)
</p>

<p>
这样你定义函数就可以通过 M-x 来执行了。在minibuffer下的回显可以通过 message 函数来做到。
</p>

<p>
如果是最简单的命令不需要输入参数，那么直接写上 (interactive) 即可，如果需要输入参数，具体情况很复杂，请参看 <a href="http://www.gnu.org/software/emacs/manual/html_node/elisp/Using-Interactive.html">这个网页</a> 。
</p>

<p>
用prefix argument，比如下面这种写法:
</p>
<pre>
(defun multiply-by-seven (number)
"Multiply NUMBER by seven."
(interactive "p") 
(message "The result is %d" (* 7 number)))
</pre>

<p>
这里的小写字母 p 的意思是接受一个prefix 参数，数值型。或者大写字母 P（raw prefix argument）。然后具体使用是 <code>C-u 5 M-x commond</code> 。
</p>

<p>
这种用法我不太喜欢，还有一种参数定义方法，如下所示:
</p>
<div class="highlight"><pre><span></span><span class="p">(</span><span class="nb">defun</span> <span class="nv">multiply-by-seven</span> <span class="p">(</span><span class="nv">number</span><span class="p">)</span>
<span class="s">&quot;Multiply NUMBER by seven.&quot;</span>
<span class="p">(</span><span class="k">interactive</span> <span class="s">&quot;nplease input a number:\n&quot;</span><span class="p">)</span> 
<span class="p">(</span><span class="nf">message</span> <span class="s">&quot;The result is %d&quot;</span> <span class="p">(</span><span class="nf">*</span> <span class="mi">7</span> <span class="nv">number</span><span class="p">)))</span>
</pre></div>

<p>
这里的第一个字母 <code>n</code> 的意思是接受一个数值参数，然后后面的字符都是提示信息文字， <code>\n</code> 表示结束，若要再定义一个参数则继续写:
</p>


<div class="highlight"><pre><span></span><span class="p">(</span><span class="nb">defun</span> <span class="nv">multiply-by-seven</span> <span class="p">(</span><span class="nv">number</span> <span class="nv">str</span><span class="p">)</span>
<span class="s">&quot;Multiply NUMBER by seven.&quot;</span>
<span class="p">(</span><span class="k">interactive</span> <span class="s">&quot;nplease input a number:\nsplease input a string:\n&quot;</span><span class="p">)</span> 
<span class="p">(</span><span class="nf">message</span> <span class="s">&quot;The result is %d&quot;</span> <span class="p">(</span><span class="nf">*</span> <span class="mi">7</span> <span class="nv">number</span><span class="p">))</span>
<span class="p">(</span><span class="nf">message</span> <span class="s">&quot;your input is: %s&quot;</span> <span class="nv">str</span><span class="p">))</span>
</pre></div>

<p>
当然一般用户接口不推荐很多参数，最多一个参数就有了。
</p>
</div>
</div>


<div class="outline-3">
<h3 id="orgheadline55">save-excursion</h3>
<div class="outline-text-3" id="text-3-7">
<p>
It saves the location of point and mark
</p>

<p>
C-SPC (set-mark-command). If a mark has been set, you can use the
command C-x C-x (exchange-point-and-mark)
set-mark-command
</p>

<p>
The mark is another position in the buffer; its value can be set with a com-
mand such as C-SPC (set-mark-command). If a mark has been set, you can use the
command C-x C-x (exchange-point-and-mark) to cause the cursor to jump to the
mark and set the mark to be the previous position of point. In addition, if you set
another mark, the position of the previous mark is saved in the mark ring. Many
mark positions can be saved this way. You can jump the cursor to a saved mark by
typing C-u C-SPC one or more times.
The part of the buffer between point and mark is called the region. Numerous
commands work on the region, including center-region, count-lines-region,
kill-region, and print-region.
</p>


<p>
In addition to recording the values of point and mark, save-excursion keeps
track of the current buffer, and restores it, too. This means you can write code that
will change the buffer and have save-excursion switch you back to the original
buffer.
In Emacs Lisp code, a save-excursion expression often occurs within the body
of a let expression. It looks like this:
(let varlist
(save-excursion
body&#x2026;))
</p>
</div>
</div>


<div class="outline-3">
<h3 id="orgheadline56">next-line</h3>
<div class="outline-text-3" id="text-3-8">
<p>
跳到下一行 对应快捷键 C-n
</p>
</div>
</div>

<div class="outline-3">
<h3 id="orgheadline57">mark-whole-buffer</h3>
<div class="outline-text-3" id="text-3-9">
<p>
也就是编辑器的全选命令。对应快捷键 C-x h
</p>
</div>
</div>

<div class="outline-3">
<h3 id="orgheadline58">subst</h3>
</div>

<div class="outline-3">
<h3 id="orgheadline59">sublis</h3>
</div>


<div class="outline-3">
<h3 id="orgheadline60">funcall</h3>
</div>

<div class="outline-3">
<h3 id="orgheadline61">mapcar</h3>
</div>

<div class="outline-3">
<h3 id="orgheadline62">lambda</h3>
</div>

<div class="outline-3">
<h3 id="orgheadline63">find-if</h3>
</div>

<div class="outline-3">
<h3 id="orgheadline64">remove-if-not</h3>
</div>

<div class="outline-3">
<h3 id="orgheadline65">remove-if</h3>
</div>

<div class="outline-3">
<h3 id="orgheadline66">reduce</h3>
</div>

<div class="outline-3">
<h3 id="orgheadline67">every</h3>
</div>


<div class="outline-3">
<h3 id="orgheadline68">incf</h3>
</div>

<div class="outline-3">
<h3 id="orgheadline69">decf</h3>
</div>

<div class="outline-3">
<h3 id="orgheadline70">push</h3>
</div>

<div class="outline-3">
<h3 id="orgheadline71">pop</h3>
</div>

<div class="outline-3">
<h3 id="orgheadline72">when</h3>
</div>

<div class="outline-3">
<h3 id="orgheadline73">unless</h3>
</div>


<div class="outline-3">
<h3 id="orgheadline74">dotimes 和dolist函数</h3>
<div class="outline-text-3" id="text-3-26">
<p>
这篇文章介绍了的函数有：
factorial -&#x2014;阶乘函数
fibonnaci&#x2013;&#x2014;斐波拉契数列函数
insert  &#x2014;&#x2014;插入函数
arrange  &#x2013;&#x2014;排列函数
while和until  宏
</p>


<p>
;;;while macro
(defmacro while (test  &amp;rest body)
  `(do ()
       ((not ,test))
       ,@body))
</p>

<p>
;;;until macro
(defmacro until (test &amp;rest body)
  `(do ()
       (,test)
       ,@body))
</p>
</div>
</div>


<div class="outline-3">
<h3 id="orgheadline75">理解递归</h3>
<div class="outline-text-3" id="text-3-27">
<p>
&gt; (defun our-member (obj lst)
   (if (null lst)
       nil
   (if (eql (car lst) obj)
       lst
       (our-member obj (cdr lst)))))
OUR-MEMBER
</p>

<p>
(defun median (list)
       (let ((sortlist (sort list #'&lt;))
         (long (length list)))
         (if (oddp long) (nth (/ (- long 1) 2) sortlist) 
         (/ (+ (nth (- (/ long 2) 1) sortlist ) (nth (/ long 2) sortlist)) 2.0)))) 
</p>

<p>
defparameter
</p>
</div>
</div>
</div>


<div class="outline-2">
<h2 id="orgheadline77">定义自己的包</h2>
<div class="outline-text-2" id="text-4">
<p>
(defun p (x y)
                          (cond  ((zerop y) 1)
                                     ((= y (1- x)) 1)
                                     (t  (+ (p (1- x) (1- y)) (p (1- x) y)))))
</p>


<p>
(defun pascal (n)
                          (loop  for  i  from 0  to (1- n)
                               collect (p n i)))
</p>

<p>
(defun pascal-triangle (x)
                          (loop for i from 1 to x
                             for s = '(1) then (pascal i)
                                 do  (format t "~&amp;~s" s)))
</p>


<p>
(defmacro show-series (f a z &amp;optional (step 1))
  `(loop for n from ,a to ,z by ,step
for y = ,f
collect y ))
</p>


<p>
(defmacro sum (f a z &amp;optional (step 1))
  `(loop for n from ,a to ,z by ,step
for y = ,f
collect y into lst
finally (return (reduce #'+ lst))))
</p>


<p>
(defmacro product (f a z &amp;optional (step 1))
  `(loop for n from ,a to ,z by ,step
for y = ,f
collect y into lst
finally (return (reduce #'* lst))))
</p>

<p>
(defmacro sum (f x a b &amp;optional (step 1))
  `(loop for ,x from ,a to ,b by ,step
for y = ,f
collect y into lst
finally (return (reduce #'+ lst)))
</p>


<p>
 (defmacro show-series (f x a z &amp;optional (step 1))
  `(loop for ,x from ,a to ,z by ,step
for y = ,f
collect y ))
(defmacro product (f x a z &amp;optional (step 1))
   `(loop for ,x from ,a to ,z by ,step
for y = ,f
 collect y into lst
 finally (return (reduce #'* lst))))
</p>

<p>
 (defmacro s-integrate (f x a b &amp;optional (n 100))
`(let ((h (/ (- ,b ,a) ,n)))
  (* (* h 1/3) 
     (+ 
(let ((,x ,a)) 
    ,f)
      (* 4 (sum ,f ,x (+ ,a h) ,b (* 2 h)))
      (* 2 (sum ,f ,x (+ ,a (* 2 h)) (- ,b h) (* 2 h)))
(let ((,x ,b))
  ,f)))))
</p>
</div>
</div>


<div class="outline-2">
<h2 id="orgheadline81">附录</h2>
<div class="outline-text-2" id="text-5">
</div><div class="outline-3">
<h3 id="orgheadline78">emacs中使用common-lisp</h3>
<div class="outline-text-3" id="text-5-1">
<p>
在deb系系统中推荐直接用apt-get安装之:
</p>
<div class="highlight"><pre><span></span>apt-get install slime
</pre></div>

<p>
这样安装之后连配置都不用配置了，直接输入 <code>M-x slime</code> 即可，不过你可能还没有装一个common-lisp的解释器，gnu的 <code>clisp</code> 或者 <code>sbcl</code> 都还行吧。
</p>
</div>
</div>

<div class="outline-3">
<h3 id="orgheadline79">命令行执行emacs里面的命令</h3>
<div class="outline-text-3" id="text-5-2">
<p>
参考了 <a href="http://stackoverflow.com/questions/22072773/batch-export-of-org-mode-files-from-the-command-line">这个网页</a> 。
</p>

<p>
如下所示，将以batch批处理模式加载test.org，然后执行命令"org-html-export-to-html" 。然后这里的 <code>-u</code> 是指定以某个用户的身份来运行emacs（主要是一些配置文件相关）。
</p>
<div class="highlight"><pre><span></span><span class="nv">emacs</span> <span class="nv">test.org</span> <span class="nv">-u</span> <span class="s">&quot;$(id -un)&quot;</span> <span class="nv">--batch</span>  <span class="nv">-f</span> <span class="nv">org-html-export-to-html</span>
</pre></div>
</div>
</div>

<div class="outline-3">
<h3 id="orgheadline80">参考资料</h3>
<div class="outline-text-3" id="text-5-3">
<ol class="org-ol">
<li>COMMON LISP: A Gentle Introduction to Symbolic Computation ; Author: David S. Touretzky</li>
<li><a href="http://acl.readthedocs.org/en/latest/">ANSI Common Lisp 中文</a></li>
</ol>

<pre>
(add-to-list 'load-path "~/workspace/myemacs/myorg/org")
(require 'org)
</pre>

<p>
add-to-list
</p>
<div class="highlight"><pre><span></span><span class="nv">ELISP&gt;</span> <span class="p">(</span><span class="k">setq</span> <span class="nv">x</span> <span class="no">nil</span><span class="p">)</span>
<span class="no">nil</span>
<span class="nv">ELISP&gt;</span> <span class="p">(</span><span class="nv">add-to-list</span> <span class="ss">&#39;x</span> <span class="s">&quot;a&quot;</span><span class="p">)</span>
<span class="p">(</span><span class="s">&quot;a&quot;</span><span class="p">)</span>

<span class="nv">ELISP&gt;</span> <span class="nv">x</span>
<span class="p">(</span><span class="s">&quot;a&quot;</span><span class="p">)</span>
</pre></div>


<p>
我们常见的 load-path 就是emacs启动时搜索插件路径的列表，所以我们加入某个搜索路径有如下命令:
</p>


<pre>
(add-to-list 'load-path "~/workspace/myemacs/myorg/org")
</pre>

<p>
eval-after-load
</p>

<p>
eval-when-compile
</p>


<p>
declare-function
</p>

<p>
global-set-key
</p>
</div>
</div>
</div>
</div>
</body>
</html>