~ubuntu-branches/ubuntu/intrepid/ecl/intrepid

« back to all changes in this revision

Viewing changes to src/c/main.d

• browse files at revision 3
• compare with another revision
• download diff
• download tarball
• view history from revision 3

Show diffs side-by-side

added

removed

src/c/main.d

52

52

 

53

53

        env->c_env = NULL;

54

54

 

55

 

        env->token = cl_alloc_adjustable_string(LISP_PAGESIZE);

 

55

        env->token = cl_alloc_adjustable_base_string(LISP_PAGESIZE);

56

56

 

57

57

        env->stack = NULL;

58

58

        env->stack_top = NULL;

179

179

        Cnil->symbol.t = (short)t_symbol;

180

180

        Cnil->symbol.dynamic = 0;

181

181

        Cnil->symbol.value = Cnil;

182

 

        Cnil->symbol.name = make_constant_string("NIL");

 

182

        Cnil->symbol.name = make_constant_base_string("NIL");

183

183

        Cnil->symbol.gfdef = Cnil;

184

184

        Cnil->symbol.plist = Cnil;

185

185

        Cnil->symbol.hpack = Cnil;

191

191

        Ct->symbol.t = (short)t_symbol;

192

192

        Ct->symbol.dynamic = 0;

193

193

        Ct->symbol.value = Ct;

194

 

        Ct->symbol.name = make_constant_string("T");

 

194

        Ct->symbol.name = make_constant_base_string("T");

195

195

        Ct->symbol.gfdef = Cnil;

196

196

        Ct->symbol.plist = Cnil;

197

197

        Ct->symbol.hpack = Cnil;

204

204

        cl_core.packages_to_be_created = OBJNULL;

205

205

 

206

206

        cl_core.lisp_package =

207

 

            make_package(make_constant_string("COMMON-LISP"),

208

 

                         CONS(make_constant_string("CL"),

209

 

                              CONS(make_constant_string("LISP"),Cnil)),

 

207

            make_package(make_constant_base_string("COMMON-LISP"),

 

208

                         CONS(make_constant_base_string("CL"),

 

209

                              CONS(make_constant_base_string("LISP"),Cnil)),

210

210

                         Cnil);

211

211

        cl_core.user_package =

212

 

            make_package(make_constant_string("COMMON-LISP-USER"),

213

 

                         CONS(make_constant_string("CL-USER"),

214

 

                              CONS(make_constant_string("USER"),Cnil)),

 

212

            make_package(make_constant_base_string("COMMON-LISP-USER"),

 

213

                         CONS(make_constant_base_string("CL-USER"),

 

214

                              CONS(make_constant_base_string("USER"),Cnil)),

215

215

                         CONS(cl_core.lisp_package, Cnil));

216

 

        cl_core.keyword_package = make_package(make_constant_string("KEYWORD"),

 

216

        cl_core.keyword_package = make_package(make_constant_base_string("KEYWORD"),

217

217

                                               Cnil, Cnil);

218

 

        cl_core.system_package = make_package(make_constant_string("SI"),

219

 

                                              CONS(make_constant_string("SYSTEM"),

220

 

                                                   CONS(make_constant_string("SYS"),

221

 

                                                        CONS(make_constant_string("EXT"),

 

218

        cl_core.system_package = make_package(make_constant_base_string("SI"),

 

219

                                              CONS(make_constant_base_string("SYSTEM"),

 

220

                                                   CONS(make_constant_base_string("SYS"),

 

221

                                                        CONS(make_constant_base_string("EXT"),

222

222

                                                             Cnil))),

223

223

                                              CONS(cl_core.lisp_package, Cnil));

224

224

#ifdef CLOS

225

 

        cl_core.clos_package = make_package(make_constant_string("CLOS"),

 

225

        cl_core.clos_package = make_package(make_constant_base_string("CLOS"),

226

226

                                            Cnil, CONS(cl_core.lisp_package, Cnil));

227

227

#endif

228

228

#ifdef ECL_THREADS

229

 

        cl_core.mp_package = make_package(make_constant_string("MP"),

230

 

                                          CONS(make_constant_string("MULTIPROCESSING"), Cnil),

 

229

        cl_core.mp_package = make_package(make_constant_base_string("MP"),

 

230

                                          CONS(make_constant_base_string("MULTIPROCESSING"), Cnil),

231

231

                                          CONS(cl_core.lisp_package, Cnil));

232

232

#endif

233

233

 

258

258

                                make_shortfloat(0.5f), /* rehash-threshold */

259

259

                                Cnil); /* thread-safe */

260

260

        for (i = 0; char_names[i].code >= 0; i++) {

261

 

                cl_object name = make_constant_string(char_names[i].name);

 

261

                cl_object name = make_constant_base_string(char_names[i].name);

262

262

                cl_object code = CODE_CHAR(char_names[i].code);

263

263

                sethash(name, aux, code);

264

264

                sethash(code, aux, name);

265

265

        }

266

266

 

267

 

        cl_core.null_string = make_constant_string("");

 

267

        cl_core.null_string = make_constant_base_string("");

268

268

 

269

269

        cl_core.null_stream = @make_broadcast_stream(0);

270

270

 

274

274

                                make_shortfloat(0.75f), /* rehash-threshold */

275

275

                                Ct); /* thread-safe */

276

276

 

277

 

        cl_core.gensym_prefix = make_constant_string("G");

278

 

        cl_core.gentemp_prefix = make_constant_string("T");

 

277

        cl_core.gensym_prefix = make_constant_base_string("G");

 

278

        cl_core.gentemp_prefix = make_constant_base_string("T");

279

279

        cl_core.gentemp_counter = MAKE_FIXNUM(0);

280

280

 

281

281

        /* LIBRARIES is an adjustable vector of objects. It behaves as a vector of

331

331

                make_pathname(Cnil, Cnil, Cnil, Cnil, Cnil, Cnil));

332

332

#endif

333

333

 

334

 

        @si::pathname-translations(2,make_constant_string("SYS"),

335

 

                                   cl_list(1,cl_list(2,make_constant_string("*.*"),

336

 

                                                     make_constant_string("./*.*"))));

 

334

        @si::pathname-translations(2,make_constant_base_string("SYS"),

 

335

                                   cl_list(1,cl_list(2,make_constant_base_string("*.*"),

 

336

                                                     make_constant_base_string("./*.*"))));

337

337

 

338

338

        /*

339

339

         * 5) Set up hooks for LOAD, errors and macros.

344

344

#endif

345

345

        aux = cl_list(

346

346

#ifdef ENABLE_DLOPEN

347

 

                6,CONS(make_constant_string("fas"), @'si::load-binary'),

 

347

                6,CONS(make_constant_base_string("fas"), @'si::load-binary'),

348

348

#else

349

349

                5,

350

350

#endif

351

 

                CONS(make_constant_string("lsp"), @'si::load-source'),

352

 

                CONS(make_constant_string("lisp"), @'si::load-source'),

353

 

                CONS(make_constant_string("LSP"), @'si::load-source'),

354

 

                CONS(make_constant_string("LISP"), @'si::load-source'),

 

351

                CONS(make_constant_base_string("lsp"), @'si::load-source'),

 

352

                CONS(make_constant_base_string("lisp"), @'si::load-source'),

 

353

                CONS(make_constant_base_string("LSP"), @'si::load-source'),

 

354

                CONS(make_constant_base_string("LISP"), @'si::load-source'),

355

355

                CONS(Cnil, @'si::load-source'));

356

356

        ECL_SET(@'si::*load-hooks*', aux);

357

357

#ifdef PDE

437

437

#ifdef ECL_DYNAMIC_FFI

438

438

        ADD_FEATURE("DFFI");

439

439

#endif

 

440

#ifdef ECL_UNICODE

 

441

        ADD_FEATURE("UNICODE");

 

442

#endif

440

443

        /* This is assumed in all systems */

441

444

        ADD_FEATURE("IEEE-FLOATING-POINT");

442

445

 

481

484

 

482

485

        if (!FIXNUMP(index) || (i = fix(index)) < 0 || i >= ARGC)

483

486

                FEerror("Illegal argument index: ~S.", 1, index);

484

 

        @(return make_string_copy(ARGV[i]))

 

487

        @(return make_base_string_copy(ARGV[i]))

485

488

}

486

489

 

487

490

cl_object

489

492

{

490

493

        const char *value;

491

494

 

492

 

        assert_type_string(var);

493

 

        value = getenv(var->string.self);

494

 

        @(return ((value == NULL)? Cnil : make_string_copy(value)))

 

495

        assert_type_base_string(var);

 

496

        value = getenv(var->base_string.self);

 

497

        @(return ((value == NULL)? Cnil : make_base_string_copy(value)))

495

498

}

496

499

 

497

500

#if defined(HAVE_SETENV) || defined(HAVE_PUTENV)

500

503

{

501

504

        cl_fixnum ret_val;

502

505

 

503

 

        assert_type_string(var);

 

506

        assert_type_base_string(var);

504

507

        if (value == Cnil) {

505

508

#ifdef HAVE_SETENV

506

509

                /* Remove the variable when setting to nil, so that

507

510

                 * (si:setenv "foo" nil), then (si:getenv "foo) returns

508

511

                 * the right thing. */

509

 

                unsetenv(var->string.self);

 

512

                unsetenv(var->base_string.self);

510

513

#else

511

514

#if defined(_MSC_VER) || defined(mingw32)

512

 

                si_setenv(var, make_simple_string(""));

 

515

                si_setenv(var, make_simple_base_string(""));

513

516

#else

514

 

                putenv(var->string.self);

 

517

                putenv(var->base_string.self);

515

518

#endif

516

519

#endif

517

520

                ret_val = 0;

518

521

        } else {

519

522

#ifdef HAVE_SETENV

520

 

                assert_type_string(value);

521

 

                ret_val = setenv(var->string.self, value->string.self, 1);

 

523

                assert_type_base_string(value);

 

524

                ret_val = setenv(var->base_string.self, value->base_string.self, 1);

522

525

#else

523

526

                cl_object temp =

524

 

                  cl_format(4, Cnil, make_constant_string("~A=~A"), var,

 

527

                  cl_format(4, Cnil, make_constant_base_string("~A=~A"), var,

525

528

                            value);

526

 

                if (temp->string.hasfillp && temp->string.fillp < temp->string.dim)

527

 

                  temp->string.self[temp->string.fillp] = '\0';

528

 

                putenv(temp->string.self);

 

529

                if (temp->base_string.hasfillp && temp->base_string.fillp < temp->base_string.dim)

 

530

                  temp->base_string.self[temp->base_string.fillp] = '\0';

 

531

                putenv(temp->base_string.self);

529

532

#endif

530

533

        }

531

534

        if (ret_val == -1)

• Older »

Loggerhead is a web-based interface for Breezy
Version: 2.0.1