Touch up Makefile.b32
[nasm/autotest.git] / nasmlib.c
blob7578ea7cf2c8e20bcc4c31d5c8c98892482a5f37
1 /* nasmlib.c library routines for the Netwide Assembler
3 * The Netwide Assembler is copyright (C) 1996 Simon Tatham and
4 * Julian Hall. All rights reserved. The software is
5 * redistributable under the licence given in the file "Licence"
6 * distributed in the NASM archive.
7 */
9 #include <stdio.h>
10 #include <stdlib.h>
11 #include <string.h>
12 #include <ctype.h>
14 #include "nasm.h"
15 #include "nasmlib.h"
16 #include "insns.h" /* For MAX_KEYWORD */
18 static efunc nasm_malloc_error;
20 #ifdef LOGALLOC
21 static FILE *logfp;
22 #endif
24 void nasm_set_malloc_error (efunc error)
26 nasm_malloc_error = error;
27 #ifdef LOGALLOC
28 logfp = fopen ("malloc.log", "w");
29 setvbuf (logfp, NULL, _IOLBF, BUFSIZ);
30 fprintf (logfp, "null pointer is %p\n", NULL);
31 #endif
34 #ifdef LOGALLOC
35 void *nasm_malloc_log (char *file, int line, size_t size)
36 #else
37 void *nasm_malloc (size_t size)
38 #endif
40 void *p = malloc(size);
41 if (!p)
42 nasm_malloc_error (ERR_FATAL | ERR_NOFILE, "out of memory");
43 #ifdef LOGALLOC
44 else
45 fprintf(logfp, "%s %d malloc(%ld) returns %p\n",
46 file, line, (long)size, p);
47 #endif
48 return p;
51 #ifdef LOGALLOC
52 void *nasm_realloc_log (char *file, int line, void *q, size_t size)
53 #else
54 void *nasm_realloc (void *q, size_t size)
55 #endif
57 void *p = q ? realloc(q, size) : malloc(size);
58 if (!p)
59 nasm_malloc_error (ERR_FATAL | ERR_NOFILE, "out of memory");
60 #ifdef LOGALLOC
61 else if (q)
62 fprintf(logfp, "%s %d realloc(%p,%ld) returns %p\n",
63 file, line, q, (long)size, p);
64 else
65 fprintf(logfp, "%s %d malloc(%ld) returns %p\n",
66 file, line, (long)size, p);
67 #endif
68 return p;
71 #ifdef LOGALLOC
72 void nasm_free_log (char *file, int line, void *q)
73 #else
74 void nasm_free (void *q)
75 #endif
77 if (q) {
78 free (q);
79 #ifdef LOGALLOC
80 fprintf(logfp, "%s %d free(%p)\n",
81 file, line, q);
82 #endif
86 #ifdef LOGALLOC
87 char *nasm_strdup_log (char *file, int line, const char *s)
88 #else
89 char *nasm_strdup (const char *s)
90 #endif
92 char *p;
93 int size = strlen(s)+1;
95 p = malloc(size);
96 if (!p)
97 nasm_malloc_error (ERR_FATAL | ERR_NOFILE, "out of memory");
98 #ifdef LOGALLOC
99 else
100 fprintf(logfp, "%s %d strdup(%ld) returns %p\n",
101 file, line, (long)size, p);
102 #endif
103 strcpy (p, s);
104 return p;
107 #ifdef LOGALLOC
108 char *nasm_strndup_log (char *file, int line, char *s, size_t len)
109 #else
110 char *nasm_strndup (char *s, size_t len)
111 #endif
113 char *p;
114 int size = len+1;
116 p = malloc(size);
117 if (!p)
118 nasm_malloc_error (ERR_FATAL | ERR_NOFILE, "out of memory");
119 #ifdef LOGALLOC
120 else
121 fprintf(logfp, "%s %d strndup(%ld) returns %p\n",
122 file, line, (long)size, p);
123 #endif
124 strncpy (p, s, len);
125 p[len] = '\0';
126 return p;
129 #if !defined(stricmp) && !defined(strcasecmp)
130 int nasm_stricmp (const char *s1, const char *s2)
132 while (*s1 && tolower(*s1) == tolower(*s2))
133 s1++, s2++;
134 if (!*s1 && !*s2)
135 return 0;
136 else if (tolower(*s1) < tolower(*s2))
137 return -1;
138 else
139 return 1;
141 #endif
143 #if !defined(strnicmp) && !defined(strncasecmp)
144 int nasm_strnicmp (const char *s1, const char *s2, int n)
146 while (n > 0 && *s1 && tolower(*s1) == tolower(*s2))
147 s1++, s2++, n--;
148 if ((!*s1 && !*s2) || n==0)
149 return 0;
150 else if (tolower(*s1) < tolower(*s2))
151 return -1;
152 else
153 return 1;
155 #endif
157 #define lib_isnumchar(c) ( isalnum(c) || (c) == '$')
158 #define numvalue(c) ((c)>='a' ? (c)-'a'+10 : (c)>='A' ? (c)-'A'+10 : (c)-'0')
160 long readnum (char *str, int *error)
162 char *r = str, *q;
163 long radix;
164 unsigned long result, checklimit;
165 int digit, last;
166 int warn = FALSE;
167 int sign = 1;
169 *error = FALSE;
171 while (isspace(*r)) r++; /* find start of number */
174 * If the number came from make_tok_num (as a result of an %assign), it
175 * might have a '-' built into it (rather than in a preceeding token).
177 if (*r == '-')
179 r++;
180 sign = -1;
183 q = r;
185 while (lib_isnumchar(*q)) q++; /* find end of number */
188 * If it begins 0x, 0X or $, or ends in H, it's in hex. if it
189 * ends in Q, it's octal. if it ends in B, it's binary.
190 * Otherwise, it's ordinary decimal.
192 if (*r=='0' && (r[1]=='x' || r[1]=='X'))
193 radix = 16, r += 2;
194 else if (*r=='$')
195 radix = 16, r++;
196 else if (q[-1]=='H' || q[-1]=='h')
197 radix = 16 , q--;
198 else if (q[-1]=='Q' || q[-1]=='q' || q[-1]=='O' || q[-1]=='o')
199 radix = 8 , q--;
200 else if (q[-1]=='B' || q[-1]=='b')
201 radix = 2 , q--;
202 else
203 radix = 10;
206 * If this number has been found for us by something other than
207 * the ordinary scanners, then it might be malformed by having
208 * nothing between the prefix and the suffix. Check this case
209 * now.
211 if (r >= q) {
212 *error = TRUE;
213 return 0;
217 * `checklimit' must be 2**32 / radix. We can't do that in
218 * 32-bit arithmetic, which we're (probably) using, so we
219 * cheat: since we know that all radices we use are even, we
220 * can divide 2**31 by radix/2 instead.
222 checklimit = 0x80000000UL / (radix>>1);
225 * Calculate the highest allowable value for the last digit
226 * of a 32 bit constant... in radix 10, it is 6, otherwise it is 0
228 last = (radix == 10 ? 6 : 0);
230 result = 0;
231 while (*r && r < q) {
232 if (*r<'0' || (*r>'9' && *r<'A') || (digit = numvalue(*r)) >= radix)
234 *error = TRUE;
235 return 0;
237 if (result > checklimit ||
238 (result == checklimit && digit >= last))
240 warn = TRUE;
243 result = radix * result + digit;
244 r++;
247 if (warn)
248 nasm_malloc_error (ERR_WARNING | ERR_PASS1 | ERR_WARN_NOV,
249 "numeric constant %s does not fit in 32 bits",
250 str);
252 return result*sign;
255 long readstrnum (char *str, int length, int *warn)
257 long charconst = 0;
258 int i;
260 *warn = FALSE;
262 str += length;
263 for (i=0; i<length; i++) {
264 if (charconst & 0xff000000UL) {
265 *warn = TRUE;
267 charconst = (charconst<<8) + (unsigned char) *--str;
269 return charconst;
272 static long next_seg;
274 void seg_init(void)
276 next_seg = 0;
279 long seg_alloc(void)
281 return (next_seg += 2) - 2;
284 void fwriteshort (int data, FILE *fp)
286 fputc ((int) (data & 255), fp);
287 fputc ((int) ((data >> 8) & 255), fp);
290 void fwritelong (long data, FILE *fp)
292 fputc ((int) (data & 255), fp);
293 fputc ((int) ((data >> 8) & 255), fp);
294 fputc ((int) ((data >> 16) & 255), fp);
295 fputc ((int) ((data >> 24) & 255), fp);
298 void standard_extension (char *inname, char *outname, char *extension,
299 efunc error)
301 char *p, *q;
303 if (*outname) /* file name already exists, */
304 return; /* so do nothing */
305 q = inname;
306 p = outname;
307 while (*q) *p++ = *q++; /* copy, and find end of string */
308 *p = '\0'; /* terminate it */
309 while (p > outname && *--p != '.');/* find final period (or whatever) */
310 if (*p != '.') while (*p) p++; /* go back to end if none found */
311 if (!strcmp(p, extension)) { /* is the extension already there? */
312 if (*extension)
313 error(ERR_WARNING | ERR_NOFILE,
314 "file name already ends in `%s': "
315 "output will be in `nasm.out'",
316 extension);
317 else
318 error(ERR_WARNING | ERR_NOFILE,
319 "file name already has no extension: "
320 "output will be in `nasm.out'");
321 strcpy(outname, "nasm.out");
322 } else
323 strcpy(p, extension);
326 #define LEAFSIZ (sizeof(RAA)-sizeof(RAA_UNION)+sizeof(RAA_LEAF))
327 #define BRANCHSIZ (sizeof(RAA)-sizeof(RAA_UNION)+sizeof(RAA_BRANCH))
329 #define LAYERSIZ(r) ( (r)->layers==0 ? RAA_BLKSIZE : RAA_LAYERSIZE )
331 static struct RAA *real_raa_init (int layers)
333 struct RAA *r;
334 int i;
336 if (layers == 0) {
337 r = nasm_malloc (LEAFSIZ);
338 r->layers = 0;
339 memset (r->u.l.data, 0, sizeof(r->u.l.data));
340 r->stepsize = 1L;
341 } else {
342 r = nasm_malloc (BRANCHSIZ);
343 r->layers = layers;
344 for ( i = 0 ; i < RAA_LAYERSIZE ; i++ )
345 r->u.b.data[i] = NULL;
346 r->stepsize = RAA_BLKSIZE;
347 while (--layers)
348 r->stepsize *= RAA_LAYERSIZE;
350 return r;
353 struct RAA *raa_init (void)
355 return real_raa_init (0);
358 void raa_free (struct RAA *r)
360 if (r->layers == 0)
361 nasm_free (r);
362 else {
363 struct RAA **p;
364 for (p = r->u.b.data; p - r->u.b.data < RAA_LAYERSIZE; p++)
365 if (*p)
366 raa_free (*p);
370 long raa_read (struct RAA *r, long posn)
372 if (posn >= r->stepsize * LAYERSIZ(r))
373 return 0; /* Return 0 for undefined entries */
374 while (r->layers > 0) {
375 ldiv_t l;
376 l = ldiv (posn, r->stepsize);
377 r = r->u.b.data[l.quot];
378 posn = l.rem;
379 if (!r)
380 return 0; /* Return 0 for undefined entries */
382 return r->u.l.data[posn];
385 struct RAA *raa_write (struct RAA *r, long posn, long value)
387 struct RAA *result;
389 if (posn < 0)
390 nasm_malloc_error (ERR_PANIC, "negative position in raa_write");
392 while (r->stepsize * LAYERSIZ(r) <= posn) {
394 * Must add a layer.
396 struct RAA *s;
397 int i;
399 s = nasm_malloc (BRANCHSIZ);
400 for ( i = 0 ; i < RAA_LAYERSIZE ; i++ )
401 s->u.b.data[i] = NULL;
402 s->layers = r->layers + 1;
403 s->stepsize = LAYERSIZ(r) * r->stepsize;
404 s->u.b.data[0] = r;
405 r = s;
408 result = r;
410 while (r->layers > 0) {
411 ldiv_t l;
412 struct RAA **s;
413 l = ldiv (posn, r->stepsize);
414 s = &r->u.b.data[l.quot];
415 if (!*s)
416 *s = real_raa_init (r->layers - 1);
417 r = *s;
418 posn = l.rem;
421 r->u.l.data[posn] = value;
423 return result;
426 #define SAA_MAXLEN 8192
428 struct SAA *saa_init (long elem_len)
430 struct SAA *s;
432 if (elem_len > SAA_MAXLEN)
433 nasm_malloc_error (ERR_PANIC | ERR_NOFILE, "SAA with huge elements");
435 s = nasm_malloc (sizeof(struct SAA));
436 s->posn = s->start = 0L;
437 s->elem_len = elem_len;
438 s->length = SAA_MAXLEN - (SAA_MAXLEN % elem_len);
439 s->data = nasm_malloc (s->length);
440 s->next = NULL;
441 s->end = s;
443 return s;
446 void saa_free (struct SAA *s)
448 struct SAA *t;
450 while (s) {
451 t = s->next;
452 nasm_free (s->data);
453 nasm_free (s);
454 s = t;
458 void *saa_wstruct (struct SAA *s)
460 void *p;
462 if (s->end->length - s->end->posn < s->elem_len) {
463 s->end->next = nasm_malloc (sizeof(struct SAA));
464 s->end->next->start = s->end->start + s->end->posn;
465 s->end = s->end->next;
466 s->end->length = s->length;
467 s->end->next = NULL;
468 s->end->posn = 0L;
469 s->end->data = nasm_malloc (s->length);
472 p = s->end->data + s->end->posn;
473 s->end->posn += s->elem_len;
474 return p;
477 void saa_wbytes (struct SAA *s, const void *data, long len)
479 const char *d = data;
481 while (len > 0) {
482 long l = s->end->length - s->end->posn;
483 if (l > len)
484 l = len;
485 if (l > 0) {
486 if (d) {
487 memcpy (s->end->data + s->end->posn, d, l);
488 d += l;
489 } else
490 memset (s->end->data + s->end->posn, 0, l);
491 s->end->posn += l;
492 len -= l;
494 if (len > 0) {
495 s->end->next = nasm_malloc (sizeof(struct SAA));
496 s->end->next->start = s->end->start + s->end->posn;
497 s->end = s->end->next;
498 s->end->length = s->length;
499 s->end->next = NULL;
500 s->end->posn = 0L;
501 s->end->data = nasm_malloc (s->length);
506 void saa_rewind (struct SAA *s)
508 s->rptr = s;
509 s->rpos = 0L;
512 void *saa_rstruct (struct SAA *s)
514 void *p;
516 if (!s->rptr)
517 return NULL;
519 if (s->rptr->posn - s->rpos < s->elem_len) {
520 s->rptr = s->rptr->next;
521 if (!s->rptr)
522 return NULL; /* end of array */
523 s->rpos = 0L;
526 p = s->rptr->data + s->rpos;
527 s->rpos += s->elem_len;
528 return p;
531 void *saa_rbytes (struct SAA *s, long *len)
533 void *p;
535 if (!s->rptr)
536 return NULL;
538 p = s->rptr->data + s->rpos;
539 *len = s->rptr->posn - s->rpos;
540 s->rptr = s->rptr->next;
541 s->rpos = 0L;
542 return p;
545 void saa_rnbytes (struct SAA *s, void *data, long len)
547 char *d = data;
549 while (len > 0) {
550 long l;
552 if (!s->rptr)
553 return;
555 l = s->rptr->posn - s->rpos;
556 if (l > len)
557 l = len;
558 if (l > 0) {
559 memcpy (d, s->rptr->data + s->rpos, l);
560 d += l;
561 s->rpos += l;
562 len -= l;
564 if (len > 0) {
565 s->rptr = s->rptr->next;
566 s->rpos = 0L;
571 void saa_fread (struct SAA *s, long posn, void *data, long len)
573 struct SAA *p;
574 long pos;
575 char *cdata = data;
577 if (!s->rptr || posn < s->rptr->start)
578 saa_rewind (s);
579 p = s->rptr;
580 while (posn >= p->start + p->posn) {
581 p = p->next;
582 if (!p)
583 return; /* what else can we do?! */
586 pos = posn - p->start;
587 while (len) {
588 long l = p->posn - pos;
589 if (l > len)
590 l = len;
591 memcpy (cdata, p->data+pos, l);
592 len -= l;
593 cdata += l;
594 p = p->next;
595 if (!p)
596 return;
597 pos = 0L;
599 s->rptr = p;
602 void saa_fwrite (struct SAA *s, long posn, void *data, long len)
604 struct SAA *p;
605 long pos;
606 char *cdata = data;
608 if (!s->rptr || posn < s->rptr->start)
609 saa_rewind (s);
610 p = s->rptr;
611 while (posn >= p->start + p->posn) {
612 p = p->next;
613 if (!p)
614 return; /* what else can we do?! */
617 pos = posn - p->start;
618 while (len) {
619 long l = p->posn - pos;
620 if (l > len)
621 l = len;
622 memcpy (p->data+pos, cdata, l);
623 len -= l;
624 cdata += l;
625 p = p->next;
626 if (!p)
627 return;
628 pos = 0L;
630 s->rptr = p;
633 void saa_fpwrite (struct SAA *s, FILE *fp)
635 char *data;
636 long len;
638 saa_rewind (s);
639 while ( (data = saa_rbytes (s, &len)) )
640 fwrite (data, 1, len, fp);
644 * Register, instruction, condition-code and prefix keywords used
645 * by the scanner.
647 #include "names.c"
648 static const char *special_names[] = {
649 "byte", "dword", "far", "long", "near", "nosplit", "qword",
650 "short", "strict", "to", "tword", "word"
652 static const char *prefix_names[] = {
653 "a16", "a32", "lock", "o16", "o32", "rep", "repe", "repne",
654 "repnz", "repz", "times"
659 * Standard scanner routine used by parser.c and some output
660 * formats. It keeps a succession of temporary-storage strings in
661 * stdscan_tempstorage, which can be cleared using stdscan_reset.
663 static char **stdscan_tempstorage = NULL;
664 static int stdscan_tempsize = 0, stdscan_templen = 0;
665 #define STDSCAN_TEMP_DELTA 256
667 static void stdscan_pop(void)
669 nasm_free (stdscan_tempstorage[--stdscan_templen]);
672 void stdscan_reset(void)
674 while (stdscan_templen > 0)
675 stdscan_pop();
679 * Unimportant cleanup is done to avoid confusing people who are trying
680 * to debug real memory leaks
682 void nasmlib_cleanup (void)
684 stdscan_reset();
685 nasm_free (stdscan_tempstorage);
688 static char *stdscan_copy(char *p, int len)
690 char *text;
692 text = nasm_malloc(len+1);
693 strncpy (text, p, len);
694 text[len] = '\0';
696 if (stdscan_templen >= stdscan_tempsize) {
697 stdscan_tempsize += STDSCAN_TEMP_DELTA;
698 stdscan_tempstorage = nasm_realloc(stdscan_tempstorage,
699 stdscan_tempsize*sizeof(char *));
701 stdscan_tempstorage[stdscan_templen++] = text;
703 return text;
706 char *stdscan_bufptr = NULL;
707 int stdscan (void *private_data, struct tokenval *tv)
709 char ourcopy[MAX_KEYWORD+1], *r, *s;
711 (void) private_data; /* Don't warn that this parameter is unused */
713 while (isspace(*stdscan_bufptr)) stdscan_bufptr++;
714 if (!*stdscan_bufptr)
715 return tv->t_type = 0;
717 /* we have a token; either an id, a number or a char */
718 if (isidstart(*stdscan_bufptr) ||
719 (*stdscan_bufptr == '$' && isidstart(stdscan_bufptr[1]))) {
720 /* now we've got an identifier */
721 int i;
722 int is_sym = FALSE;
724 if (*stdscan_bufptr == '$') {
725 is_sym = TRUE;
726 stdscan_bufptr++;
729 r = stdscan_bufptr++;
730 while (isidchar(*stdscan_bufptr)) stdscan_bufptr++;
731 tv->t_charptr = stdscan_copy(r, stdscan_bufptr - r);
733 if (is_sym || stdscan_bufptr-r > MAX_KEYWORD)
734 return tv->t_type = TOKEN_ID;/* bypass all other checks */
736 for (s=tv->t_charptr, r=ourcopy; *s; s++)
737 *r++ = tolower (*s);
738 *r = '\0';
739 /* right, so we have an identifier sitting in temp storage. now,
740 * is it actually a register or instruction name, or what? */
741 if ((tv->t_integer=bsi(ourcopy, reg_names,
742 elements(reg_names)))>=0) {
743 tv->t_integer += EXPR_REG_START;
744 return tv->t_type = TOKEN_REG;
745 } else if ((tv->t_integer=bsi(ourcopy, insn_names,
746 elements(insn_names)))>=0) {
747 return tv->t_type = TOKEN_INSN;
749 for (i=0; i<elements(icn); i++)
750 if (!strncmp(ourcopy, icn[i], strlen(icn[i]))) {
751 char *p = ourcopy + strlen(icn[i]);
752 tv->t_integer = ico[i];
753 if ((tv->t_inttwo=bsi(p, conditions,
754 elements(conditions)))>=0)
755 return tv->t_type = TOKEN_INSN;
757 if ((tv->t_integer=bsi(ourcopy, prefix_names,
758 elements(prefix_names)))>=0) {
759 tv->t_integer += PREFIX_ENUM_START;
760 return tv->t_type = TOKEN_PREFIX;
762 if ((tv->t_integer=bsi(ourcopy, special_names,
763 elements(special_names)))>=0)
764 return tv->t_type = TOKEN_SPECIAL;
765 if (!nasm_stricmp(ourcopy, "seg"))
766 return tv->t_type = TOKEN_SEG;
767 if (!nasm_stricmp(ourcopy, "wrt"))
768 return tv->t_type = TOKEN_WRT;
769 return tv->t_type = TOKEN_ID;
770 } else if (*stdscan_bufptr == '$' && !isnumchar(stdscan_bufptr[1])) {
772 * It's a $ sign with no following hex number; this must
773 * mean it's a Here token ($), evaluating to the current
774 * assembly location, or a Base token ($$), evaluating to
775 * the base of the current segment.
777 stdscan_bufptr++;
778 if (*stdscan_bufptr == '$') {
779 stdscan_bufptr++;
780 return tv->t_type = TOKEN_BASE;
782 return tv->t_type = TOKEN_HERE;
783 } else if (isnumstart(*stdscan_bufptr)) { /* now we've got a number */
784 int rn_error;
786 r = stdscan_bufptr++;
787 while (isnumchar(*stdscan_bufptr))
788 stdscan_bufptr++;
790 if (*stdscan_bufptr == '.') {
792 * a floating point constant
794 stdscan_bufptr++;
795 while (isnumchar(*stdscan_bufptr) ||
796 ((stdscan_bufptr[-1] == 'e' || stdscan_bufptr[-1] == 'E')
797 && (*stdscan_bufptr == '-' || *stdscan_bufptr == '+')) )
799 stdscan_bufptr++;
801 tv->t_charptr = stdscan_copy(r, stdscan_bufptr - r);
802 return tv->t_type = TOKEN_FLOAT;
804 r = stdscan_copy(r, stdscan_bufptr - r);
805 tv->t_integer = readnum(r, &rn_error);
806 stdscan_pop();
807 if (rn_error)
808 return tv->t_type = TOKEN_ERRNUM;/* some malformation occurred */
809 tv->t_charptr = NULL;
810 return tv->t_type = TOKEN_NUM;
811 } else if (*stdscan_bufptr == '\'' ||
812 *stdscan_bufptr == '"') {/* a char constant */
813 char quote = *stdscan_bufptr++, *r;
814 int rn_warn;
815 r = tv->t_charptr = stdscan_bufptr;
816 while (*stdscan_bufptr && *stdscan_bufptr != quote) stdscan_bufptr++;
817 tv->t_inttwo = stdscan_bufptr - r; /* store full version */
818 if (!*stdscan_bufptr)
819 return tv->t_type = TOKEN_ERRNUM; /* unmatched quotes */
820 stdscan_bufptr++; /* skip over final quote */
821 tv->t_integer = readstrnum(r, tv->t_inttwo, &rn_warn);
822 /* FIXME: rn_warn is not checked! */
823 return tv->t_type = TOKEN_NUM;
824 } else if (*stdscan_bufptr == ';') { /* a comment has happened - stay */
825 return tv->t_type = 0;
826 } else if (stdscan_bufptr[0] == '>' && stdscan_bufptr[1] == '>') {
827 stdscan_bufptr += 2;
828 return tv->t_type = TOKEN_SHR;
829 } else if (stdscan_bufptr[0] == '<' && stdscan_bufptr[1] == '<') {
830 stdscan_bufptr += 2;
831 return tv->t_type = TOKEN_SHL;
832 } else if (stdscan_bufptr[0] == '/' && stdscan_bufptr[1] == '/') {
833 stdscan_bufptr += 2;
834 return tv->t_type = TOKEN_SDIV;
835 } else if (stdscan_bufptr[0] == '%' && stdscan_bufptr[1] == '%') {
836 stdscan_bufptr += 2;
837 return tv->t_type = TOKEN_SMOD;
838 } else if (stdscan_bufptr[0] == '=' && stdscan_bufptr[1] == '=') {
839 stdscan_bufptr += 2;
840 return tv->t_type = TOKEN_EQ;
841 } else if (stdscan_bufptr[0] == '<' && stdscan_bufptr[1] == '>') {
842 stdscan_bufptr += 2;
843 return tv->t_type = TOKEN_NE;
844 } else if (stdscan_bufptr[0] == '!' && stdscan_bufptr[1] == '=') {
845 stdscan_bufptr += 2;
846 return tv->t_type = TOKEN_NE;
847 } else if (stdscan_bufptr[0] == '<' && stdscan_bufptr[1] == '=') {
848 stdscan_bufptr += 2;
849 return tv->t_type = TOKEN_LE;
850 } else if (stdscan_bufptr[0] == '>' && stdscan_bufptr[1] == '=') {
851 stdscan_bufptr += 2;
852 return tv->t_type = TOKEN_GE;
853 } else if (stdscan_bufptr[0] == '&' && stdscan_bufptr[1] == '&') {
854 stdscan_bufptr += 2;
855 return tv->t_type = TOKEN_DBL_AND;
856 } else if (stdscan_bufptr[0] == '^' && stdscan_bufptr[1] == '^') {
857 stdscan_bufptr += 2;
858 return tv->t_type = TOKEN_DBL_XOR;
859 } else if (stdscan_bufptr[0] == '|' && stdscan_bufptr[1] == '|') {
860 stdscan_bufptr += 2;
861 return tv->t_type = TOKEN_DBL_OR;
862 } else /* just an ordinary char */
863 return tv->t_type = (unsigned char) (*stdscan_bufptr++);
867 * Return TRUE if the argument is a simple scalar. (Or a far-
868 * absolute, which counts.)
870 int is_simple (expr *vect)
872 while (vect->type && !vect->value)
873 vect++;
874 if (!vect->type)
875 return 1;
876 if (vect->type != EXPR_SIMPLE)
877 return 0;
878 do {
879 vect++;
880 } while (vect->type && !vect->value);
881 if (vect->type && vect->type < EXPR_SEGBASE+SEG_ABS) return 0;
882 return 1;
886 * Return TRUE if the argument is a simple scalar, _NOT_ a far-
887 * absolute.
889 int is_really_simple (expr *vect)
891 while (vect->type && !vect->value)
892 vect++;
893 if (!vect->type)
894 return 1;
895 if (vect->type != EXPR_SIMPLE)
896 return 0;
897 do {
898 vect++;
899 } while (vect->type && !vect->value);
900 if (vect->type) return 0;
901 return 1;
905 * Return TRUE if the argument is relocatable (i.e. a simple
906 * scalar, plus at most one segment-base, plus possibly a WRT).
908 int is_reloc (expr *vect)
910 while (vect->type && !vect->value) /* skip initial value-0 terms */
911 vect++;
912 if (!vect->type) /* trivially return TRUE if nothing */
913 return 1; /* is present apart from value-0s */
914 if (vect->type < EXPR_SIMPLE) /* FALSE if a register is present */
915 return 0;
916 if (vect->type == EXPR_SIMPLE) { /* skip over a pure number term... */
917 do {
918 vect++;
919 } while (vect->type && !vect->value);
920 if (!vect->type) /* ...returning TRUE if that's all */
921 return 1;
923 if (vect->type == EXPR_WRT) { /* skip over a WRT term... */
924 do {
925 vect++;
926 } while (vect->type && !vect->value);
927 if (!vect->type) /* ...returning TRUE if that's all */
928 return 1;
930 if (vect->value != 0 && vect->value != 1)
931 return 0; /* segment base multiplier non-unity */
932 do { /* skip over _one_ seg-base term... */
933 vect++;
934 } while (vect->type && !vect->value);
935 if (!vect->type) /* ...returning TRUE if that's all */
936 return 1;
937 return 0; /* And return FALSE if there's more */
941 * Return TRUE if the argument contains an `unknown' part.
943 int is_unknown(expr *vect)
945 while (vect->type && vect->type < EXPR_UNKNOWN)
946 vect++;
947 return (vect->type == EXPR_UNKNOWN);
951 * Return TRUE if the argument contains nothing but an `unknown'
952 * part.
954 int is_just_unknown(expr *vect)
956 while (vect->type && !vect->value)
957 vect++;
958 return (vect->type == EXPR_UNKNOWN);
962 * Return the scalar part of a relocatable vector. (Including
963 * simple scalar vectors - those qualify as relocatable.)
965 long reloc_value (expr *vect)
967 while (vect->type && !vect->value)
968 vect++;
969 if (!vect->type) return 0;
970 if (vect->type == EXPR_SIMPLE)
971 return vect->value;
972 else
973 return 0;
977 * Return the segment number of a relocatable vector, or NO_SEG for
978 * simple scalars.
980 long reloc_seg (expr *vect)
982 while (vect->type && (vect->type == EXPR_WRT || !vect->value))
983 vect++;
984 if (vect->type == EXPR_SIMPLE) {
985 do {
986 vect++;
987 } while (vect->type && (vect->type == EXPR_WRT || !vect->value));
989 if (!vect->type)
990 return NO_SEG;
991 else
992 return vect->type - EXPR_SEGBASE;
996 * Return the WRT segment number of a relocatable vector, or NO_SEG
997 * if no WRT part is present.
999 long reloc_wrt (expr *vect)
1001 while (vect->type && vect->type < EXPR_WRT)
1002 vect++;
1003 if (vect->type == EXPR_WRT) {
1004 return vect->value;
1005 } else
1006 return NO_SEG;
1010 * Binary search.
1012 int bsi (char *string, const char **array, int size)
1014 int i = -1, j = size; /* always, i < index < j */
1015 while (j-i >= 2) {
1016 int k = (i+j)/2;
1017 int l = strcmp(string, array[k]);
1018 if (l<0) /* it's in the first half */
1019 j = k;
1020 else if (l>0) /* it's in the second half */
1021 i = k;
1022 else /* we've got it :) */
1023 return k;
1025 return -1; /* we haven't got it :( */
1028 static char *file_name = NULL;
1029 static long line_number = 0;
1031 char *src_set_fname(char *newname)
1033 char *oldname = file_name;
1034 file_name = newname;
1035 return oldname;
1038 long src_set_linnum(long newline)
1040 long oldline = line_number;
1041 line_number = newline;
1042 return oldline;
1045 long src_get_linnum(void)
1047 return line_number;
1050 int src_get(long *xline, char **xname)
1052 if (!file_name || !*xname || strcmp(*xname, file_name))
1054 nasm_free(*xname);
1055 *xname = file_name ? nasm_strdup(file_name) : NULL;
1056 *xline = line_number;
1057 return -2;
1059 if (*xline != line_number)
1061 long tmp = line_number - *xline;
1062 *xline = line_number;
1063 return tmp;
1065 return 0;
1068 void nasm_quote(char **str)
1070 int ln=strlen(*str);
1071 char q=(*str)[0];
1072 char *p;
1073 if (ln>1 && (*str)[ln-1]==q && (q=='"' || q=='\''))
1074 return;
1075 q = '"';
1076 if (strchr(*str,q))
1077 q = '\'';
1078 p = nasm_malloc(ln+3);
1079 strcpy(p+1, *str);
1080 nasm_free(*str);
1081 p[ln+1] = p[0] = q;
1082 p[ln+2] = 0;
1083 *str = p;
1086 char *nasm_strcat(char *one, char *two)
1088 char *rslt;
1089 int l1=strlen(one);
1090 rslt = nasm_malloc(l1+strlen(two)+1);
1091 strcpy(rslt, one);
1092 strcpy(rslt+l1, two);
1093 return rslt;
1096 void null_debug_init(struct ofmt *of, void *id, FILE *fp, efunc error ) {}
1097 void null_debug_linenum(const char *filename, long linenumber, long segto) {}
1098 void null_debug_deflabel(char *name, long segment, long offset, int is_global, char *special) {}
1099 void null_debug_routine(const char *directive, const char *params) {}
1100 void null_debug_typevalue(long type) {}
1101 void null_debug_output(int type, void *param) {}
1102 void null_debug_cleanup(void){}
1104 struct dfmt null_debug_form = {
1105 "Null debug format",
1106 "null",
1107 null_debug_init,
1108 null_debug_linenum,
1109 null_debug_deflabel,
1110 null_debug_routine,
1111 null_debug_typevalue,
1112 null_debug_output,
1113 null_debug_cleanup
1116 struct dfmt *null_debug_arr[2] = { &null_debug_form, NULL };