~ubuntu-branches/ubuntu/vivid/gcl/vivid

Next: <a href="C-Interface.html#C-Interface" accesskey="n" rel="next">C Interface</a>, Previous: <a href="Type.html#Type" accesskey="p" rel="prev">Type</a>, Up: <a href="index.html#Top" accesskey="u" rel="up">Top</a>   [<a href="Function-and-Variable-Index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Function-and-Variable-Index.html#Function-and-Variable-Index" title="Index" rel="index">Index</a>]

</div>

<hr>

<h2 class="chapter">15 GCL Specific</h2>

<dl>

<dt><a name="index-SYSTEM"></a>Function: SYSTEM (string)</dt>

<dd>Package:LISP

GCL specific: Executes a Shell command as if STRING is an input to the

Shell. Not all versions of GCL support this function. At least on

POSIX systems, this call should return two integers represeting the

exit status and any possible terminating signal respectively.

</dd></dl>

<dl>

<dt><a name="index-_002aTMP_002dDIR_002a"></a>Variable: *TMP-DIR*</dt>

<dd>Package:COMPILER

GCL specific: Directory in which temporary “gazonk” files used by the

compiler are to be created.

</dd></dl>

<dl>

<dt><a name="index-_002aIGNORE_002dMAXIMUM_002dPAGES_002a"></a>Variable: *IGNORE-MAXIMUM-PAGES*</dt>

<dd>Package:SI

GCL specific: Tells the GCL memory manager whether (non-NIL) or not (NIL) it

should expand memory whenever the maximum allocatable pages have been used

up.

</dd></dl>

<dl>

<dt><a name="index-_002aOPTIMIZE_002dMAXIMUM_002dPAGES_002a"></a>Variable: *OPTIMIZE-MAXIMUM-PAGES*</dt>

<dd>Package:SI

GCL specific: Tells the GCL memory manager whether to attempt to

adjust the maximum allowable pages for each type to approximately

optimize the garbage collection load in the current process. Defaults

to T. Set to NIL if you care more about memory usage than runtime.

100

101

102

</dd></dl>

103

104

<dl>

105

<dt><a name="index-MACHINE_002dVERSION"></a>Function: MACHINE-VERSION ()</dt>

106

<dd>Package:LISP

107

108

Returns a string that identifies the machine version of the machine

109

on which GCL is currently running.

110

111

112

</dd></dl>

113

114

<dl>

115

<dt><a name="index-BY"></a>Function: BY ()</dt>

116

<dd>Package:LISP

117

118

GCL specific: Exits from GCL.

119

120

121

</dd></dl>

122

123

<dl>

124

<dt><a name="index-DEFCFUN"></a>Macro: DEFCFUN</dt>

125

<dd>Package:LISP

126

127

Syntax:

128

129

<pre class="example">(defcfun header n {element}*)

130

</pre></div>

131

132

133

GCL specific: Defines a C-language function which calls Lisp functions

134

and/or handles Lisp objects. HEADER gives the header of the C

135

function as a string. Non-negative-integer is the number of the main

136

stack entries used by the C function, primarily for protecting Lisp

137

objects from being garbage-collected. Each ELEMENT may give a C code

138

fragment as a string, or it may be a list

139

((symbol {arg}*) {place}*)

140

which, when executed, calls the Lisp function named by SYMBOL with the

141

specified arguments and saves the value(s) to the specified places.

142

The DEFCFUN form has the above meanings only after compiled; The GCL

143

interpreter simply ignores this form.

144

145

An example which defines a C function list2 of two arguments, but which

146

calls the ’lisp’ function CONS by name, and refers to the constant ’NIL.

147

Note to be loaded by <code>load</code> the function should be static.

148

149

150

(defCfun "static object list2(x,y) object x,y;" 0

151

"object z;"

152

(’NIL z)

153

((CONS y z) z)

154

((CONS x z) z)

155

"return(z);"

156

)

157

158

In lisp the operations in the body would be

159

(setq z ’nil)

160

(setq z (cons y z))

161

(setq z (cons x z))

162

163

164

165

Syntax:

166

167

168

(defCfun header non-negative-integer

169

{ string

170

| ( function-symbol { value }* )

171

| (( function-symbol { value }* ) { place }* ) })

172

173

174

value:

175

place:

176

{ C-expr | ( C-type C-expr ) }

177

178

C-function-name:

179

C-expr:

180

{ string | symbol }

181

182

C-type:

183

{ object | int | char | float | double }

184

185

</pre></div>

186

187

188

189

190

</dd></dl>

191

192

<dl>

193

<dt><a name="index-CLINES"></a>Macro: CLINES</dt>

194

<dd>Package:LISP

195

196

Syntax:

197

198

<pre class="example">(clines {string}*)

199

</pre></div>

200

201

GCL specific: The GCL compiler embeds STRINGs into the intermediate C

202

language code. The interpreter ignores this form.

203

204

205

</dd></dl>

206

207

<dl>

208

<dt><a name="index-ALLOCATE"></a>Function: ALLOCATE (type number &optional (really-allocate nil))</dt>

209

<dd>Package:LISP

210

211

GCL specific: Sets the maximum number of pages for the type class of the

212

GCL implementation type TYPE to NUMBER. If REALLY-ALLOCATE is given a

213

non-NIL value, then the specified number of pages will be allocated

214

immediately.

215

216

217

</dd></dl>

218

219

<dl>

220

<dt><a name="index-GBC"></a>Function: GBC (x)</dt>

221

<dd>Package:LISP

222

223

GCL specific: Invokes the garbage collector (GC) with the collection level

224

specified by X. NIL as the argument causes GC to collect cells only. T as

225

the argument causes GC to collect everything.

226

227

228

</dd></dl>

229

230

<dl>

231

<dt><a name="index-SAVE"></a>Function: SAVE (pathname)</dt>

232

<dd>Package:LISP

233

234

GCL specific: Saves the current GCL core image into a program file specified

235

by PATHNAME. This function depends on the version of GCL. The function

236

si::save-system is to be preferred in almost all circumstances. Unlike

237

save, it makes the relocatable section permanent, and causes no future gc of

238

currently loaded .o files.

239

240

</dd></dl>

241

242

<dl>

243

<dt><a name="index-HELP_002a"></a>Function: HELP* (string &optional (package 'lisp))</dt>

244

<dd>Package:LISP

245

246

GCL specific: Prints the documentation associated with those symbols in the

247

specified package whose print names contain STRING as substring. STRING may

248

be a symbol, in which case the print-name of that symbol is used. If PACKAGE

249

is NIL, then all packages are searched.

250

251

252

</dd></dl>

253

254

<dl>

255

<dt><a name="index-DEFLA"></a>Macro: DEFLA</dt>

256

<dd>Package:LISP

257

258

Syntax:

259

260

<pre class="example">(defla name lambda-list {decl | doc}* {form}*)

261

</pre></div>

262

263

GCL specific: Used to DEFine Lisp Alternative. For the interpreter, DEFLA is

264

equivalent to DEFUN, but the compiler ignores this form.

265

266

267

</dd></dl>

268

269

<dl>

270

<dt><a name="index-PROCLAMATION"></a>Function: PROCLAMATION (decl-spec)</dt>

271

<dd>Package:LISP

272

273

GCL specific: Returns T if the specified declaration is globally in effect;

274

NIL otherwise. See the doc of DECLARE for possible DECL-SPECs.

275

276

277

</dd></dl>

278

279

<dl>

280

<dt><a name="index-DEFENTRY"></a>Macro: DEFENTRY</dt>

281

<dd>Package:LISP

282

283

Syntax:

284

285

<pre class="example">(defentry name arg-types c-function)

286

</pre></div>

287

288

289

GCL specific: The compiler defines a Lisp function whose body consists of a

290

calling sequence to the C language function specified by C-FUNCTION. The

291

interpreter ignores this form. The ARG-TYPES specifies the C types of the

292

arguments which C-FUNCTION requires. The list of allowed types is (object

293

char int float double string). Code will be produced to coerce from a lisp

294

object to the appropriate type before passing the argument to the C-FUNCTION.

295

The c-function should be of the form (c-result-type c-fname) where

296

c-result-type is a member of (void object char int float double string).

297

c-fname may be a symbol (in which case it will be downcased) or a string. If

298

c-function is not a list, then (object c-function) is assumed. In order

299

for C code to be loaded in by <code>load</code> you should declare any

300

variables and functions to be static. If you will link them in

301

at build time, of course you are allowed to define new externals.

302

303

304

<pre class="example"> Sample usage:

305

--File begin-----

306

;; JOE takes X a lisp string and Y a fixnum and returns a character.

307

(clines "#include \"foo.ch\"")

308

(defentry joe (string int) (char "our_c_fun"))

309

---File end------

310

---File foo.ch---

311

/* C function for extracting the i'th element of a string */

312

static char our_c_fun(p,i)

313

char *p;

314

int i;

315

{

316

return p[i];

317

}

318

-----File end---

319

</pre></div>

320

321

One must be careful of storage allocation issues when passing a string.

322

If the C code invokes storage allocation (either by calling <code>malloc</code>

323

or <code>make_cons</code> etc), then there is a possibility of a garbage

324

collection, so that if the string passed was not constructed with

325

<code>:static t</code> when its array was constructed, then it could move.

326

If the C function may allocate storage, then you should pass a copy:

327

328

<pre class="example">(defun safe-c-string (x)

329

(let* ((n (length x))

330

(a (make-array (+ n 1) :element-type 'string-char

331

:static t :fill-pointer n)))

332

(si::copy-array-portion x y 0 0 n)

333

(setf (aref a n) (code-char 0)))

334

335

336

</pre></div>

337

338

339

</dd></dl>

340

<dl>

341

<dt><a name="index-COPY_002dARRAY_002dPORTION"></a>Function: COPY-ARRAY-PORTION (x,y,i1,i2,n1)</dt>

342

<dd>Package:SI

343

Copy elements from X to Y starting at X[i1] to Y[i2] and doing N1

344

elements if N1 is supplied otherwise, doing the length of X - I1

345

elements. If the types of the arrays are not the same, this has

346

implementation dependent results.

347

</dd></dl>

348

349

<dl>

350

<dt><a name="index-BYE"></a>Function: BYE ( &optional (exit-status 0))</dt>

351

<dd>Package:LISP

352

353

GCL specific: Exits from GCL with exit-status.

354

355

356

</dd></dl>

357

358

<dl>

359

<dt><a name="index-USE_002dFAST_002dLINKS"></a>Function: USE-FAST-LINKS (turn-on)</dt>

360

<dd>Package:LISP

361

362

GCL specific: If TURN-ON is not nil, the fast link mechanism is enabled,

363

so that ordinary function calls will not appear in the invocation stack,

364

and calls will be much faster. This is the default. If you anticipate

365

needing to see a stack trace in the debugger, then you should turn this

366

off.

367

368

369

</dd></dl>

370

371

372

<tr><td align="left" valign="top">• <a href="Bignums.html#Bignums" accesskey="1">Bignums</a>:</td><td>  </td><td align="left" valign="top">

373

</td></tr>

374

</table>

375

376

<hr>

377

378

379

380

</div>

381

382

383

384

</body>

385

</html>

Older »