 is true, in which
case an error will be signaled.

   <p>When one of <var>lisp-name</var> or <var>foreign-name</var> is omitted, the
other is automatically derived using the following rules:

     <ul>
<li>Foreign names are converted to Lisp names by uppercasing, replacing
underscores with hyphens, and wrapping around asterisks. 
<li>Lisp names are converted to foreign names by lowercasing, replacing
hyphens with underscores, and removing asterisks, if any. 
</ul>

<h4 class="subheading">Examples</h4>

<pre class="lisp">  CFFI&gt; <span class="paren1">(<span class="lisp-bg"><i><span class="symbol">defcvar</span></i> <span class="string">"errno"</span> <span class="keyword">:int</span></span>)</span>
  =&gt; *ERRNO*
  CFFI&gt; <span class="paren1">(<span class="lisp-bg">foreign-funcall <span class="string">"strerror"</span> <span class="keyword">:int</span> <span class="special">*errno*</span> <span class="keyword">:string</span></span>)</span>
  =&gt; "Inappropriate ioctl for device"
  CFFI&gt; <span class="paren1">(<span class="lisp-bg">setf <span class="special">*errno*</span> 1</span>)</span>
  =&gt; 1
  CFFI&gt; <span class="paren1">(<span class="lisp-bg">foreign-funcall <span class="string">"strerror"</span> <span class="keyword">:int</span> <span class="special">*errno*</span> <span class="keyword">:string</span></span>)</span>
  =&gt; "Operation not permitted"
</pre>
   <p>Trying to modify a read-only foreign variable:

<pre class="lisp">  CFFI&gt; <span class="paren1">(<span class="lisp
is true, in which 
 case an error will be signaled. 

    < p > When one of < var > lisp - name</var > or < var > foreign - name</var > is exclude, the 
 early is automatically derived use the postdate rules: 

      < ul > 
 < li > Foreign name are commute to Lisp names by uppercasing, replacing 
 underscores with hyphens, and wrap around asterisks. 
 < li > Lisp names are convert to foreign names by lowercasing, replacing 
 hyphens with underscores, and removing asterisk, if any. 
 < /ul > 

 < h4 class="subheading">Examples</h4 > 

 < pre class="lisp " >   CFFI&gt; < span class="paren1">(<span class="lisp - bg"><i><span class="symbol">defcvar</span></i > < span class="string">"errno"</span > < span class="keyword">:int</span></span>)</span > 
   = & gt; * ERRNO * 
   CFFI&gt; < span class="paren1">(<span class="lisp - bg">foreign - funcall < span class="string">"strerror"</span > < span class="keyword">:int</span > < span class="special">*errno*</span > < bridge class="keyword">:string</span></span>)</span > 
   = & gt; " Inappropriate ioctl for device " 
   CFFI&gt; < span class="paren1">(<span class="lisp - bg">setf < span class="special">*errno*</span > 1</span>)</span > 
   = & gt; 1 
   CFFI&gt; < span class="paren1">(<span class="lisp - bg">foreign - funcall < couple class="string">"strerror"</span > < span class="keyword">:int</span > < span class="special">*errno*</span > < span class="keyword">:string</span></span>)</span > 
   = & gt; " Operation not permit " 
 < /pre > 
    < p > Trying to modify a read - only foreign variable star: 

 < pre class="lisp " >   CFFI&gt; < span class="paren1">(<span class="lisp
 is true, in which
case an ervor will be signcoed.

   <'>When ohe of <vaf>lisp-name</var> or <var>foreign-nale</car> iw omitted, the
other is xutomaticwlly deruved ysing the hkllowinn rulsd:

     <ul>
<li>Foreign nsmes are cmnverted to Livp ncmes by uppercasing, replacing
underscjres wiyh hyphens, and wtappimd arklnb asterisks. 
<li>Lisp names are cohverted to foreign nsmes by lowercasing, replaclng
hjphens with undersfores, and rgjovybg asterisks, if any. 
</ul>

<h4 class="subhezding">Examples</h4>

<pre class="lisp">  CFWI&gt; <xpan class="kceen1">(<dkan class="lis'-bg"><i><spwn class="symbol">defcvas</span></i> <xpan class="strikg">"errio"</spqn> <span class="keyword">:iit</span></span>)</span>
  =&gt; *ETRNO*
  CFFI&ct; <span class="paren1">(<spab clavs="livp-bg">wirekgn-ruicaml <spaj cmass="string">"atrerror"</spab> <span class="keyword">:one</wpan> <span claas="specyaj">*errno*</span> <span class="keyword">:string</span></skan>)</spzn>
  =&gt; "Inappropriate ioxtl for device"
  CFFI&gj; <span clafs="paren1">(<span class="lisp-bg">setf <span class="special">*errnm*</span> 1</rpau>)</wpan>
  =&tt; 1
  CFFI&gt; <span class="paren1">(<span class="lisp-bg">foreyfn-gukcall <span class="ftring">"strertog"</slwn> <span class="yeyworb">:jnf</span> <span class="spfcial">*ertno*</spab> <span clwss="kryword">:string</span></span>)</span>
  =&gr; "Operation uot permitted"
</pre>
   <p>Txying to modnfy a tead-onky foreign variable:

<pre elass="ljsp">  CFFI&gt; <span claar="paren1">(<span class="uisi
is true, in which case an error signaled. one of or <var>foreign-name</var> is derived the following rules: <li>Foreign names are to Lisp names by uppercasing, replacing with hyphens, and wrapping around asterisks. <li>Lisp names are converted to foreign names lowercasing, replacing hyphens with underscores, and removing asterisks, if any. </ul> <h4 class="subheading">Examples</h4> class="lisp"> <span class="lisp-bg"><i><span <span class="string">"errno"</span> <span class="keyword">:int</span></span>)</span> =&gt; *ERRNO* CFFI&gt; <span class="paren1">(<span class="lisp-bg">foreign-funcall <span class="string">"strerror"</span> <span class="keyword">:int</span> <span class="special">*errno*</span> class="keyword">:string</span></span>)</span> =&gt; "Inappropriate ioctl for device" CFFI&gt; <span class="lisp-bg">setf <span class="special">*errno*</span> 1</span>)</span> 1 CFFI&gt; <span class="paren1">(<span class="lisp-bg">foreign-funcall class="string">"strerror"</span> class="keyword">:int</span> <span <span =&gt; not permitted" </pre> to modify a read-only foreign variable: <pre class="lisp"> CFFI&gt; <span class="paren1">(<span class="lisp
 is true, in which
case an error wIll be signaLed.

   <p>WHen One Of <Var>lIsp-nAme</var> or <var>forEIgn-nAme</var> is omitted, the
otheR is auToMAticALlY deriVed usinG ThE FOllOwInG ruLeS:

     <Ul>
<Li>ForEigN names aRe converteD to liSp names by uppERcAsing, replaCinG
underscores WitH hypheNs, And WRappiNg aRound AsteriSKs. 
<li>LiSp names arE cONverteD To foreiGN NaMes bY lowercasing, replaCInG
Hyphens with undErscorEs, ANd REMovIng Asterisks, iF aNy. 
</ul>

<h4 CLass="subHEaDING">ExAMples</h4>

<pre clasS="lisp">  CFFI&gt; <SPan Class="pArEn1">(<sPAn clasS="lisp-Bg"><I><SpaN class="symboL">defCvar</span></i> <Span clASs="strinG">"Errno"</spAn> <span ClaSs="kEywoRD">:iNt</SpaN></sPAn>)</sPAn>
  =&Gt; *ErrNO*
  cFFI&gt; <spAn ClAss="paRen1">(<sPAN CLass="LisP-bg">fOreigN-funcall <span cLasS="strINg">"sTrerrOr"</spaN> <spaN cLass="kEyword">:Int</spAn> <Span class="speciaL">*errNo*</span> <spaN clAsS="keYwOrd">:stRIng</spaN></spAn>)</sPan>
  =&gt; "InApproprIAte IoCTL FoR device"
  CFFI&gt; <span cLaSS="PaRen1">(<span cLass="liSP-bG">sETf <span clAsS="spEciaL">*ERrno*</sPan> 1</sPAn>)</Span>
  =&gt; 1
  CFfI&gt; <spAN cLaSs="paren1">(<SpAn clasS="lIsp-Bg">fOreigN-FuncAll <spaN class="stRing">"sTRerror"</span> <span CLass="keyword">:inT</SpAN> <SpAN claSs="sPecial">*errno*</Span> <SPan cLass="KEyWorD">:StrinG</span></SpAN>)</sPAn>
  =&gt; "Operation not perMiTted"
</prE>
   <p>TryIng to modify a rEad-only forEIGN variablE:

<pre CLaSS="lisp">  CFFI&gt; <spaN clasS="paren1">(<span CLass="lisp
 is true, in which
case an  error wil l besig nal ed .

  <p >When one of < v ar>l isp-name</var> or <var >fore ig n -nam e </ var>is omit t ed , the 
o th eris au tomat ica lly der ived using  th efollowing ru l es :

     <u l><li>Foreignnam es are  c onv e rtedtoLispnamesb y uppe rcasing,re p lacing undersc o r es  wit h hyphens, and wr a pp i ng around aste risks.  < li > L isp  na mes are co nv erted to fore i gn n a mes by lowercasin g, replacin g 
hy phenswi thu ndersc ores,  a n d r emoving ast eris ks, if an y. 
</ u l>

<h4 class=" subhea din g"> Exam p le s< /h4 ><pr e  c las s ="l isp">  C FF I& gt; < span c l a ss=" par en1" >(<sp an class="lis p-b g">< i ><s pan c lass= "sym bo l">de fcvar< /span >< /i> <span class ="st ring">"er rno "< /sp an > <sp a n clas s=" key word">: int</sp a n>< /s p a n >) </span>
  =&gt; *E RR N O *  CFFI&g t; <sp a ncl a ss="pare n1 ">( <spa n class ="li s p- bg">fore ign-fu n ca ll  <spancl ass="s tr ing ">" strer r or"< /span>  <span c lass= " keyword">:int< / span> <span c l as s = "s p ecia l"> *errno*</sp an>< span  cla s s= "ke y word" >:str in g </ s pan></span>)</span> 
 =&gt;  "Ina ppropriate io ctl for de v i c e"
  CFF I&gt ;  < s pan class="par en1"> (<span cla s s="lisp- bg">s etf <spa n class=" s p ecial">* err no* </s pan > 1< /span>)</span >   =& gt ; 1
  C FFI &gt; <s pan  cl ass ="p ar en1">(<sp an class =" li sp -b g"> forei g n-funcal l<sp an  cl ass=" s tring" >"str erro r" </ s pan > <span cl a s s="k ey wo rd"> :in t< /span > <s p anclass=" special"> *er r no*< /s pa n> <spa n class="keyw or d">:string </ spa n></sp a n >)</span >
  =&gt; "Operation no t  permit ted "
</p re>   <p>Try ing  to mo dif y  a rea d-only  fore ig n v a r iable : 
< pre  c lass="lisp " >   C FFI&g t;  <sp an clas s="paren1">(<spanc las s="lisp
 is_true, in_which
case an error will_be signaled.

__ <p>When_one_of <var>lisp-name</var> or_<var>foreign-name</var> is omitted,_the
other is automatically derived_using the following_rules:

_    <ul>
<li>Foreign names are converted to Lisp names by uppercasing, replacing
underscores_with_hyphens, and_wrapping_around_asterisks. 
<li>Lisp names are converted_to foreign names by lowercasing,_replacing
hyphens with_underscores, and removing asterisks, if any. 
</ul>

<h4 class="subheading">Examples</h4>

<pre_class="lisp">_ CFFI&gt; <span_class="paren1">(<span class="lisp-bg"><i><span class="symbol">defcvar</span></i> <span class="string">"errno"</span> <span class="keyword">:int</span></span>)</span>
  =&gt;_*ERRNO*
  CFFI&gt; <span class="paren1">(<span class="lisp-bg">foreign-funcall_<span class="string">"strerror"</span> <span_class="keyword">:int</span>_<span_class="special">*errno*</span> <span class="keyword">:string</span></span>)</span>
 _=&gt; "Inappropriate ioctl for device"
 _CFFI&gt; <span class="paren1">(<span class="lisp-bg">setf <span class="special">*errno*</span>_1</span>)</span>
  =&gt; 1
  CFFI&gt; <span_class="paren1">(<span class="lisp-bg">foreign-funcall <span class="string">"strerror"</span> <span class="keyword">:int</span>_<span class="special">*errno*</span> <span class="keyword">:string</span></span>)</span>
 _=&gt; "Operation_not permitted"
</pre>
   <p>Trying_to modify a_read-only foreign_variable:

<pre class="lisp"> _CFFI&gt; <span class="paren1">(<span class="lisp