1/*-
2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
3 *
4 * units.c   Copyright (c) 1993 by Adrian Mariano (adrian@cam.cornell.edu)
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 * 1. Redistributions of source code must retain the above copyright
10 *    notice, this list of conditions and the following disclaimer.
11 * 2. The name of the author may not be used to endorse or promote products
12 *    derived from this software without specific prior written permission.
13 * Disclaimer:  This software is provided by the author "as is".  The author
14 * shall not be liable for any damages caused in any way by this software.
15 *
16 * I would appreciate (though I do not require) receiving a copy of any
17 * improvements you might make to this program.
18 */
19
20#ifndef lint
21static const char rcsid[] =
22  "$FreeBSD: stable/11/usr.bin/units/units.c 330449 2018-03-05 07:26:05Z eadler $";
23#endif /* not lint */
24
25#include <ctype.h>
26#include <err.h>
27#include <errno.h>
28#include <histedit.h>
29#include <getopt.h>
30#include <stdbool.h>
31#include <stdio.h>
32#include <stdlib.h>
33#include <string.h>
34#include <unistd.h>
35
36#include <sys/capsicum.h>
37
38#ifndef UNITSFILE
39#define UNITSFILE "/usr/share/misc/definitions.units"
40#endif
41
42#define MAXUNITS 1000
43#define MAXPREFIXES 100
44
45#define MAXSUBUNITS 500
46
47#define PRIMITIVECHAR '!'
48
49static const char *powerstring = "^";
50static const char *numfmt = "%.8g";
51
52static struct {
53	char *uname;
54	char *uval;
55}      unittable[MAXUNITS];
56
57struct unittype {
58	char *numerator[MAXSUBUNITS];
59	char *denominator[MAXSUBUNITS];
60	double factor;
61	double offset;
62	int quantity;
63};
64
65static struct {
66	char *prefixname;
67	char *prefixval;
68}      prefixtable[MAXPREFIXES];
69
70
71static char NULLUNIT[] = "";
72
73#define SEPARATOR      ":"
74
75static int unitcount;
76static int prefixcount;
77static bool verbose = false;
78static bool terse = false;
79static const char * outputformat;
80static const char * havestr;
81static const char * wantstr;
82
83static int	 addsubunit(char *product[], char *toadd);
84static int	 addunit(struct unittype *theunit, const char *toadd, int flip, int quantity);
85static void	 cancelunit(struct unittype * theunit);
86static int	 compare(const void *item1, const void *item2);
87static int	 compareproducts(char **one, char **two);
88static int	 compareunits(struct unittype * first, struct unittype * second);
89static int	 completereduce(struct unittype * unit);
90static char	*dupstr(const char *str);
91static void	 initializeunit(struct unittype * theunit);
92static char	*lookupunit(const char *unit);
93static void	 readunits(const char *userfile);
94static int	 reduceproduct(struct unittype * theunit, int flip);
95static int	 reduceunit(struct unittype * theunit);
96static void	 showanswer(struct unittype * have, struct unittype * want);
97static void	 showunit(struct unittype * theunit);
98static void	 sortunit(struct unittype * theunit);
99static void	 usage(void);
100static void	 zeroerror(void);
101
102static const char* promptstr = "";
103
104static const char * prompt(EditLine *e __unused) {
105	return promptstr;
106}
107
108static char *
109dupstr(const char *str)
110{
111	char *ret;
112
113	ret = strdup(str);
114	if (!ret)
115		err(3, "dupstr");
116	return (ret);
117}
118
119
120static void
121readunits(const char *userfile)
122{
123	FILE *unitfile;
124	char line[512], *lineptr;
125	int len, linenum, i;
126	cap_rights_t unitfilerights;
127
128	unitcount = 0;
129	linenum = 0;
130
131	if (userfile) {
132		unitfile = fopen(userfile, "r");
133		if (!unitfile)
134			errx(1, "unable to open units file '%s'", userfile);
135	}
136	else {
137		unitfile = fopen(UNITSFILE, "r");
138		if (!unitfile) {
139			char *direc, *env;
140			char filename[1000];
141
142			env = getenv("PATH");
143			if (env) {
144				direc = strtok(env, SEPARATOR);
145				while (direc) {
146					snprintf(filename, sizeof(filename),
147					    "%s/%s", direc, UNITSFILE);
148					unitfile = fopen(filename, "rt");
149					if (unitfile)
150						break;
151					direc = strtok(NULL, SEPARATOR);
152				}
153			}
154			if (!unitfile)
155				errx(1, "can't find units file '%s'", UNITSFILE);
156		}
157	}
158	cap_rights_init(&unitfilerights, CAP_READ, CAP_FSTAT);
159	if (cap_rights_limit(fileno(unitfile), &unitfilerights) < 0
160		&& errno != ENOSYS)
161		err(1, "cap_rights_limit() failed");
162	while (!feof(unitfile)) {
163		if (!fgets(line, sizeof(line), unitfile))
164			break;
165		linenum++;
166		lineptr = line;
167		if (*lineptr == '/' || *lineptr == '#')
168			continue;
169		lineptr += strspn(lineptr, " \n\t");
170		len = strcspn(lineptr, " \n\t");
171		lineptr[len] = 0;
172		if (!strlen(lineptr))
173			continue;
174		if (lineptr[strlen(lineptr) - 1] == '-') { /* it's a prefix */
175			if (prefixcount == MAXPREFIXES) {
176				warnx("memory for prefixes exceeded in line %d", linenum);
177				continue;
178			}
179			lineptr[strlen(lineptr) - 1] = 0;
180			prefixtable[prefixcount].prefixname = dupstr(lineptr);
181			for (i = 0; i < prefixcount; i++)
182				if (!strcmp(prefixtable[i].prefixname, lineptr)) {
183					warnx("redefinition of prefix '%s' on line %d ignored",
184					    lineptr, linenum);
185					continue;
186				}
187			lineptr += len + 1;
188			lineptr += strspn(lineptr, " \n\t");
189			len = strcspn(lineptr, "\n\t");
190			if (len == 0) {
191				warnx("unexpected end of prefix on line %d",
192				    linenum);
193				continue;
194			}
195			lineptr[len] = 0;
196			prefixtable[prefixcount++].prefixval = dupstr(lineptr);
197		}
198		else {		/* it's not a prefix */
199			if (unitcount == MAXUNITS) {
200				warnx("memory for units exceeded in line %d", linenum);
201				continue;
202			}
203			unittable[unitcount].uname = dupstr(lineptr);
204			for (i = 0; i < unitcount; i++)
205				if (!strcmp(unittable[i].uname, lineptr)) {
206					warnx("redefinition of unit '%s' on line %d ignored",
207					    lineptr, linenum);
208					continue;
209				}
210			lineptr += len + 1;
211			lineptr += strspn(lineptr, " \n\t");
212			if (!strlen(lineptr)) {
213				warnx("unexpected end of unit on line %d",
214				    linenum);
215				continue;
216			}
217			len = strcspn(lineptr, "\n\t");
218			lineptr[len] = 0;
219			unittable[unitcount++].uval = dupstr(lineptr);
220		}
221	}
222	fclose(unitfile);
223}
224
225static void
226initializeunit(struct unittype * theunit)
227{
228	theunit->numerator[0] = theunit->denominator[0] = NULL;
229	theunit->factor = 1.0;
230	theunit->offset = 0.0;
231	theunit->quantity = 0;
232}
233
234
235static int
236addsubunit(char *product[], char *toadd)
237{
238	char **ptr;
239
240	for (ptr = product; *ptr && *ptr != NULLUNIT; ptr++);
241	if (ptr >= product + MAXSUBUNITS) {
242		warnx("memory overflow in unit reduction");
243		return 1;
244	}
245	if (!*ptr)
246		*(ptr + 1) = NULL;
247	*ptr = dupstr(toadd);
248	return 0;
249}
250
251
252static void
253showunit(struct unittype * theunit)
254{
255	char **ptr;
256	int printedslash;
257	int counter = 1;
258
259	printf(numfmt, theunit->factor);
260	if (theunit->offset)
261		printf("&%.8g", theunit->offset);
262	for (ptr = theunit->numerator; *ptr; ptr++) {
263		if (ptr > theunit->numerator && **ptr &&
264		    !strcmp(*ptr, *(ptr - 1)))
265			counter++;
266		else {
267			if (counter > 1)
268				printf("%s%d", powerstring, counter);
269			if (**ptr)
270				printf(" %s", *ptr);
271			counter = 1;
272		}
273	}
274	if (counter > 1)
275		printf("%s%d", powerstring, counter);
276	counter = 1;
277	printedslash = 0;
278	for (ptr = theunit->denominator; *ptr; ptr++) {
279		if (ptr > theunit->denominator && **ptr &&
280		    !strcmp(*ptr, *(ptr - 1)))
281			counter++;
282		else {
283			if (counter > 1)
284				printf("%s%d", powerstring, counter);
285			if (**ptr) {
286				if (!printedslash)
287					printf(" /");
288				printedslash = 1;
289				printf(" %s", *ptr);
290			}
291			counter = 1;
292		}
293	}
294	if (counter > 1)
295		printf("%s%d", powerstring, counter);
296	printf("\n");
297}
298
299
300void
301zeroerror(void)
302{
303	warnx("unit reduces to zero");
304}
305
306/*
307   Adds the specified string to the unit.
308   Flip is 0 for adding normally, 1 for adding reciprocal.
309   Quantity is 1 if this is a quantity to be converted rather than a pure unit.
310
311   Returns 0 for successful addition, nonzero on error.
312*/
313
314static int
315addunit(struct unittype * theunit, const char *toadd, int flip, int quantity)
316{
317	char *scratch, *savescr;
318	char *item;
319	char *divider, *slash, *offset;
320	int doingtop;
321
322	if (!strlen(toadd))
323		return 1;
324
325	savescr = scratch = dupstr(toadd);
326	for (slash = scratch + 1; *slash; slash++)
327		if (*slash == '-' &&
328		    (tolower(*(slash - 1)) != 'e' ||
329		    !strchr(".0123456789", *(slash + 1))))
330			*slash = ' ';
331	slash = strchr(scratch, '/');
332	if (slash)
333		*slash = 0;
334	doingtop = 1;
335	do {
336		item = strtok(scratch, " *\t\n/");
337		while (item) {
338			if (strchr("0123456789.", *item)) { /* item is a number */
339				double num, offsetnum;
340
341				if (quantity)
342					theunit->quantity = 1;
343
344				offset = strchr(item, '&');
345				if (offset) {
346					*offset = 0;
347					offsetnum = atof(offset+1);
348				} else
349					offsetnum = 0.0;
350
351				divider = strchr(item, '|');
352				if (divider) {
353					*divider = 0;
354					num = atof(item);
355					if (!num) {
356						zeroerror();
357						free(savescr);
358						return 1;
359					}
360					if (doingtop ^ flip) {
361						theunit->factor *= num;
362						theunit->offset *= num;
363					} else {
364						theunit->factor /= num;
365						theunit->offset /= num;
366					}
367					num = atof(divider + 1);
368					if (!num) {
369						zeroerror();
370						free(savescr);
371						return 1;
372					}
373					if (doingtop ^ flip) {
374						theunit->factor /= num;
375						theunit->offset /= num;
376					} else {
377						theunit->factor *= num;
378						theunit->offset *= num;
379					}
380				}
381				else {
382					num = atof(item);
383					if (!num) {
384						zeroerror();
385						free(savescr);
386						return 1;
387					}
388					if (doingtop ^ flip) {
389						theunit->factor *= num;
390						theunit->offset *= num;
391					} else {
392						theunit->factor /= num;
393						theunit->offset /= num;
394					}
395				}
396				if (doingtop ^ flip)
397					theunit->offset += offsetnum;
398			}
399			else {	/* item is not a number */
400				int repeat = 1;
401
402				if (strchr("23456789",
403				    item[strlen(item) - 1])) {
404					repeat = item[strlen(item) - 1] - '0';
405					item[strlen(item) - 1] = 0;
406				}
407				for (; repeat; repeat--) {
408					if (addsubunit(doingtop ^ flip ? theunit->numerator : theunit->denominator, item)) {
409						free(savescr);
410						return 1;
411					}
412				}
413			}
414			item = strtok(NULL, " *\t/\n");
415		}
416		doingtop--;
417		if (slash) {
418			scratch = slash + 1;
419		}
420		else
421			doingtop--;
422	} while (doingtop >= 0);
423	free(savescr);
424	return 0;
425}
426
427
428static int
429compare(const void *item1, const void *item2)
430{
431	return strcmp(*(const char * const *)item1, *(const char * const *)item2);
432}
433
434
435static void
436sortunit(struct unittype * theunit)
437{
438	char **ptr;
439	unsigned int count;
440
441	for (count = 0, ptr = theunit->numerator; *ptr; ptr++, count++);
442	qsort(theunit->numerator, count, sizeof(char *), compare);
443	for (count = 0, ptr = theunit->denominator; *ptr; ptr++, count++);
444	qsort(theunit->denominator, count, sizeof(char *), compare);
445}
446
447
448void
449cancelunit(struct unittype * theunit)
450{
451	char **den, **num;
452	int comp;
453
454	den = theunit->denominator;
455	num = theunit->numerator;
456
457	while (*num && *den) {
458		comp = strcmp(*den, *num);
459		if (!comp) {
460/*      if (*den!=NULLUNIT) free(*den);
461      if (*num!=NULLUNIT) free(*num);*/
462			*den++ = NULLUNIT;
463			*num++ = NULLUNIT;
464		}
465		else if (comp < 0)
466			den++;
467		else
468			num++;
469	}
470}
471
472
473
474
475/*
476   Looks up the definition for the specified unit.
477   Returns a pointer to the definition or a null pointer
478   if the specified unit does not appear in the units table.
479*/
480
481static char buffer[100];	/* buffer for lookupunit answers with
482				   prefixes */
483
484char *
485lookupunit(const char *unit)
486{
487	int i;
488	char *copy;
489
490	for (i = 0; i < unitcount; i++) {
491		if (!strcmp(unittable[i].uname, unit))
492			return unittable[i].uval;
493	}
494
495	if (unit[strlen(unit) - 1] == '^') {
496		copy = dupstr(unit);
497		copy[strlen(copy) - 1] = 0;
498		for (i = 0; i < unitcount; i++) {
499			if (!strcmp(unittable[i].uname, copy)) {
500				strlcpy(buffer, copy, sizeof(buffer));
501				free(copy);
502				return buffer;
503			}
504		}
505		free(copy);
506	}
507	if (unit[strlen(unit) - 1] == 's') {
508		copy = dupstr(unit);
509		copy[strlen(copy) - 1] = 0;
510		for (i = 0; i < unitcount; i++) {
511			if (!strcmp(unittable[i].uname, copy)) {
512				strlcpy(buffer, copy, sizeof(buffer));
513				free(copy);
514				return buffer;
515			}
516		}
517		if (copy[strlen(copy) - 1] == 'e') {
518			copy[strlen(copy) - 1] = 0;
519			for (i = 0; i < unitcount; i++) {
520				if (!strcmp(unittable[i].uname, copy)) {
521					strlcpy(buffer, copy, sizeof(buffer));
522					free(copy);
523					return buffer;
524				}
525			}
526		}
527		free(copy);
528	}
529	for (i = 0; i < prefixcount; i++) {
530		size_t len = strlen(prefixtable[i].prefixname);
531		if (!strncmp(prefixtable[i].prefixname, unit, len)) {
532			if (!strlen(unit + len) || lookupunit(unit + len)) {
533				snprintf(buffer, sizeof(buffer), "%s %s",
534				    prefixtable[i].prefixval, unit + len);
535				return buffer;
536			}
537		}
538	}
539	return 0;
540}
541
542
543
544/*
545   reduces a product of symbolic units to primitive units.
546   The three low bits are used to return flags:
547
548     bit 0 (1) set on if reductions were performed without error.
549     bit 1 (2) set on if no reductions are performed.
550     bit 2 (4) set on if an unknown unit is discovered.
551*/
552
553
554#define ERROR 4
555
556static int
557reduceproduct(struct unittype * theunit, int flip)
558{
559
560	char *toadd;
561	char **product;
562	int didsomething = 2;
563
564	if (flip)
565		product = theunit->denominator;
566	else
567		product = theunit->numerator;
568
569	for (; *product; product++) {
570
571		for (;;) {
572			if (!strlen(*product))
573				break;
574			toadd = lookupunit(*product);
575			if (!toadd) {
576				printf("unknown unit '%s'\n", *product);
577				return ERROR;
578			}
579			if (strchr(toadd, PRIMITIVECHAR))
580				break;
581			didsomething = 1;
582			if (*product != NULLUNIT) {
583				free(*product);
584				*product = NULLUNIT;
585			}
586			if (addunit(theunit, toadd, flip, 0))
587				return ERROR;
588		}
589	}
590	return didsomething;
591}
592
593
594/*
595   Reduces numerator and denominator of the specified unit.
596   Returns 0 on success, or 1 on unknown unit error.
597*/
598
599static int
600reduceunit(struct unittype * theunit)
601{
602	int ret;
603
604	ret = 1;
605	while (ret & 1) {
606		ret = reduceproduct(theunit, 0) | reduceproduct(theunit, 1);
607		if (ret & 4)
608			return 1;
609	}
610	return 0;
611}
612
613
614static int
615compareproducts(char **one, char **two)
616{
617	while (*one || *two) {
618		if (!*one && *two != NULLUNIT)
619			return 1;
620		if (!*two && *one != NULLUNIT)
621			return 1;
622		if (*one == NULLUNIT)
623			one++;
624		else if (*two == NULLUNIT)
625			two++;
626		else if (strcmp(*one, *two))
627			return 1;
628		else
629			one++, two++;
630	}
631	return 0;
632}
633
634
635/* Return zero if units are compatible, nonzero otherwise */
636
637static int
638compareunits(struct unittype * first, struct unittype * second)
639{
640	return
641	compareproducts(first->numerator, second->numerator) ||
642	compareproducts(first->denominator, second->denominator);
643}
644
645
646static int
647completereduce(struct unittype * unit)
648{
649	if (reduceunit(unit))
650		return 1;
651	sortunit(unit);
652	cancelunit(unit);
653	return 0;
654}
655
656static void
657showanswer(struct unittype * have, struct unittype * want)
658{
659	double ans;
660	char* oformat;
661
662	if (compareunits(have, want)) {
663		printf("conformability error\n");
664		if (verbose)
665			printf("\t%s = ", havestr);
666		else if (!terse)
667			printf("\t");
668		showunit(have);
669		if (!terse) {
670			if (verbose)
671				printf("\t%s = ", wantstr);
672			else
673				printf("\t");
674			showunit(want);
675		}
676	}
677	else if (have->offset != want->offset) {
678		if (want->quantity)
679			printf("WARNING: conversion of non-proportional quantities.\n");
680		if (have->quantity) {
681			asprintf(&oformat, "\t%s\n", outputformat);
682			printf(oformat,
683			    (have->factor + have->offset-want->offset)/want->factor);
684			free(oformat);
685		}
686		else {
687			asprintf(&oformat, "\t (-> x*%sg %sg)\n\t (<- y*%sg %sg)\n",
688			    outputformat, outputformat, outputformat, outputformat);
689			printf(oformat,
690			    have->factor / want->factor,
691			    (have->offset-want->offset)/want->factor,
692			    want->factor / have->factor,
693			    (want->offset - have->offset)/have->factor);
694		}
695	}
696	else {
697		ans = have->factor / want->factor;
698
699		if (verbose) {
700			printf("\t%s = ", havestr);
701			printf(outputformat, ans);
702			printf(" * %s", wantstr);
703			printf("\n");
704		}
705		else if (terse) {
706			printf(outputformat, ans);
707			printf("\n");
708		}
709		else {
710			printf("\t* ");
711			printf(outputformat, ans);
712			printf("\n");
713		}
714
715		if (verbose) {
716			printf("\t%s = (1 / ", havestr);
717			printf(outputformat, 1/ans);
718			printf(") * %s\n", wantstr);
719		}
720		else if (!terse) {
721			printf("\t/ ");
722			printf(outputformat, 1/ans);
723			printf("\n");
724		}
725	}
726}
727
728
729static void
730usage(void)
731{
732	fprintf(stderr,
733		"usage: units [-f unitsfile] [-H historyfile] [-UVq] [from-unit to-unit]\n");
734	exit(3);
735}
736
737static struct option longopts[] = {
738	{"help", no_argument, NULL, 'h'},
739	{"exponential", no_argument, NULL, 'e'},
740	{"file", required_argument, NULL, 'f'},
741	{"history", required_argument, NULL, 'H'},
742	{"output-format", required_argument, NULL, 'o'},
743	{"quiet", no_argument, NULL, 'q'},
744	{"terse", no_argument, NULL, 't'},
745	{"unitsfile", no_argument, NULL, 'U'},
746	{"verbose", no_argument, NULL, 'v'},
747	{"version", no_argument, NULL, 'V'},
748	{ 0, 0, 0, 0 }
749};
750
751
752int
753main(int argc, char **argv)
754{
755
756	struct unittype have, want;
757	int optchar;
758	bool quiet;
759	bool readfile;
760	bool quit;
761	History *inhistory;
762	EditLine *el;
763	HistEvent ev;
764	int inputsz;
765	char const * history_file;
766
767	quiet = false;
768	readfile = false;
769	history_file = NULL;
770	outputformat = numfmt;
771	quit = false;
772	while ((optchar = getopt_long(argc, argv, "+ehf:o:qtvH:UV", longopts, NULL)) != -1) {
773		switch (optchar) {
774		case 'e':
775			outputformat = "%6e";
776			break;
777		case 'f':
778			readfile = true;
779			if (strlen(optarg) == 0)
780				readunits(NULL);
781			else
782				readunits(optarg);
783			break;
784		case 'H':
785			history_file = optarg;
786			break;
787		case 'q':
788			quiet = true;
789			break;
790		case 't':
791			terse = true;
792			break;
793		case 'o':
794			outputformat = optarg;
795			break;
796		case 'v':
797			verbose = true;
798			break;
799		case 'V':
800			fprintf(stderr, "FreeBSD units\n");
801			/* FALLTHROUGH */
802		case 'U':
803			if (access(UNITSFILE, F_OK) == 0)
804				printf("%s\n", UNITSFILE);
805			else
806				printf("Units data file not found");
807			exit(0);
808			break;
809		case 'h':
810			/* FALLTHROUGH */
811
812		default:
813			usage();
814		}
815	}
816
817	if (!readfile)
818		readunits(NULL);
819
820	if (optind == argc - 2) {
821		if (cap_enter() < 0 && errno != ENOSYS)
822			err(1, "unable to enter capability mode");
823
824		havestr = argv[optind];
825		wantstr = argv[optind + 1];
826		initializeunit(&have);
827		addunit(&have, havestr, 0, 1);
828		completereduce(&have);
829		initializeunit(&want);
830		addunit(&want, wantstr, 0, 1);
831		completereduce(&want);
832		showanswer(&have, &want);
833	} else {
834		inhistory = history_init();
835		el = el_init(argv[0], stdin, stdout, stderr);
836		el_set(el, EL_PROMPT, &prompt);
837		el_set(el, EL_EDITOR, "emacs");
838		el_set(el, EL_SIGNAL, 1);
839		el_set(el, EL_HIST, history, inhistory);
840		el_source(el, NULL);
841		history(inhistory, &ev, H_SETSIZE, 800);
842		if (inhistory == 0)
843			err(1, "Could not initialize history");
844
845		if (cap_enter() < 0 && errno != ENOSYS)
846			err(1, "unable to enter capability mode");
847
848		if (!quiet)
849			printf("%d units, %d prefixes\n", unitcount,
850			    prefixcount);
851		while (!quit) {
852			do {
853				initializeunit(&have);
854				if (!quiet)
855					promptstr = "You have: ";
856				havestr = el_gets(el, &inputsz);
857				if (havestr == NULL) {
858					quit = true;
859					break;
860				}
861				if (inputsz > 0)
862					history(inhistory, &ev, H_ENTER,
863					havestr);
864			} while (addunit(&have, havestr, 0, 1) ||
865			    completereduce(&have));
866			if (quit) {
867				break;
868			}
869			do {
870				initializeunit(&want);
871				if (!quiet)
872					promptstr = "You want: ";
873				wantstr = el_gets(el, &inputsz);
874				if (wantstr == NULL) {
875					quit = true;
876					break;
877				}
878				if (inputsz > 0)
879					history(inhistory, &ev, H_ENTER,
880					wantstr);
881			} while (addunit(&want, wantstr, 0, 1) ||
882			    completereduce(&want));
883			if (quit) {
884				break;
885			}
886			showanswer(&have, &want);
887		}
888
889		history_end(inhistory);
890		el_end(el);
891	}
892
893	return (0);
894}
895