xref: /titanic_52/usr/src/common/ficl/loader.c (revision e09118e474abe7cd4a2d6d9c34c01e4be81ad76e) 
1 /*
2  * Copyright (c) 2000 Daniel Capo Sobral
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24  * SUCH DAMAGE.
25  *
26  *	$FreeBSD$
27  */
28 
29 /*
30  * l o a d e r . c
31  * Additional FICL words designed for FreeBSD's loader
32  */
33 
34 #ifndef _STANDALONE
35 #include <sys/types.h>
36 #include <sys/stat.h>
37 #include <dirent.h>
38 #include <fcntl.h>
39 #include <stdio.h>
40 #include <stdlib.h>
41 #include <unistd.h>
42 #include <strings.h>
43 #include <termios.h>
44 #else
45 #include <stand.h>
46 #ifdef __i386__
47 #include <machine/cpufunc.h>
48 #endif
49 #include "bootstrap.h"
50 #endif
51 #ifdef _STANDALONE
52 #include <uuid.h>
53 #else
54 #include <uuid/uuid.h>
55 #endif
56 #include <string.h>
57 #include "ficl.h"
58 
59 /*
60  *		FreeBSD's loader interaction words and extras
61  *
62  *		setenv      ( value n name n' -- )
63  *		setenv?     ( value n name n' flag -- )
64  *		getenv      ( addr n -- addr' n' | -1 )
65  *		unsetenv    ( addr n -- )
66  *		copyin      ( addr addr' len -- )
67  *		copyout     ( addr addr' len -- )
68  *		findfile    ( name len type len' -- addr )
69  *		ccall       ( [[...[p10] p9] ... p1] n addr -- result )
70  *		uuid-from-string ( addr n -- addr' )
71  *		uuid-to-string ( addr' -- addr n | -1 )
72  *		.#	    ( value -- )
73  */
74 
75 void
76 ficlSetenv(ficlVm *pVM)
77 {
78 	char *name, *value;
79 	char *namep, *valuep;
80 	int names, values;
81 
82 	FICL_STACK_CHECK(ficlVmGetDataStack(pVM), 4, 0);
83 
84 	names = ficlStackPopInteger(ficlVmGetDataStack(pVM));
85 	namep = (char *)ficlStackPopPointer(ficlVmGetDataStack(pVM));
86 	values = ficlStackPopInteger(ficlVmGetDataStack(pVM));
87 	valuep = (char *)ficlStackPopPointer(ficlVmGetDataStack(pVM));
88 
89 	name = (char *)ficlMalloc(names+1);
90 	if (!name)
91 		ficlVmThrowError(pVM, "Error: out of memory");
92 	strncpy(name, namep, names);
93 	name[names] = '\0';
94 	value = (char *)ficlMalloc(values+1);
95 	if (!value)
96 		ficlVmThrowError(pVM, "Error: out of memory");
97 	strncpy(value, valuep, values);
98 	value[values] = '\0';
99 
100 	setenv(name, value, 1);
101 	ficlFree(name);
102 	ficlFree(value);
103 }
104 
105 void
106 ficlSetenvq(ficlVm *pVM)
107 {
108 	char *name, *value;
109 	char *namep, *valuep;
110 	int names, values, overwrite;
111 
112 	FICL_STACK_CHECK(ficlVmGetDataStack(pVM), 5, 0);
113 
114 	overwrite = ficlStackPopInteger(ficlVmGetDataStack(pVM));
115 	names = ficlStackPopInteger(ficlVmGetDataStack(pVM));
116 	namep = (char *)ficlStackPopPointer(ficlVmGetDataStack(pVM));
117 	values = ficlStackPopInteger(ficlVmGetDataStack(pVM));
118 	valuep = (char *)ficlStackPopPointer(ficlVmGetDataStack(pVM));
119 
120 	name = (char *)ficlMalloc(names+1);
121 	if (!name)
122 		ficlVmThrowError(pVM, "Error: out of memory");
123 	strncpy(name, namep, names);
124 	name[names] = '\0';
125 	value = (char *)ficlMalloc(values+1);
126 	if (!value)
127 		ficlVmThrowError(pVM, "Error: out of memory");
128 	strncpy(value, valuep, values);
129 	value[values] = '\0';
130 
131 	setenv(name, value, overwrite);
132 	ficlFree(name);
133 	ficlFree(value);
134 }
135 
136 void
137 ficlGetenv(ficlVm *pVM)
138 {
139 	char *name, *value;
140 	char *namep;
141 	int names;
142 
143 	FICL_STACK_CHECK(ficlVmGetDataStack(pVM), 2, 2);
144 
145 	names = ficlStackPopInteger(ficlVmGetDataStack(pVM));
146 	namep = (char *)ficlStackPopPointer(ficlVmGetDataStack(pVM));
147 
148 	name = (char *)ficlMalloc(names+1);
149 	if (!name)
150 		ficlVmThrowError(pVM, "Error: out of memory");
151 	strncpy(name, namep, names);
152 	name[names] = '\0';
153 
154 	value = getenv(name);
155 	ficlFree(name);
156 
157 	if (value != NULL) {
158 		ficlStackPushPointer(ficlVmGetDataStack(pVM), value);
159 		ficlStackPushInteger(ficlVmGetDataStack(pVM), strlen(value));
160 	} else
161 		ficlStackPushInteger(ficlVmGetDataStack(pVM), -1);
162 }
163 
164 void
165 ficlUnsetenv(ficlVm *pVM)
166 {
167 	char *name;
168 	char *namep;
169 	int names;
170 
171 	FICL_STACK_CHECK(ficlVmGetDataStack(pVM), 2, 0);
172 
173 	names = ficlStackPopInteger(ficlVmGetDataStack(pVM));
174 	namep = (char *)ficlStackPopPointer(ficlVmGetDataStack(pVM));
175 
176 	name = (char *)ficlMalloc(names+1);
177 	if (!name)
178 		ficlVmThrowError(pVM, "Error: out of memory");
179 	strncpy(name, namep, names);
180 	name[names] = '\0';
181 
182 	unsetenv(name);
183 	ficlFree(name);
184 }
185 
186 void
187 ficlCopyin(ficlVm *pVM)
188 {
189 #ifdef _STANDALONE
190 	void*		src;
191 	vm_offset_t	dest;
192 	size_t		len;
193 #endif
194 
195 	FICL_STACK_CHECK(ficlVmGetDataStack(pVM), 3, 0);
196 
197 #ifdef _STANDALONE
198 	len = ficlStackPopInteger(ficlVmGetDataStack(pVM));
199 	dest = ficlStackPopInteger(ficlVmGetDataStack(pVM));
200 	src = ficlStackPopPointer(ficlVmGetDataStack(pVM));
201 	archsw.arch_copyin(src, dest, len);
202 #else
203 	(void) ficlStackPopInteger(ficlVmGetDataStack(pVM));
204 	(void) ficlStackPopInteger(ficlVmGetDataStack(pVM));
205 	(void) ficlStackPopPointer(ficlVmGetDataStack(pVM));
206 #endif
207 }
208 
209 void
210 ficlCopyout(ficlVm *pVM)
211 {
212 #ifdef _STANDALONE
213 	void*		dest;
214 	vm_offset_t	src;
215 	size_t		len;
216 #endif
217 
218 	FICL_STACK_CHECK(ficlVmGetDataStack(pVM), 3, 0);
219 
220 #ifdef _STANDALONE
221 	len = ficlStackPopInteger(ficlVmGetDataStack(pVM));
222 	dest = ficlStackPopPointer(ficlVmGetDataStack(pVM));
223 	src = ficlStackPopInteger(ficlVmGetDataStack(pVM));
224 	archsw.arch_copyout(src, dest, len);
225 #else
226 	(void) ficlStackPopInteger(ficlVmGetDataStack(pVM));
227 	(void) ficlStackPopPointer(ficlVmGetDataStack(pVM));
228 	(void) ficlStackPopInteger(ficlVmGetDataStack(pVM));
229 #endif
230 }
231 
232 void
233 ficlFindfile(ficlVm *pVM)
234 {
235 #ifdef _STANDALONE
236 	char	*name, *type;
237 	char	*namep, *typep;
238 	int	names, types;
239 #endif
240 	struct	preloaded_file *fp;
241 
242 	FICL_STACK_CHECK(ficlVmGetDataStack(pVM), 4, 1);
243 
244 #ifdef _STANDALONE
245 	types = ficlStackPopInteger(ficlVmGetDataStack(pVM));
246 	typep = (char *)ficlStackPopPointer(ficlVmGetDataStack(pVM));
247 	names = ficlStackPopInteger(ficlVmGetDataStack(pVM));
248 	namep = (char *)ficlStackPopPointer(ficlVmGetDataStack(pVM));
249 
250 	name = (char *)ficlMalloc(names+1);
251 	if (!name)
252 		ficlVmThrowError(pVM, "Error: out of memory");
253 	strncpy(name, namep, names);
254 	name[names] = '\0';
255 	type = (char *)ficlMalloc(types+1);
256 	if (!type)
257 		ficlVmThrowError(pVM, "Error: out of memory");
258 	strncpy(type, typep, types);
259 	type[types] = '\0';
260 
261 	fp = file_findfile(name, type);
262 #else
263 	(void) ficlStackPopInteger(ficlVmGetDataStack(pVM));
264 	(void) ficlStackPopPointer(ficlVmGetDataStack(pVM));
265 	(void) ficlStackPopInteger(ficlVmGetDataStack(pVM));
266 	(void) ficlStackPopPointer(ficlVmGetDataStack(pVM));
267 
268 	fp = NULL;
269 #endif
270 	ficlStackPushPointer(ficlVmGetDataStack(pVM), fp);
271 }
272 
273 void
274 ficlCcall(ficlVm *pVM)
275 {
276 	int (*func)(int, ...);
277 	int result, p[10];
278 	int nparam, i;
279 
280 	FICL_STACK_CHECK(ficlVmGetDataStack(pVM), 2, 0);
281 
282 	func = (int (*)(int, ...))ficlStackPopPointer(ficlVmGetDataStack(pVM));
283 	nparam = ficlStackPopInteger(ficlVmGetDataStack(pVM));
284 
285 	FICL_STACK_CHECK(ficlVmGetDataStack(pVM), nparam, 1);
286 
287 	for (i = 0; i < nparam; i++)
288 		p[i] = ficlStackPopInteger(ficlVmGetDataStack(pVM));
289 
290 	result = func(p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7], p[8],
291 	    p[9]);
292 
293 	ficlStackPushInteger(ficlVmGetDataStack(pVM), result);
294 }
295 
296 void
297 ficlUuidFromString(ficlVm *pVM)
298 {
299 	char	*uuid;
300 	char	*uuid_ptr;
301 	int	uuid_size;
302 	uuid_t	*u;
303 #ifdef _STANDALONE
304 	uint32_t status;
305 #else
306 	int status;
307 #endif
308 
309 	FICL_STACK_CHECK(ficlVmGetDataStack(pVM), 2, 0);
310 
311 	uuid_size = ficlStackPopInteger(ficlVmGetDataStack(pVM));
312 	uuid_ptr = ficlStackPopPointer(ficlVmGetDataStack(pVM));
313 
314 	uuid = ficlMalloc(uuid_size + 1);
315 	if (!uuid)
316 		ficlVmThrowError(pVM, "Error: out of memory");
317 	(void) memcpy(uuid, uuid_ptr, uuid_size);
318 	uuid[uuid_size] = '\0';
319 
320 	u = ficlMalloc(sizeof (*u));
321 #ifdef _STANDALONE
322 	uuid_from_string(uuid, u, &status);
323 	ficlFree(uuid);
324 	if (status != uuid_s_ok) {
325 		ficlFree(u);
326 		u = NULL;
327 	}
328 #else
329 	status = uuid_parse(uuid, *u);
330 	ficlFree(uuid);
331 	if (status != 0) {
332 		ficlFree(u);
333 		u = NULL;
334 	}
335 #endif
336 	ficlStackPushPointer(ficlVmGetDataStack(pVM), u);
337 }
338 
339 void
340 ficlUuidToString(ficlVm *pVM)
341 {
342 	char	*uuid;
343 	uuid_t	*u;
344 #ifdef _STANDALONE
345 	uint32_t status;
346 #endif
347 
348 	FICL_STACK_CHECK(ficlVmGetDataStack(pVM), 1, 0);
349 
350 	u = ficlStackPopPointer(ficlVmGetDataStack(pVM));
351 #ifdef _STANDALONE
352 	uuid_to_string(u, &uuid, &status);
353 	if (status == uuid_s_ok) {
354 		ficlStackPushPointer(ficlVmGetDataStack(pVM), uuid);
355 		ficlStackPushInteger(ficlVmGetDataStack(pVM), strlen(uuid));
356 	} else
357 #else
358 	uuid = ficlMalloc(UUID_PRINTABLE_STRING_LENGTH);
359 	if (uuid != NULL) {
360 		uuid_unparse(*u, uuid);
361 		ficlStackPushPointer(ficlVmGetDataStack(pVM), uuid);
362 		ficlStackPushInteger(ficlVmGetDataStack(pVM), strlen(uuid));
363 	} else
364 #endif
365 		ficlStackPushInteger(ficlVmGetDataStack(pVM), -1);
366 }
367 
368 /*
369  * f i c l E x e c F D
370  * reads in text from file fd and passes it to ficlExec()
371  * returns FICL_VM_STATUS_OUT_OF_TEXT on success or the ficlExec() error
372  * code on failure.
373  */
374 #define	nLINEBUF	256
375 int
376 ficlExecFD(ficlVm *pVM, int fd)
377 {
378 	char cp[nLINEBUF];
379 	int nLine = 0, rval = FICL_VM_STATUS_OUT_OF_TEXT;
380 	char ch;
381 	ficlCell id;
382 	ficlString s;
383 
384 	id = pVM->sourceId;
385 	pVM->sourceId.i = fd+1; /* in loader we can get 0, there is no stdin */
386 
387 	/* feed each line to ficlExec */
388 	while (1) {
389 		int status, i;
390 
391 		i = 0;
392 		while ((status = read(fd, &ch, 1)) > 0 && ch != '\n')
393 			cp[i++] = ch;
394 		nLine++;
395 		if (!i) {
396 			if (status < 1)
397 				break;
398 			continue;
399 		}
400 		if (cp[i] == '\n')
401 			cp[i] = '\0';
402 
403 		FICL_STRING_SET_POINTER(s, cp);
404 		FICL_STRING_SET_LENGTH(s, i);
405 
406 		rval = ficlVmExecuteString(pVM, s);
407 		if (rval != FICL_VM_STATUS_QUIT &&
408 		    rval != FICL_VM_STATUS_USER_EXIT &&
409 		    rval != FICL_VM_STATUS_OUT_OF_TEXT) {
410 			pVM->sourceId = id;
411 			(void) ficlVmEvaluate(pVM, "");
412 			return (rval);
413 		}
414 	}
415 	pVM->sourceId = id;
416 
417 	/*
418 	 * Pass an empty line with SOURCE-ID == -1 to flush
419 	 * any pending REFILLs (as required by FILE wordset)
420 	 */
421 	(void) ficlVmEvaluate(pVM, "");
422 
423 	if (rval == FICL_VM_STATUS_USER_EXIT)
424 		ficlVmThrow(pVM, FICL_VM_STATUS_USER_EXIT);
425 
426 	return (rval);
427 }
428 
429 static void displayCellNoPad(ficlVm *pVM)
430 {
431 	ficlCell c;
432 	FICL_STACK_CHECK(ficlVmGetDataStack(pVM), 1, 0);
433 
434 	c = ficlStackPop(ficlVmGetDataStack(pVM));
435 	ficlLtoa((c).i, pVM->pad, pVM->base);
436 	ficlVmTextOut(pVM, pVM->pad);
437 }
438 
439 /*
440  * isdir? - Return whether an fd corresponds to a directory.
441  *
442  * isdir? ( fd -- bool )
443  */
444 static void
445 isdirQuestion(ficlVm *pVM)
446 {
447 	struct stat sb;
448 	ficlInteger flag;
449 	int fd;
450 
451 	FICL_STACK_CHECK(ficlVmGetDataStack(pVM), 1, 1);
452 
453 	fd = ficlStackPopInteger(ficlVmGetDataStack(pVM));
454 	flag = FICL_FALSE;
455 	do {
456 		if (fd < 0)
457 			break;
458 		if (fstat(fd, &sb) < 0)
459 			break;
460 		if (!S_ISDIR(sb.st_mode))
461 			break;
462 		flag = FICL_TRUE;
463 	} while (0);
464 	ficlStackPushInteger(ficlVmGetDataStack(pVM), flag);
465 }
466 
467 /*
468  * fopen - open a file and return new fd on stack.
469  *
470  * fopen ( ptr count mode -- fd )
471  */
472 extern char *get_dev(const char *);
473 
474 static void
475 pfopen(ficlVm *pVM)
476 {
477 	int mode, fd, count;
478 	char *ptr, *name;
479 #ifndef _STANDALONE
480 	char *tmp;
481 #endif
482 
483 	FICL_STACK_CHECK(ficlVmGetDataStack(pVM), 3, 1);
484 
485 	mode = ficlStackPopInteger(ficlVmGetDataStack(pVM));	/* get mode */
486 	count = ficlStackPopInteger(ficlVmGetDataStack(pVM));	/* get count */
487 	ptr = ficlStackPopPointer(ficlVmGetDataStack(pVM));	/* get ptr */
488 
489 	if ((count < 0) || (ptr == NULL)) {
490 		ficlStackPushInteger(ficlVmGetDataStack(pVM), -1);
491 		return;
492 	}
493 
494 	/* ensure that the string is null terminated */
495 	name = (char *)malloc(count+1);
496 	bcopy(ptr, name, count);
497 	name[count] = 0;
498 #ifndef _STANDALONE
499 	tmp = get_dev(name);
500 	free(name);
501 	name = tmp;
502 #endif
503 
504 	/* open the file */
505 	fd = open(name, mode);
506 	free(name);
507 	ficlStackPushInteger(ficlVmGetDataStack(pVM), fd);
508 }
509 
510 /*
511  * fclose - close a file who's fd is on stack.
512  * fclose ( fd -- )
513  */
514 static void
515 pfclose(ficlVm *pVM)
516 {
517 	int fd;
518 
519 	FICL_STACK_CHECK(ficlVmGetDataStack(pVM), 1, 0);
520 
521 	fd = ficlStackPopInteger(ficlVmGetDataStack(pVM)); /* get fd */
522 	if (fd != -1)
523 		close(fd);
524 }
525 
526 /*
527  * fread - read file contents
528  * fread  ( fd buf nbytes  -- nread )
529  */
530 static void
531 pfread(ficlVm *pVM)
532 {
533 	int fd, len;
534 	char *buf;
535 
536 	FICL_STACK_CHECK(ficlVmGetDataStack(pVM), 3, 1);
537 
538 	len = ficlStackPopInteger(ficlVmGetDataStack(pVM));
539 	buf = ficlStackPopPointer(ficlVmGetDataStack(pVM)); /* get buffer */
540 	fd = ficlStackPopInteger(ficlVmGetDataStack(pVM)); /* get fd */
541 	if (len > 0 && buf && fd != -1)
542 		ficlStackPushInteger(ficlVmGetDataStack(pVM),
543 		    read(fd, buf, len));
544 	else
545 		ficlStackPushInteger(ficlVmGetDataStack(pVM), -1);
546 }
547 
548 /*
549  * fopendir - open directory
550  *
551  * fopendir ( addr len -- ptr TRUE | FALSE )
552  */
553 static void pfopendir(ficlVm *pVM)
554 {
555 #ifndef _STANDALONE
556 	DIR *dir;
557 	char *tmp;
558 #else
559 	struct stat sb;
560 	int fd;
561 #endif
562 	int count;
563 	char *ptr, *name;
564 	ficlInteger flag = FICL_FALSE;
565 
566 	FICL_STACK_CHECK(ficlVmGetDataStack(pVM), 2, 1);
567 
568 	count = ficlStackPopInteger(ficlVmGetDataStack(pVM));
569 	ptr = ficlStackPopPointer(ficlVmGetDataStack(pVM));	/* get ptr */
570 
571 	if ((count < 0) || (ptr == NULL)) {
572 		ficlStackPushInteger(ficlVmGetDataStack(pVM), -1);
573 		return;
574 	}
575 	/* ensure that the string is null terminated */
576 	name = (char *)malloc(count+1);
577 	bcopy(ptr, name, count);
578 	name[count] = 0;
579 #ifndef _STANDALONE
580 	tmp = get_dev(name);
581 	free(name);
582 	name = tmp;
583 #else
584 	fd = open(name, O_RDONLY);
585 	free(name);
586 	do {
587 		if (fd < 0)
588 			break;
589 		if (fstat(fd, &sb) < 0)
590 			break;
591 		if (!S_ISDIR(sb.st_mode))
592 			break;
593 		flag = FICL_TRUE;
594 		ficlStackPushInteger(ficlVmGetDataStack(pVM), fd);
595 		ficlStackPushInteger(ficlVmGetDataStack(pVM), flag);
596 		return;
597 	} while (0);
598 
599 	if (fd >= 0)
600 		close(fd);
601 
602 	ficlStackPushInteger(ficlVmGetDataStack(pVM), flag);
603 		return;
604 #endif
605 #ifndef _STANDALONE
606 	dir = opendir(name);
607 	if (dir == NULL) {
608 		ficlStackPushInteger(ficlVmGetDataStack(pVM), flag);
609 		return;
610 	} else
611 		flag = FICL_TRUE;
612 
613 	ficlStackPushPointer(ficlVmGetDataStack(pVM), dir);
614 	ficlStackPushInteger(ficlVmGetDataStack(pVM), flag);
615 #endif
616 }
617 
618 /*
619  * freaddir - read directory contents
620  * freaddir ( fd -- ptr len TRUE | FALSE )
621  */
622 static void
623 pfreaddir(ficlVm *pVM)
624 {
625 #ifndef _STANDALONE
626 	static DIR *dir = NULL;
627 #else
628 	int fd;
629 #endif
630 	struct dirent *d = NULL;
631 
632 	FICL_STACK_CHECK(ficlVmGetDataStack(pVM), 1, 3);
633 	/*
634 	 * libstand readdir does not always return . nor .. so filter
635 	 * them out to have consistent behaviour.
636 	 */
637 #ifndef _STANDALONE
638 	dir = ficlStackPopPointer(ficlVmGetDataStack(pVM));
639 	if (dir != NULL)
640 		do {
641 			d = readdir(dir);
642 			if (d != NULL && strcmp(d->d_name, ".") == 0)
643 				continue;
644 			if (d != NULL && strcmp(d->d_name, "..") == 0)
645 				continue;
646 			break;
647 		} while (d != NULL);
648 #else
649 	fd = ficlStackPopInteger(ficlVmGetDataStack(pVM));
650 	if (fd != -1)
651 		do {
652 			d = readdirfd(fd);
653 			if (d != NULL && strcmp(d->d_name, ".") == 0)
654 				continue;
655 			if (d != NULL && strcmp(d->d_name, "..") == 0)
656 				continue;
657 			break;
658 		} while (d != NULL);
659 #endif
660 	if (d != NULL) {
661 		ficlStackPushPointer(ficlVmGetDataStack(pVM), d->d_name);
662 		ficlStackPushInteger(ficlVmGetDataStack(pVM),
663 		    strlen(d->d_name));
664 		ficlStackPushInteger(ficlVmGetDataStack(pVM), FICL_TRUE);
665 	} else {
666 		ficlStackPushInteger(ficlVmGetDataStack(pVM), FICL_FALSE);
667 	}
668 }
669 
670 /*
671  * fclosedir - close a dir on stack.
672  *
673  * fclosedir ( fd -- )
674  */
675 static void
676 pfclosedir(ficlVm *pVM)
677 {
678 #ifndef _STANDALONE
679 	DIR *dir;
680 #else
681 	int fd;
682 #endif
683 
684 	FICL_STACK_CHECK(ficlVmGetDataStack(pVM), 1, 0);
685 
686 #ifndef _STANDALONE
687 	dir = ficlStackPopPointer(ficlVmGetDataStack(pVM)); /* get dir */
688 	if (dir != NULL)
689 		closedir(dir);
690 #else
691 	fd = ficlStackPopInteger(ficlVmGetDataStack(pVM)); /* get fd */
692 	if (fd != -1)
693 		close(fd);
694 #endif
695 }
696 
697 /*
698  * fload - interpret file contents
699  *
700  * fload  ( fd -- )
701  */
702 static void pfload(ficlVm *pVM)
703 {
704 	int fd;
705 
706 	FICL_STACK_CHECK(ficlVmGetDataStack(pVM), 1, 0);
707 
708 	fd = ficlStackPopInteger(ficlVmGetDataStack(pVM)); /* get fd */
709 	if (fd != -1)
710 		ficlExecFD(pVM, fd);
711 }
712 
713 /*
714  * fwrite - write file contents
715  *
716  * fwrite  ( fd buf nbytes  -- nwritten )
717  */
718 static void
719 pfwrite(ficlVm *pVM)
720 {
721 	int fd, len;
722 	char *buf;
723 
724 	FICL_STACK_CHECK(ficlVmGetDataStack(pVM), 3, 1);
725 
726 	len = ficlStackPopInteger(ficlVmGetDataStack(pVM)); /* bytes to read */
727 	buf = ficlStackPopPointer(ficlVmGetDataStack(pVM)); /* get buffer */
728 	fd = ficlStackPopInteger(ficlVmGetDataStack(pVM)); /* get fd */
729 	if (len > 0 && buf && fd != -1)
730 		ficlStackPushInteger(ficlVmGetDataStack(pVM),
731 		    write(fd, buf, len));
732 	else
733 		ficlStackPushInteger(ficlVmGetDataStack(pVM), -1);
734 }
735 
736 /*
737  * fseek - seek to a new position in a file
738  *
739  * fseek  ( fd ofs whence  -- pos )
740  */
741 static void
742 pfseek(ficlVm *pVM)
743 {
744 	int fd, pos, whence;
745 
746 	FICL_STACK_CHECK(ficlVmGetDataStack(pVM), 3, 1);
747 
748 	whence = ficlStackPopInteger(ficlVmGetDataStack(pVM));
749 	pos = ficlStackPopInteger(ficlVmGetDataStack(pVM));
750 	fd = ficlStackPopInteger(ficlVmGetDataStack(pVM));
751 	ficlStackPushInteger(ficlVmGetDataStack(pVM), lseek(fd, pos, whence));
752 }
753 
754 /*
755  * key - get a character from stdin
756  *
757  * key ( -- char )
758  */
759 static void
760 key(ficlVm *pVM)
761 {
762 	FICL_STACK_CHECK(ficlVmGetDataStack(pVM), 0, 1);
763 
764 	ficlStackPushInteger(ficlVmGetDataStack(pVM), getchar());
765 }
766 
767 /*
768  * key? - check for a character from stdin (FACILITY)
769  * key? ( -- flag )
770  */
771 static void
772 keyQuestion(ficlVm *pVM)
773 {
774 #ifndef _STANDALONE
775 	char ch = -1;
776 	struct termios oldt;
777 	struct termios newt;
778 #endif
779 
780 	FICL_STACK_CHECK(ficlVmGetDataStack(pVM), 0, 1);
781 
782 #ifndef _STANDALONE
783 	tcgetattr(STDIN_FILENO, &oldt);
784 	newt = oldt;
785 	newt.c_lflag &= ~(ICANON | ECHO);
786 	newt.c_cc[VMIN] = 0;
787 	newt.c_cc[VTIME] = 0;
788 	tcsetattr(STDIN_FILENO, TCSANOW, &newt);
789 	ch = getchar();
790 	tcsetattr(STDIN_FILENO, TCSANOW, &oldt);
791 
792 	if (ch != -1)
793 		(void) ungetc(ch, stdin);
794 
795 	ficlStackPushInteger(ficlVmGetDataStack(pVM),
796 	    ch != -1? FICL_TRUE : FICL_FALSE);
797 #else
798 	ficlStackPushInteger(ficlVmGetDataStack(pVM),
799 	    ischar()? FICL_TRUE : FICL_FALSE);
800 #endif
801 }
802 
803 /*
804  * seconds - gives number of seconds since beginning of time
805  *
806  * beginning of time is defined as:
807  *
808  *	BTX	- number of seconds since midnight
809  *	FreeBSD	- number of seconds since Jan 1 1970
810  *
811  * seconds ( -- u )
812  */
813 static void
814 pseconds(ficlVm *pVM)
815 {
816 	FICL_STACK_CHECK(ficlVmGetDataStack(pVM), 0, 1);
817 
818 	ficlStackPushUnsigned(ficlVmGetDataStack(pVM),
819 	    (ficlUnsigned) time(NULL));
820 }
821 
822 /*
823  * ms - wait at least that many milliseconds (FACILITY)
824  * ms ( u -- )
825  */
826 static void
827 ms(ficlVm *pVM)
828 {
829 	FICL_STACK_CHECK(ficlVmGetDataStack(pVM), 1, 0);
830 
831 #ifndef _STANDALONE
832 	usleep(ficlStackPopUnsigned(ficlVmGetDataStack(pVM)) * 1000);
833 #else
834 	delay(ficlStackPopUnsigned(ficlVmGetDataStack(pVM)) * 1000);
835 #endif
836 }
837 
838 /*
839  * fkey - get a character from a file
840  * fkey ( file -- char )
841  */
842 static void
843 fkey(ficlVm *pVM)
844 {
845 	int i, fd;
846 	char ch;
847 
848 	FICL_STACK_CHECK(ficlVmGetDataStack(pVM), 1, 1);
849 
850 	fd = ficlStackPopInteger(ficlVmGetDataStack(pVM));
851 	i = read(fd, &ch, 1);
852 	ficlStackPushInteger(ficlVmGetDataStack(pVM), i > 0 ? ch : -1);
853 }
854 
855 
856 #ifdef _STANDALONE
857 #ifdef __i386__
858 
859 /*
860  * outb ( port# c -- )
861  * Store a byte to I/O port number port#
862  */
863 void
864 ficlOutb(ficlVm *pVM)
865 {
866 	uint8_t c;
867 	uint32_t port;
868 
869 	port = ficlStackPopUnsigned(ficlVmGetDataStack(pVM));
870 	c = ficlStackPopInteger(ficlVmGetDataStack(pVM));
871 	outb(port, c);
872 }
873 
874 /*
875  * inb ( port# -- c )
876  * Fetch a byte from I/O port number port#
877  */
878 void
879 ficlInb(ficlVm *pVM)
880 {
881 	uint8_t c;
882 	uint32_t port;
883 
884 	port = ficlStackPopUnsigned(ficlVmGetDataStack(pVM));
885 	c = inb(port);
886 	ficlStackPushInteger(ficlVmGetDataStack(pVM), c);
887 }
888 #endif
889 #endif
890 
891 /*
892  * Retrieves free space remaining on the dictionary
893  */
894 static void
895 freeHeap(ficlVm *pVM)
896 {
897 	ficlStackPushInteger(ficlVmGetDataStack(pVM),
898 	    ficlDictionaryCellsAvailable(ficlVmGetDictionary(pVM)));
899 }
900 
901 /*
902  * f i c l C o m p i l e P l a t f o r m
903  * Build FreeBSD platform extensions into the system dictionary
904  */
905 void
906 ficlSystemCompilePlatform(ficlSystem *pSys)
907 {
908 	ficlDictionary *dp = ficlSystemGetDictionary(pSys);
909 	ficlDictionary *env = ficlSystemGetEnvironment(pSys);
910 #ifdef _STANDALONE
911 	ficlCompileFcn **fnpp;
912 #endif
913 
914 	FICL_SYSTEM_ASSERT(pSys, dp);
915 	FICL_SYSTEM_ASSERT(pSys, env);
916 
917 	ficlDictionarySetPrimitive(dp, ".#", displayCellNoPad,
918 	    FICL_WORD_DEFAULT);
919 	ficlDictionarySetPrimitive(dp, "isdir?", isdirQuestion,
920 	    FICL_WORD_DEFAULT);
921 	ficlDictionarySetPrimitive(dp, "fopen", pfopen, FICL_WORD_DEFAULT);
922 	ficlDictionarySetPrimitive(dp, "fclose", pfclose, FICL_WORD_DEFAULT);
923 	ficlDictionarySetPrimitive(dp, "fread", pfread, FICL_WORD_DEFAULT);
924 	ficlDictionarySetPrimitive(dp, "fopendir", pfopendir,
925 	    FICL_WORD_DEFAULT);
926 	ficlDictionarySetPrimitive(dp, "freaddir", pfreaddir,
927 	    FICL_WORD_DEFAULT);
928 	ficlDictionarySetPrimitive(dp, "fclosedir", pfclosedir,
929 	    FICL_WORD_DEFAULT);
930 	ficlDictionarySetPrimitive(dp, "fload", pfload, FICL_WORD_DEFAULT);
931 	ficlDictionarySetPrimitive(dp, "fkey", fkey, FICL_WORD_DEFAULT);
932 	ficlDictionarySetPrimitive(dp, "fseek", pfseek, FICL_WORD_DEFAULT);
933 	ficlDictionarySetPrimitive(dp, "fwrite", pfwrite, FICL_WORD_DEFAULT);
934 	ficlDictionarySetPrimitive(dp, "key", key, FICL_WORD_DEFAULT);
935 	ficlDictionarySetPrimitive(dp, "key?", keyQuestion, FICL_WORD_DEFAULT);
936 	ficlDictionarySetPrimitive(dp, "ms", ms, FICL_WORD_DEFAULT);
937 	ficlDictionarySetPrimitive(dp, "seconds", pseconds, FICL_WORD_DEFAULT);
938 	ficlDictionarySetPrimitive(dp, "heap?", freeHeap, FICL_WORD_DEFAULT);
939 
940 	ficlDictionarySetPrimitive(dp, "setenv", ficlSetenv, FICL_WORD_DEFAULT);
941 	ficlDictionarySetPrimitive(dp, "setenv?", ficlSetenvq,
942 	    FICL_WORD_DEFAULT);
943 	ficlDictionarySetPrimitive(dp, "getenv", ficlGetenv, FICL_WORD_DEFAULT);
944 	ficlDictionarySetPrimitive(dp, "unsetenv", ficlUnsetenv,
945 	    FICL_WORD_DEFAULT);
946 	ficlDictionarySetPrimitive(dp, "copyin", ficlCopyin, FICL_WORD_DEFAULT);
947 	ficlDictionarySetPrimitive(dp, "copyout", ficlCopyout,
948 	    FICL_WORD_DEFAULT);
949 	ficlDictionarySetPrimitive(dp, "findfile", ficlFindfile,
950 	    FICL_WORD_DEFAULT);
951 	ficlDictionarySetPrimitive(dp, "ccall", ficlCcall, FICL_WORD_DEFAULT);
952 	ficlDictionarySetPrimitive(dp, "uuid-from-string", ficlUuidFromString,
953 	    FICL_WORD_DEFAULT);
954 	ficlDictionarySetPrimitive(dp, "uuid-to-string", ficlUuidToString,
955 	    FICL_WORD_DEFAULT);
956 #ifdef _STANDALONE
957 #ifdef __i386__
958 	ficlDictionarySetPrimitive(dp, "outb", ficlOutb, FICL_WORD_DEFAULT);
959 	ficlDictionarySetPrimitive(dp, "inb", ficlInb, FICL_WORD_DEFAULT);
960 #endif
961 	/* Register words from linker set. */
962 	SET_FOREACH(fnpp, Xficl_compile_set)
963 		(*fnpp)(pSys);
964 #endif
965 
966 #if defined(__i386__) || defined(__amd64__)
967 	ficlDictionarySetConstant(env, "arch-i386", FICL_TRUE);
968 	ficlDictionarySetConstant(env, "arch-sparc", FICL_FALSE);
969 #endif
970 #ifdef __sparc
971 	ficlDictionarySetConstant(env, "arch-i386", FICL_FALSE);
972 	ficlDictionarySetConstant(env, "arch-sparc", FICL_TRUE);
973 #endif
974 }
975