From: Christos Zoulas <christos@zoulas.com>
Date: Mon, 24 Mar 2003 01:16:28 +0000 (+0000)
Subject: constant name protection.
X-Git-Tag: FILE4_00~8
X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=67989b092f3cceba43c5c2eab88149f3b730a73d;p=file

constant name protection.
---

diff --git a/src/apprentice.c b/src/apprentice.c
index 96911fe1..f85d0487 100644
--- a/src/apprentice.c
+++ b/src/apprentice.c
@@ -50,7 +50,7 @@
 #endif
 
 #ifndef	lint
-FILE_RCSID("@(#)$Id: apprentice.c,v 1.53 2003/03/23 21:16:26 christos Exp $")
+FILE_RCSID("@(#)$Id: apprentice.c,v 1.54 2003/03/24 01:16:28 christos Exp $")
 #endif	/* lint */
 
 #define	EATAB {while (isascii((unsigned char) *l) && \
@@ -143,7 +143,7 @@ apprentice_1(struct magic_set *ms, const char *fn, int action,
 	int rv = -1;
 	int mapped;
 
-	if (action == COMPILE) {
+	if (action == FILE_COMPILE) {
 		rv = apprentice_file(ms, &magic, &nmagic, fn, action);
 		if (rv == 0) {
 			rv = apprentice_compile(ms, &magic, &nmagic, fn,
@@ -257,7 +257,7 @@ apprentice_file(struct magic_set *ms, struct magic **magicp, uint32_t *nmagicp,
 	}
 
 	/* parse it */
-	if (action == CHECK)	/* print silly verbose header for USG compat. */
+	if (action == FILE_CHECK)	/* print silly verbose header for USG compat. */
 		(void) printf("%s\n", hdr);
 
 	for (lineno = 1; fgets(line, BUFSIZ, f) != NULL; lineno++) {
@@ -292,29 +292,29 @@ file_signextend(struct magic_set *ms, struct magic *m, uint32_t v)
 		 * vital.  When later compared with the data,
 		 * the sign extension must have happened.
 		 */
-		case BYTE:
+		case FILE_BYTE:
 			v = (char) v;
 			break;
-		case SHORT:
-		case BESHORT:
-		case LESHORT:
+		case FILE_SHORT:
+		case FILE_BESHORT:
+		case FILE_LESHORT:
 			v = (short) v;
 			break;
-		case DATE:
-		case BEDATE:
-		case LEDATE:
-		case LDATE:
-		case BELDATE:
-		case LELDATE:
-		case LONG:
-		case BELONG:
-		case LELONG:
+		case FILE_DATE:
+		case FILE_BEDATE:
+		case FILE_LEDATE:
+		case FILE_LDATE:
+		case FILE_BELDATE:
+		case FILE_LELDATE:
+		case FILE_LONG:
+		case FILE_BELONG:
+		case FILE_LELONG:
 			v = (int32_t) v;
 			break;
-		case STRING:
-		case PSTRING:
+		case FILE_STRING:
+		case FILE_PSTRING:
 			break;
-		case REGEX:
+		case FILE_REGEX:
 			break;
 		default:
 			if (ms->flags & MAGIC_CHECK)
@@ -376,7 +376,7 @@ parse(struct magic_set *ms, struct magic **magicp, uint32_t *nmagicp, char *l,
         l = t;
 
 	if (m->flag & INDIR) {
-		m->in_type = LONG;
+		m->in_type = FILE_LONG;
 		m->in_offset = 0;
 		/*
 		 * read [.lbs][+-]nnnnn)
@@ -385,24 +385,24 @@ parse(struct magic_set *ms, struct magic **magicp, uint32_t *nmagicp, char *l,
 			l++;
 			switch (*l) {
 			case 'l':
-				m->in_type = LELONG;
+				m->in_type = FILE_LELONG;
 				break;
 			case 'L':
-				m->in_type = BELONG;
+				m->in_type = FILE_BELONG;
 				break;
 			case 'h':
 			case 's':
-				m->in_type = LESHORT;
+				m->in_type = FILE_LESHORT;
 				break;
 			case 'H':
 			case 'S':
-				m->in_type = BESHORT;
+				m->in_type = FILE_BESHORT;
 				break;
 			case 'c':
 			case 'b':
 			case 'C':
 			case 'B':
-				m->in_type = BYTE;
+				m->in_type = FILE_BYTE;
 				break;
 			default:
 				if (ms->flags & MAGIC_CHECK)
@@ -414,40 +414,40 @@ parse(struct magic_set *ms, struct magic **magicp, uint32_t *nmagicp, char *l,
 			l++;
 		}
 		if (*l == '~') {
-			m->in_op = OPINVERSE;
+			m->in_op = FILE_OPINVERSE;
 			l++;
 		}
 		switch (*l) {
 		case '&':
-			m->in_op |= OPAND;
+			m->in_op |= FILE_OPAND;
 			l++;
 			break;
 		case '|':
-			m->in_op |= OPOR;
+			m->in_op |= FILE_OPOR;
 			l++;
 			break;
 		case '^':
-			m->in_op |= OPXOR;
+			m->in_op |= FILE_OPXOR;
 			l++;
 			break;
 		case '+':
-			m->in_op |= OPADD;
+			m->in_op |= FILE_OPADD;
 			l++;
 			break;
 		case '-':
-			m->in_op |= OPMINUS;
+			m->in_op |= FILE_OPMINUS;
 			l++;
 			break;
 		case '*':
-			m->in_op |= OPMULTIPLY;
+			m->in_op |= FILE_OPMULTIPLY;
 			l++;
 			break;
 		case '/':
-			m->in_op |= OPDIVIDE;
+			m->in_op |= FILE_OPDIVIDE;
 			l++;
 			break;
 		case '%':
-			m->in_op |= OPMODULO;
+			m->in_op |= FILE_OPMODULO;
 			l++;
 			break;
 		}
@@ -490,55 +490,55 @@ parse(struct magic_set *ms, struct magic **magicp, uint32_t *nmagicp, char *l,
 
 	/* get type, skip it */
 	if (strncmp(l, "char", NBYTE)==0) {	/* HP/UX compat */
-		m->type = BYTE;
+		m->type = FILE_BYTE;
 		l += NBYTE;
 	} else if (strncmp(l, "byte", NBYTE)==0) {
-		m->type = BYTE;
+		m->type = FILE_BYTE;
 		l += NBYTE;
 	} else if (strncmp(l, "short", NSHORT)==0) {
-		m->type = SHORT;
+		m->type = FILE_SHORT;
 		l += NSHORT;
 	} else if (strncmp(l, "long", NLONG)==0) {
-		m->type = LONG;
+		m->type = FILE_LONG;
 		l += NLONG;
 	} else if (strncmp(l, "string", NSTRING)==0) {
-		m->type = STRING;
+		m->type = FILE_STRING;
 		l += NSTRING;
 	} else if (strncmp(l, "date", NDATE)==0) {
-		m->type = DATE;
+		m->type = FILE_DATE;
 		l += NDATE;
 	} else if (strncmp(l, "beshort", NBESHORT)==0) {
-		m->type = BESHORT;
+		m->type = FILE_BESHORT;
 		l += NBESHORT;
 	} else if (strncmp(l, "belong", NBELONG)==0) {
-		m->type = BELONG;
+		m->type = FILE_BELONG;
 		l += NBELONG;
 	} else if (strncmp(l, "bedate", NBEDATE)==0) {
-		m->type = BEDATE;
+		m->type = FILE_BEDATE;
 		l += NBEDATE;
 	} else if (strncmp(l, "leshort", NLESHORT)==0) {
-		m->type = LESHORT;
+		m->type = FILE_LESHORT;
 		l += NLESHORT;
 	} else if (strncmp(l, "lelong", NLELONG)==0) {
-		m->type = LELONG;
+		m->type = FILE_LELONG;
 		l += NLELONG;
 	} else if (strncmp(l, "ledate", NLEDATE)==0) {
-		m->type = LEDATE;
+		m->type = FILE_LEDATE;
 		l += NLEDATE;
 	} else if (strncmp(l, "pstring", NPSTRING)==0) {
-		m->type = PSTRING;
+		m->type = FILE_PSTRING;
 		l += NPSTRING;
 	} else if (strncmp(l, "ldate", NLDATE)==0) {
-		m->type = LDATE;
+		m->type = FILE_LDATE;
 		l += NLDATE;
 	} else if (strncmp(l, "beldate", NBELDATE)==0) {
-		m->type = BELDATE;
+		m->type = FILE_BELDATE;
 		l += NBELDATE;
 	} else if (strncmp(l, "leldate", NLELDATE)==0) {
-		m->type = LELDATE;
+		m->type = FILE_LELDATE;
 		l += NLELDATE;
 	} else if (strncmp(l, "regex", NREGEX)==0) {
-		m->type = REGEX;
+		m->type = FILE_REGEX;
 		l += sizeof("regex");
 	} else {
 		if (ms->flags & MAGIC_CHECK)
@@ -548,56 +548,56 @@ parse(struct magic_set *ms, struct magic **magicp, uint32_t *nmagicp, char *l,
 	/* New-style anding: "0 byte&0x80 =0x80 dynamically linked" */
 	/* New and improved: ~ & | ^ + - * / % -- exciting, isn't it? */
 	if (*l == '~') {
-		if (STRING != m->type && PSTRING != m->type)
-			m->mask_op = OPINVERSE;
+		if (FILE_STRING != m->type && FILE_PSTRING != m->type)
+			m->mask_op = FILE_OPINVERSE;
 		++l;
 	}
 	switch (*l) {
 	case '&':
-		m->mask_op |= OPAND;
+		m->mask_op |= FILE_OPAND;
 		++l;
 		m->mask = file_signextend(ms, m, strtoul(l, &l, 0));
 		eatsize(&l);
 		break;
 	case '|':
-		m->mask_op |= OPOR;
+		m->mask_op |= FILE_OPOR;
 		++l;
 		m->mask = file_signextend(ms, m, strtoul(l, &l, 0));
 		eatsize(&l);
 		break;
 	case '^':
-		m->mask_op |= OPXOR;
+		m->mask_op |= FILE_OPXOR;
 		++l;
 		m->mask = file_signextend(ms, m, strtoul(l, &l, 0));
 		eatsize(&l);
 		break;
 	case '+':
-		m->mask_op |= OPADD;
+		m->mask_op |= FILE_OPADD;
 		++l;
 		m->mask = file_signextend(ms, m, strtoul(l, &l, 0));
 		eatsize(&l);
 		break;
 	case '-':
-		m->mask_op |= OPMINUS;
+		m->mask_op |= FILE_OPMINUS;
 		++l;
 		m->mask = file_signextend(ms, m, strtoul(l, &l, 0));
 		eatsize(&l);
 		break;
 	case '*':
-		m->mask_op |= OPMULTIPLY;
+		m->mask_op |= FILE_OPMULTIPLY;
 		++l;
 		m->mask = file_signextend(ms, m, strtoul(l, &l, 0));
 		eatsize(&l);
 		break;
 	case '%':
-		m->mask_op |= OPMODULO;
+		m->mask_op |= FILE_OPMODULO;
 		++l;
 		m->mask = file_signextend(ms, m, strtoul(l, &l, 0));
 		eatsize(&l);
 		break;
 	case '/':
-		if (STRING != m->type && PSTRING != m->type) {
-			m->mask_op |= OPDIVIDE;
+		if (FILE_STRING != m->type && FILE_PSTRING != m->type) {
+			m->mask_op |= FILE_OPDIVIDE;
 			++l;
 			m->mask = file_signextend(ms, m, strtoul(l, &l, 0));
 			eatsize(&l);
@@ -645,7 +645,7 @@ parse(struct magic_set *ms, struct magic **magicp, uint32_t *nmagicp, char *l,
 		}
 		break;
 	case '!':
-		if (m->type != STRING && m->type != PSTRING) {
+		if (m->type != FILE_STRING && m->type != FILE_PSTRING) {
 			m->reln = *l;
 			++l;
 			break;
@@ -685,11 +685,11 @@ GetDesc:
 		m->nospflag = 1;
 	} else
 		m->nospflag = 0;
-	while ((m->desc[i++] = *l++) != '\0' && i<MAXDESC)
+	while ((m->desc[i++] = *l++) != '\0' && i < MAXDESC)
 		/* NULLBODY */;
 
 #ifndef COMPILE_ONLY
-	if (action == CHECK) {
+	if (action == FILE_CHECK) {
 		file_mdump(m);
 	}
 #endif
@@ -707,17 +707,22 @@ getvalue(struct magic_set *ms, struct magic *m, char **p)
 {
 	int slen;
 
-	if (m->type == STRING || m->type == PSTRING || m->type == REGEX) {
+	switch (m->type) {
+	case FILE_STRING:
+	case FILE_PSTRING:
+	case FILE_REGEX:
 		*p = getstr(ms, *p, m->value.s, sizeof(m->value.s), &slen);
 		if (*p == NULL)
 			return -1;
 		m->vallen = slen;
-	} else
+		return 0;
+	default:
 		if (m->reln != 'x') {
 			m->value.l = file_signextend(ms, m, strtoul(*p, p, 0));
 			eatsize(p);
 		}
-	return 0;
+		return 0;
+	}
 }
 
 /*
@@ -1121,7 +1126,7 @@ bs1(struct magic *m)
 	m->cont_level = swap2(m->cont_level);
 	m->offset = swap4(m->offset);
 	m->in_offset = swap4(m->in_offset);
-	if (m->type != STRING)
+	if (m->type != FILE_STRING)
 		m->value.l = swap4(m->value.l);
 	m->mask = swap4(m->mask);
 }
diff --git a/src/compress.c b/src/compress.c
index 0734d61a..097983c1 100644
--- a/src/compress.c
+++ b/src/compress.c
@@ -55,7 +55,7 @@
 #endif
 
 #ifndef lint
-FILE_RCSID("@(#)$Id: compress.c,v 1.28 2003/03/23 21:24:07 christos Exp $")
+FILE_RCSID("@(#)$Id: compress.c,v 1.29 2003/03/24 01:16:28 christos Exp $")
 #endif
 
 
@@ -108,7 +108,7 @@ file_zmagic(struct magic_set *ms, const unsigned char *buf, size_t nbytes)
 			if (file_printf(ms, " (") == -1)
 				return -1;
 			ms->flags &= ~MAGIC_COMPRESS;
-			if (file_buf(ms, buf, nbytes) == -1) {
+			if (file_buffer(ms, buf, nbytes) == -1) {
 				ms->flags |= MAGIC_COMPRESS;
 				return -1;
 			}
diff --git a/src/file.c b/src/file.c
index b0ed6b33..22629fb5 100644
--- a/src/file.c
+++ b/src/file.c
@@ -72,7 +72,7 @@
 #include "patchlevel.h"
 
 #ifndef	lint
-FILE_RCSID("@(#)$Id: file.c,v 1.71 2003/03/23 21:16:26 christos Exp $")
+FILE_RCSID("@(#)$Id: file.c,v 1.72 2003/03/24 01:16:28 christos Exp $")
 #endif	/* lint */
 
 
@@ -208,10 +208,10 @@ main(int argc, char *argv[])
 			++bflag;
 			break;
 		case 'c':
-			action = CHECK;
+			action = FILE_CHECK;
 			break;
 		case 'C':
-			action = COMPILE;
+			action = FILE_COMPILE;
 			break;
 		case 'd':
 			flags |= MAGIC_DEBUG;
@@ -274,15 +274,15 @@ main(int argc, char *argv[])
 	}
 
 	switch(action) {
-	case CHECK:
-	case COMPILE:
+	case FILE_CHECK:
+	case FILE_COMPILE:
 		magic = magic_open(flags);
 		if (magic == NULL) {
 			(void)fprintf(stderr, "%s: %s\n", progname,
 			    strerror(errno));
 			return 1;
 		}
-		return action == CHECK ? magic_check(magic, magicfile) :
+		return action == FILE_CHECK ? magic_check(magic, magicfile) :
 		    magic_compile(magic, magicfile);
 	default:
 		load(magicfile, flags);
diff --git a/src/file.h b/src/file.h
index 467f535d..060a12f1 100644
--- a/src/file.h
+++ b/src/file.h
@@ -32,7 +32,7 @@
  */
 /*
  * file.h - definitions for file(1) program
- * @(#)$Id: file.h,v 1.47 2003/03/23 21:16:26 christos Exp $
+ * @(#)$Id: file.h,v 1.48 2003/03/24 01:16:28 christos Exp $
  */
 
 #ifndef __file_h__
@@ -76,8 +76,8 @@
 #define MAGICNO		0xF11E041C
 #define VERSIONNO	1
 
-#define CHECK	1
-#define COMPILE	2
+#define FILE_CHECK	1
+#define FILE_COMPILE	2
 
 #ifndef __GNUC__
 #define __attribute__(a)
@@ -94,33 +94,33 @@ struct magic {
 	uint8_t vallen;		/* length of string value, if any */
 	uint8_t type;		/* int, short, long or string. */
 	uint8_t in_type;	/* type of indirrection */
-#define 			BYTE	1
-#define				SHORT	2
-#define				LONG	4
-#define				STRING	5
-#define				DATE	6
-#define				BESHORT	7
-#define				BELONG	8
-#define				BEDATE	9
-#define				LESHORT	10
-#define				LELONG	11
-#define				LEDATE	12
-#define				PSTRING	13
-#define				LDATE	14
-#define				BELDATE	15
-#define				LELDATE	16
-#define				REGEX	17
+#define 			FILE_BYTE	1
+#define				FILE_SHORT	2
+#define				FILE_LONG	4
+#define				FILE_STRING	5
+#define				FILE_DATE	6
+#define				FILE_BESHORT	7
+#define				FILE_BELONG	8
+#define				FILE_BEDATE	9
+#define				FILE_LESHORT	10
+#define				FILE_LELONG	11
+#define				FILE_LEDATE	12
+#define				FILE_PSTRING	13
+#define				FILE_LDATE	14
+#define				FILE_BELDATE	15
+#define				FILE_LELDATE	16
+#define				FILE_REGEX	17
 	uint8_t in_op;		/* operator for indirection */
 	uint8_t mask_op;	/* operator for mask */
-#define				OPAND	1
-#define				OPOR	2
-#define				OPXOR	3
-#define				OPADD	4
-#define				OPMINUS	5
-#define				OPMULTIPLY	6
-#define				OPDIVIDE	7
-#define				OPMODULO	8
-#define				OPINVERSE	0x80
+#define				FILE_OPAND	1
+#define				FILE_OPOR	2
+#define				FILE_OPXOR	3
+#define				FILE_OPADD	4
+#define				FILE_OPMINUS	5
+#define				FILE_OPMULTIPLY	6
+#define				FILE_OPDIVIDE	7
+#define				FILE_OPMODULO	8
+#define				FILE_OPINVERSE	0x80
 	int32_t offset;		/* offset to magic number */
 	int32_t in_offset;	/* offset from indirection */
 	union VALUETYPE {
@@ -173,7 +173,7 @@ struct magic_set {
 
 struct stat;
 protected char *file_fmttime(long, int);
-protected int file_buf(struct magic_set *, const void *buf, size_t);
+protected int file_buffer(struct magic_set *, const void *buf, size_t);
 protected int file_fsmagic(struct magic_set *, const char *, struct stat *);
 protected int file_pipe2file(struct magic_set *, int, const void *, size_t);
 protected int file_printf(struct magic_set *, const char *, ...);
diff --git a/src/funcs.c b/src/funcs.c
index 46a4f834..e95e7f1f 100644
--- a/src/funcs.c
+++ b/src/funcs.c
@@ -111,7 +111,7 @@ file_badread(struct magic_set *ms)
 }
 
 protected int
-file_buf(struct magic_set *ms, const void *buf, size_t nb)
+file_buffer(struct magic_set *ms, const void *buf, size_t nb)
 {
     int m;
     /* try compression stuff */
diff --git a/src/magic.c b/src/magic.c
index 6f090af5..3733120d 100644
--- a/src/magic.c
+++ b/src/magic.c
@@ -36,7 +36,7 @@
 #include "patchlevel.h"
 
 #ifndef	lint
-FILE_RCSID("@(#)$Id: magic.c,v 1.3 2003/03/23 21:24:07 christos Exp $")
+FILE_RCSID("@(#)$Id: magic.c,v 1.4 2003/03/24 01:16:28 christos Exp $")
 #endif	/* lint */
 
 
@@ -131,7 +131,7 @@ magic_close(ms)
 public int
 magic_compile(struct magic_set *ms, const char *magicfile)
 {
-	struct mlist *ml = file_apprentice(ms, magicfile, COMPILE);
+	struct mlist *ml = file_apprentice(ms, magicfile, FILE_COMPILE);
 	if(ml == NULL)
 		return -1;
 	free_mlist(ml);
@@ -141,7 +141,7 @@ magic_compile(struct magic_set *ms, const char *magicfile)
 public int
 magic_check(struct magic_set *ms, const char *magicfile)
 {
-	struct mlist *ml = file_apprentice(ms, magicfile, CHECK);
+	struct mlist *ml = file_apprentice(ms, magicfile, FILE_CHECK);
 	if(ml == NULL)
 		return -1;
 	free_mlist(ml);
diff --git a/src/print.c b/src/print.c
index 7f1f0093..f07c7b5d 100644
--- a/src/print.c
+++ b/src/print.c
@@ -46,7 +46,7 @@
 #include <time.h>
 
 #ifndef lint
-FILE_RCSID("@(#)$Id: print.c,v 1.41 2003/03/23 21:16:26 christos Exp $")
+FILE_RCSID("@(#)$Id: print.c,v 1.42 2003/03/24 01:16:28 christos Exp $")
 #endif  /* lint */
 
 #define SZOF(a)	(sizeof(a) / sizeof(a[0]))
@@ -71,7 +71,7 @@ file_mdump(struct magic *m)
 			       /* Note: type is unsigned */
 			       (m->in_type < SZOF(typ)) ? 
 					typ[m->in_type] : "*bad*");
-		if (m->in_op & OPINVERSE)
+		if (m->in_op & FILE_OPINVERSE)
 			(void) fputc('~', stderr);
 		(void) fprintf(stderr, "%c%d),",
 			       ((m->in_op&0x7F) < SZOF(optyp)) ? 
@@ -81,13 +81,13 @@ file_mdump(struct magic *m)
 	(void) fprintf(stderr, " %s%s", (m->flag & UNSIGNED) ? "u" : "",
 		       /* Note: type is unsigned */
 		       (m->type < SZOF(typ)) ? typ[m->type] : "*bad*");
-	if (m->mask_op & OPINVERSE)
+	if (m->mask_op & FILE_OPINVERSE)
 		(void) fputc('~', stderr);
 	if (m->mask) {
 		((m->mask_op&0x7F) < SZOF(optyp)) ? 
 			(void) fputc(optyp[m->mask_op&0x7F], stderr) :
 			(void) fputc('?', stderr);
-		if(STRING != m->type || PSTRING != m->type)
+		if(FILE_STRING != m->type || FILE_PSTRING != m->type)
 			(void) fprintf(stderr, "%.8x", m->mask);
 		else {
 			if (m->mask & STRING_IGNORE_LOWERCASE) 
@@ -104,29 +104,29 @@ file_mdump(struct magic *m)
 
 	if (m->reln != 'x') {
 		switch (m->type) {
-		case BYTE:
-		case SHORT:
-		case LONG:
-		case LESHORT:
-		case LELONG:
-		case BESHORT:
-		case BELONG:
+		case FILE_BYTE:
+		case FILE_SHORT:
+		case FILE_LONG:
+		case FILE_LESHORT:
+		case FILE_LELONG:
+		case FILE_BESHORT:
+		case FILE_BELONG:
 			(void) fprintf(stderr, "%d", m->value.l);
 			break;
-		case STRING:
-		case PSTRING:
-		case REGEX:
+		case FILE_STRING:
+		case FILE_PSTRING:
+		case FILE_REGEX:
 			file_showstr(stderr, m->value.s, -1);
 			break;
-		case DATE:
-		case LEDATE:
-		case BEDATE:
+		case FILE_DATE:
+		case FILE_LEDATE:
+		case FILE_BEDATE:
 			(void)fprintf(stderr, "%s,",
 			    file_fmttime(m->value.l, 1));
 			break;
-		case LDATE:
-		case LELDATE:
-		case BELDATE:
+		case FILE_LDATE:
+		case FILE_LELDATE:
+		case FILE_BELDATE:
 			(void)fprintf(stderr, "%s,",
 			    file_fmttime(m->value.l, 0));
 			break;
diff --git a/src/softmagic.c b/src/softmagic.c
index 86261f87..7b069bc7 100644
--- a/src/softmagic.c
+++ b/src/softmagic.c
@@ -44,7 +44,7 @@
 
 
 #ifndef	lint
-FILE_RCSID("@(#)$Id: softmagic.c,v 1.56 2003/03/23 21:16:26 christos Exp $")
+FILE_RCSID("@(#)$Id: softmagic.c,v 1.57 2003/03/24 01:16:28 christos Exp $")
 #endif	/* lint */
 
 private int match(struct magic_set *, struct magic *, uint32_t,
@@ -248,33 +248,33 @@ mprint(struct magic_set *ms, union VALUETYPE *p, struct magic *m)
 
 
   	switch (m->type) {
-  	case BYTE:
+  	case FILE_BYTE:
 		v = file_signextend(ms, m, p->b);
 		if (file_printf(ms, m->desc, (unsigned char) v) == -1)
 			return -1;
 		t = m->offset + sizeof(char);
 		break;
 
-  	case SHORT:
-  	case BESHORT:
-  	case LESHORT:
+  	case FILE_SHORT:
+  	case FILE_BESHORT:
+  	case FILE_LESHORT:
 		v = file_signextend(ms, m, p->h);
 		if (file_printf(ms, m->desc, (unsigned short) v) == -1)
 			return -1;
 		t = m->offset + sizeof(short);
 		break;
 
-  	case LONG:
-  	case BELONG:
-  	case LELONG:
+  	case FILE_LONG:
+  	case FILE_BELONG:
+  	case FILE_LELONG:
 		v = file_signextend(ms, m, p->l);
 		if (file_printf(ms, m->desc, (uint32_t) v) == -1)
 			return -1;
 		t = m->offset + sizeof(int32_t);
   		break;
 
-  	case STRING:
-  	case PSTRING:
+  	case FILE_STRING:
+  	case FILE_PSTRING:
 		if (m->reln == '=') {
 			if (file_printf(ms, m->desc, m->value.s) == -1)
 				return -1;
@@ -292,22 +292,22 @@ mprint(struct magic_set *ms, union VALUETYPE *p, struct magic *m)
 		}
 		break;
 
-	case DATE:
-	case BEDATE:
-	case LEDATE:
+	case FILE_DATE:
+	case FILE_BEDATE:
+	case FILE_LEDATE:
 		if (file_printf(ms, m->desc, file_fmttime(p->l, 1)) == -1)
 			return -1;
 		t = m->offset + sizeof(time_t);
 		break;
 
-	case LDATE:
-	case BELDATE:
-	case LELDATE:
+	case FILE_LDATE:
+	case FILE_BELDATE:
+	case FILE_LELDATE:
 		if (file_printf(ms, m->desc, file_fmttime(p->l, 0)) == -1)
 			return -1;
 		t = m->offset + sizeof(time_t);
 		break;
-	case REGEX:
+	case FILE_REGEX:
 	  	if (file_printf(ms, m->desc, p->s) == -1)
 			return -1;
 		t = m->offset + strlen(p->s);
@@ -329,102 +329,102 @@ private int
 mconvert(struct magic_set *ms, union VALUETYPE *p, struct magic *m)
 {
 	switch (m->type) {
-	case BYTE:
+	case FILE_BYTE:
 		if (m->mask)
 			switch (m->mask_op&0x7F) {
-			case OPAND:
+			case FILE_OPAND:
 				p->b &= m->mask;
 				break;
-			case OPOR:
+			case FILE_OPOR:
 				p->b |= m->mask;
 				break;
-			case OPXOR:
+			case FILE_OPXOR:
 				p->b ^= m->mask;
 				break;
-			case OPADD:
+			case FILE_OPADD:
 				p->b += m->mask;
 				break;
-			case OPMINUS:
+			case FILE_OPMINUS:
 				p->b -= m->mask;
 				break;
-			case OPMULTIPLY:
+			case FILE_OPMULTIPLY:
 				p->b *= m->mask;
 				break;
-			case OPDIVIDE:
+			case FILE_OPDIVIDE:
 				p->b /= m->mask;
 				break;
-			case OPMODULO:
+			case FILE_OPMODULO:
 				p->b %= m->mask;
 				break;
 			}
-		if (m->mask_op & OPINVERSE)
+		if (m->mask_op & FILE_OPINVERSE)
 			p->b = ~p->b;
 		return 1;
-	case SHORT:
+	case FILE_SHORT:
 		if (m->mask)
 			switch (m->mask_op&0x7F) {
-			case OPAND:
+			case FILE_OPAND:
 				p->h &= m->mask;
 				break;
-			case OPOR:
+			case FILE_OPOR:
 				p->h |= m->mask;
 				break;
-			case OPXOR:
+			case FILE_OPXOR:
 				p->h ^= m->mask;
 				break;
-			case OPADD:
+			case FILE_OPADD:
 				p->h += m->mask;
 				break;
-			case OPMINUS:
+			case FILE_OPMINUS:
 				p->h -= m->mask;
 				break;
-			case OPMULTIPLY:
+			case FILE_OPMULTIPLY:
 				p->h *= m->mask;
 				break;
-			case OPDIVIDE:
+			case FILE_OPDIVIDE:
 				p->h /= m->mask;
 				break;
-			case OPMODULO:
+			case FILE_OPMODULO:
 				p->h %= m->mask;
 				break;
 			}
-		if (m->mask_op & OPINVERSE)
+		if (m->mask_op & FILE_OPINVERSE)
 			p->h = ~p->h;
 		return 1;
-	case LONG:
-	case DATE:
-	case LDATE:
+	case FILE_LONG:
+	case FILE_DATE:
+	case FILE_LDATE:
 		if (m->mask)
 			switch (m->mask_op&0x7F) {
-			case OPAND:
+			case FILE_OPAND:
 				p->l &= m->mask;
 				break;
-			case OPOR:
+			case FILE_OPOR:
 				p->l |= m->mask;
 				break;
-			case OPXOR:
+			case FILE_OPXOR:
 				p->l ^= m->mask;
 				break;
-			case OPADD:
+			case FILE_OPADD:
 				p->l += m->mask;
 				break;
-			case OPMINUS:
+			case FILE_OPMINUS:
 				p->l -= m->mask;
 				break;
-			case OPMULTIPLY:
+			case FILE_OPMULTIPLY:
 				p->l *= m->mask;
 				break;
-			case OPDIVIDE:
+			case FILE_OPDIVIDE:
 				p->l /= m->mask;
 				break;
-			case OPMODULO:
+			case FILE_OPMODULO:
 				p->l %= m->mask;
 				break;
 			}
-		if (m->mask_op & OPINVERSE)
+		if (m->mask_op & FILE_OPINVERSE)
 			p->l = ~p->l;
 		return 1;
-	case STRING:
+	case FILE_STRING:
 		{
 			int n;
 
@@ -435,7 +435,7 @@ mconvert(struct magic_set *ms, union VALUETYPE *p, struct magic *m)
 				p->s[n] = '\0';
 			return 1;
 		}
-	case PSTRING:
+	case FILE_PSTRING:
 		{
 			char *ptr1 = p->s, *ptr2 = ptr1 + 1;
 			int n = *p->s;
@@ -449,141 +449,141 @@ mconvert(struct magic_set *ms, union VALUETYPE *p, struct magic *m)
 				p->s[n] = '\0';
 			return 1;
 		}
-	case BESHORT:
+	case FILE_BESHORT:
 		p->h = (short)((p->hs[0]<<8)|(p->hs[1]));
 		if (m->mask)
 			switch (m->mask_op&0x7F) {
-			case OPAND:
+			case FILE_OPAND:
 				p->h &= m->mask;
 				break;
-			case OPOR:
+			case FILE_OPOR:
 				p->h |= m->mask;
 				break;
-			case OPXOR:
+			case FILE_OPXOR:
 				p->h ^= m->mask;
 				break;
-			case OPADD:
+			case FILE_OPADD:
 				p->h += m->mask;
 				break;
-			case OPMINUS:
+			case FILE_OPMINUS:
 				p->h -= m->mask;
 				break;
-			case OPMULTIPLY:
+			case FILE_OPMULTIPLY:
 				p->h *= m->mask;
 				break;
-			case OPDIVIDE:
+			case FILE_OPDIVIDE:
 				p->h /= m->mask;
 				break;
-			case OPMODULO:
+			case FILE_OPMODULO:
 				p->h %= m->mask;
 				break;
 			}
-		if (m->mask_op & OPINVERSE)
+		if (m->mask_op & FILE_OPINVERSE)
 			p->h = ~p->h;
 		return 1;
-	case BELONG:
-	case BEDATE:
-	case BELDATE:
+	case FILE_BELONG:
+	case FILE_BEDATE:
+	case FILE_BELDATE:
 		p->l = (int32_t)
 		    ((p->hl[0]<<24)|(p->hl[1]<<16)|(p->hl[2]<<8)|(p->hl[3]));
 		if (m->mask)
 			switch (m->mask_op&0x7F) {
-			case OPAND:
+			case FILE_OPAND:
 				p->l &= m->mask;
 				break;
-			case OPOR:
+			case FILE_OPOR:
 				p->l |= m->mask;
 				break;
-			case OPXOR:
+			case FILE_OPXOR:
 				p->l ^= m->mask;
 				break;
-			case OPADD:
+			case FILE_OPADD:
 				p->l += m->mask;
 				break;
-			case OPMINUS:
+			case FILE_OPMINUS:
 				p->l -= m->mask;
 				break;
-			case OPMULTIPLY:
+			case FILE_OPMULTIPLY:
 				p->l *= m->mask;
 				break;
-			case OPDIVIDE:
+			case FILE_OPDIVIDE:
 				p->l /= m->mask;
 				break;
-			case OPMODULO:
+			case FILE_OPMODULO:
 				p->l %= m->mask;
 				break;
 			}
-		if (m->mask_op & OPINVERSE)
+		if (m->mask_op & FILE_OPINVERSE)
 			p->l = ~p->l;
 		return 1;
-	case LESHORT:
+	case FILE_LESHORT:
 		p->h = (short)((p->hs[1]<<8)|(p->hs[0]));
 		if (m->mask)
 			switch (m->mask_op&0x7F) {
-			case OPAND:
+			case FILE_OPAND:
 				p->h &= m->mask;
 				break;
-			case OPOR:
+			case FILE_OPOR:
 				p->h |= m->mask;
 				break;
-			case OPXOR:
+			case FILE_OPXOR:
 				p->h ^= m->mask;
 				break;
-			case OPADD:
+			case FILE_OPADD:
 				p->h += m->mask;
 				break;
-			case OPMINUS:
+			case FILE_OPMINUS:
 				p->h -= m->mask;
 				break;
-			case OPMULTIPLY:
+			case FILE_OPMULTIPLY:
 				p->h *= m->mask;
 				break;
-			case OPDIVIDE:
+			case FILE_OPDIVIDE:
 				p->h /= m->mask;
 				break;
-			case OPMODULO:
+			case FILE_OPMODULO:
 				p->h %= m->mask;
 				break;
 			}
-		if (m->mask_op & OPINVERSE)
+		if (m->mask_op & FILE_OPINVERSE)
 			p->h = ~p->h;
 		return 1;
-	case LELONG:
-	case LEDATE:
-	case LELDATE:
+	case FILE_LELONG:
+	case FILE_LEDATE:
+	case FILE_LELDATE:
 		p->l = (int32_t)
 		    ((p->hl[3]<<24)|(p->hl[2]<<16)|(p->hl[1]<<8)|(p->hl[0]));
 		if (m->mask)
 			switch (m->mask_op&0x7F) {
-			case OPAND:
+			case FILE_OPAND:
 				p->l &= m->mask;
 				break;
-			case OPOR:
+			case FILE_OPOR:
 				p->l |= m->mask;
 				break;
-			case OPXOR:
+			case FILE_OPXOR:
 				p->l ^= m->mask;
 				break;
-			case OPADD:
+			case FILE_OPADD:
 				p->l += m->mask;
 				break;
-			case OPMINUS:
+			case FILE_OPMINUS:
 				p->l -= m->mask;
 				break;
-			case OPMULTIPLY:
+			case FILE_OPMULTIPLY:
 				p->l *= m->mask;
 				break;
-			case OPDIVIDE:
+			case FILE_OPDIVIDE:
 				p->l /= m->mask;
 				break;
-			case OPMODULO:
+			case FILE_OPMODULO:
 				p->l %= m->mask;
 				break;
 			}
-		if (m->mask_op & OPINVERSE)
+		if (m->mask_op & FILE_OPINVERSE)
 			p->l = ~p->l;
 		return 1;
-	case REGEX:
+	case FILE_REGEX:
 		return 1;
 	default:
 		file_error(ms, "invalid type %d in mconvert()", m->type);
@@ -607,7 +607,7 @@ mget(struct magic_set *ms, union VALUETYPE *p, const unsigned char *s,
 {
 	int32_t offset = m->offset;
 
-	if (m->type == REGEX) {
+	if (m->type == FILE_REGEX) {
 		/*
 		 * offset is interpreted as last line to search,
 		 * (starting at 1), not as bytes-from start-of-file
@@ -643,215 +643,215 @@ mget(struct magic_set *ms, union VALUETYPE *p, const unsigned char *s,
 
 	if (m->flag & INDIR) {
 		switch (m->in_type) {
-		case BYTE:
+		case FILE_BYTE:
 			if (m->in_offset)
 				switch (m->in_op&0x7F) {
-				case OPAND:
+				case FILE_OPAND:
 					offset = p->b & m->in_offset;
 					break;
-				case OPOR:
+				case FILE_OPOR:
 					offset = p->b | m->in_offset;
 					break;
-				case OPXOR:
+				case FILE_OPXOR:
 					offset = p->b ^ m->in_offset;
 					break;
-				case OPADD:
+				case FILE_OPADD:
 					offset = p->b + m->in_offset;
 					break;
-				case OPMINUS:
+				case FILE_OPMINUS:
 					offset = p->b - m->in_offset;
 					break;
-				case OPMULTIPLY:
+				case FILE_OPMULTIPLY:
 					offset = p->b * m->in_offset;
 					break;
-				case OPDIVIDE:
+				case FILE_OPDIVIDE:
 					offset = p->b / m->in_offset;
 					break;
-				case OPMODULO:
+				case FILE_OPMODULO:
 					offset = p->b % m->in_offset;
 					break;
 				}
-			if (m->in_op & OPINVERSE)
+			if (m->in_op & FILE_OPINVERSE)
 				offset = ~offset;
 			break;
-		case BESHORT:
+		case FILE_BESHORT:
 			if (m->in_offset)
 				switch (m->in_op&0x7F) {
-				case OPAND:
+				case FILE_OPAND:
 					offset = (short)((p->hs[0]<<8)|
 							 (p->hs[1])) &
 						 m->in_offset;
 					break;
-				case OPOR:
+				case FILE_OPOR:
 					offset = (short)((p->hs[0]<<8)|
 							 (p->hs[1])) |
 						 m->in_offset;
 					break;
-				case OPXOR:
+				case FILE_OPXOR:
 					offset = (short)((p->hs[0]<<8)|
 							 (p->hs[1])) ^
 						 m->in_offset;
 					break;
-				case OPADD:
+				case FILE_OPADD:
 					offset = (short)((p->hs[0]<<8)|
 							 (p->hs[1])) +
 						 m->in_offset;
 					break;
-				case OPMINUS:
+				case FILE_OPMINUS:
 					offset = (short)((p->hs[0]<<8)|
 							 (p->hs[1])) -
 						 m->in_offset;
 					break;
-				case OPMULTIPLY:
+				case FILE_OPMULTIPLY:
 					offset = (short)((p->hs[0]<<8)|
 							 (p->hs[1])) *
 						 m->in_offset;
 					break;
-				case OPDIVIDE:
+				case FILE_OPDIVIDE:
 					offset = (short)((p->hs[0]<<8)|
 							 (p->hs[1])) /
 						 m->in_offset;
 					break;
-				case OPMODULO:
+				case FILE_OPMODULO:
 					offset = (short)((p->hs[0]<<8)|
 							 (p->hs[1])) %
 						 m->in_offset;
 					break;
 				}
-			if (m->in_op & OPINVERSE)
+			if (m->in_op & FILE_OPINVERSE)
 				offset = ~offset;
 			break;
-		case LESHORT:
+		case FILE_LESHORT:
 			if (m->in_offset)
 				switch (m->in_op&0x7F) {
-				case OPAND:
+				case FILE_OPAND:
 					offset = (short)((p->hs[1]<<8)|
 							 (p->hs[0])) &
 						 m->in_offset;
 					break;
-				case OPOR:
+				case FILE_OPOR:
 					offset = (short)((p->hs[1]<<8)|
 							 (p->hs[0])) |
 						 m->in_offset;
 					break;
-				case OPXOR:
+				case FILE_OPXOR:
 					offset = (short)((p->hs[1]<<8)|
 							 (p->hs[0])) ^
 						 m->in_offset;
 					break;
-				case OPADD:
+				case FILE_OPADD:
 					offset = (short)((p->hs[1]<<8)|
 							 (p->hs[0])) +
 						 m->in_offset;
 					break;
-				case OPMINUS:
+				case FILE_OPMINUS:
 					offset = (short)((p->hs[1]<<8)|
 							 (p->hs[0])) -
 						 m->in_offset;
 					break;
-				case OPMULTIPLY:
+				case FILE_OPMULTIPLY:
 					offset = (short)((p->hs[1]<<8)|
 							 (p->hs[0])) *
 						 m->in_offset;
 					break;
-				case OPDIVIDE:
+				case FILE_OPDIVIDE:
 					offset = (short)((p->hs[1]<<8)|
 							 (p->hs[0])) /
 						 m->in_offset;
 					break;
-				case OPMODULO:
+				case FILE_OPMODULO:
 					offset = (short)((p->hs[1]<<8)|
 							 (p->hs[0])) %
 						 m->in_offset;
 					break;
 				}
-			if (m->in_op & OPINVERSE)
+			if (m->in_op & FILE_OPINVERSE)
 				offset = ~offset;
 			break;
-		case SHORT:
+		case FILE_SHORT:
 			if (m->in_offset)
 				switch (m->in_op&0x7F) {
-				case OPAND:
+				case FILE_OPAND:
 					offset = p->h & m->in_offset;
 					break;
-				case OPOR:
+				case FILE_OPOR:
 					offset = p->h | m->in_offset;
 					break;
-				case OPXOR:
+				case FILE_OPXOR:
 					offset = p->h ^ m->in_offset;
 					break;
-				case OPADD:
+				case FILE_OPADD:
 					offset = p->h + m->in_offset;
 					break;
-				case OPMINUS:
+				case FILE_OPMINUS:
 					offset = p->h - m->in_offset;
 					break;
-				case OPMULTIPLY:
+				case FILE_OPMULTIPLY:
 					offset = p->h * m->in_offset;
 					break;
-				case OPDIVIDE:
+				case FILE_OPDIVIDE:
 					offset = p->h / m->in_offset;
 					break;
-				case OPMODULO:
+				case FILE_OPMODULO:
 					offset = p->h % m->in_offset;
 					break;
 				}
-			if (m->in_op & OPINVERSE)
+			if (m->in_op & FILE_OPINVERSE)
 				offset = ~offset;
 			break;
-		case BELONG:
+		case FILE_BELONG:
 			if (m->in_offset)
 				switch (m->in_op&0x7F) {
-				case OPAND:
+				case FILE_OPAND:
 					offset = (int32_t)((p->hl[0]<<24)|
 							 (p->hl[1]<<16)|
 							 (p->hl[2]<<8)|
 							 (p->hl[3])) &
 						 m->in_offset;
 					break;
-				case OPOR:
+				case FILE_OPOR:
 					offset = (int32_t)((p->hl[0]<<24)|
 							 (p->hl[1]<<16)|
 							 (p->hl[2]<<8)|
 							 (p->hl[3])) |
 						 m->in_offset;
 					break;
-				case OPXOR:
+				case FILE_OPXOR:
 					offset = (int32_t)((p->hl[0]<<24)|
 							 (p->hl[1]<<16)|
 							 (p->hl[2]<<8)|
 							 (p->hl[3])) ^
 						 m->in_offset;
 					break;
-				case OPADD:
+				case FILE_OPADD:
 					offset = (int32_t)((p->hl[0]<<24)|
 							 (p->hl[1]<<16)|
 							 (p->hl[2]<<8)|
 							 (p->hl[3])) +
 						 m->in_offset;
 					break;
-				case OPMINUS:
+				case FILE_OPMINUS:
 					offset = (int32_t)((p->hl[0]<<24)|
 							 (p->hl[1]<<16)|
 							 (p->hl[2]<<8)|
 							 (p->hl[3])) -
 						 m->in_offset;
 					break;
-				case OPMULTIPLY:
+				case FILE_OPMULTIPLY:
 					offset = (int32_t)((p->hl[0]<<24)|
 							 (p->hl[1]<<16)|
 							 (p->hl[2]<<8)|
 							 (p->hl[3])) *
 						 m->in_offset;
 					break;
-				case OPDIVIDE:
+				case FILE_OPDIVIDE:
 					offset = (int32_t)((p->hl[0]<<24)|
 							 (p->hl[1]<<16)|
 							 (p->hl[2]<<8)|
 							 (p->hl[3])) /
 						 m->in_offset;
 					break;
-				case OPMODULO:
+				case FILE_OPMODULO:
 					offset = (int32_t)((p->hl[0]<<24)|
 							 (p->hl[1]<<16)|
 							 (p->hl[2]<<8)|
@@ -859,62 +859,62 @@ mget(struct magic_set *ms, union VALUETYPE *p, const unsigned char *s,
 						 m->in_offset;
 					break;
 				}
-			if (m->in_op & OPINVERSE)
+			if (m->in_op & FILE_OPINVERSE)
 				offset = ~offset;
 			break;
-		case LELONG:
+		case FILE_LELONG:
 			if (m->in_offset)
 				switch (m->in_op&0x7F) {
-				case OPAND:
+				case FILE_OPAND:
 					offset = (int32_t)((p->hl[3]<<24)|
 							 (p->hl[2]<<16)|
 							 (p->hl[1]<<8)|
 							 (p->hl[0])) &
 						 m->in_offset;
 					break;
-				case OPOR:
+				case FILE_OPOR:
 					offset = (int32_t)((p->hl[3]<<24)|
 							 (p->hl[2]<<16)|
 							 (p->hl[1]<<8)|
 							 (p->hl[0])) |
 						 m->in_offset;
 					break;
-				case OPXOR:
+				case FILE_OPXOR:
 					offset = (int32_t)((p->hl[3]<<24)|
 							 (p->hl[2]<<16)|
 							 (p->hl[1]<<8)|
 							 (p->hl[0])) ^
 						 m->in_offset;
 					break;
-				case OPADD:
+				case FILE_OPADD:
 					offset = (int32_t)((p->hl[3]<<24)|
 							 (p->hl[2]<<16)|
 							 (p->hl[1]<<8)|
 							 (p->hl[0])) +
 						 m->in_offset;
 					break;
-				case OPMINUS:
+				case FILE_OPMINUS:
 					offset = (int32_t)((p->hl[3]<<24)|
 							 (p->hl[2]<<16)|
 							 (p->hl[1]<<8)|
 							 (p->hl[0])) -
 						 m->in_offset;
 					break;
-				case OPMULTIPLY:
+				case FILE_OPMULTIPLY:
 					offset = (int32_t)((p->hl[3]<<24)|
 							 (p->hl[2]<<16)|
 							 (p->hl[1]<<8)|
 							 (p->hl[0])) *
 						 m->in_offset;
 					break;
-				case OPDIVIDE:
+				case FILE_OPDIVIDE:
 					offset = (int32_t)((p->hl[3]<<24)|
 							 (p->hl[2]<<16)|
 							 (p->hl[1]<<8)|
 							 (p->hl[0])) /
 						 m->in_offset;
 					break;
-				case OPMODULO:
+				case FILE_OPMODULO:
 					offset = (int32_t)((p->hl[3]<<24)|
 							 (p->hl[2]<<16)|
 							 (p->hl[1]<<8)|
@@ -922,34 +922,34 @@ mget(struct magic_set *ms, union VALUETYPE *p, const unsigned char *s,
 						 m->in_offset;
 					break;
 				}
-			if (m->in_op & OPINVERSE)
+			if (m->in_op & FILE_OPINVERSE)
 				offset = ~offset;
 			break;
-		case LONG:
+		case FILE_LONG:
 			if (m->in_offset)
 				switch (m->in_op&0x7F) {
-				case OPAND:
+				case FILE_OPAND:
 					offset = p->l & m->in_offset;
 					break;
-				case OPOR:
+				case FILE_OPOR:
 					offset = p->l | m->in_offset;
 					break;
-				case OPXOR:
+				case FILE_OPXOR:
 					offset = p->l ^ m->in_offset;
 					break;
-				case OPADD:
+				case FILE_OPADD:
 					offset = p->l + m->in_offset;
 					break;
-				case OPMINUS:
+				case FILE_OPMINUS:
 					offset = p->l - m->in_offset;
 					break;
-				case OPMULTIPLY:
+				case FILE_OPMULTIPLY:
 					offset = p->l * m->in_offset;
 					break;
-				case OPDIVIDE:
+				case FILE_OPDIVIDE:
 					offset = p->l / m->in_offset;
 					break;
-				case OPMODULO:
+				case FILE_OPMODULO:
 					offset = p->l % m->in_offset;
 					break;
 			/*	case TOOMANYSWITCHBLOCKS:
@@ -960,7 +960,7 @@ mget(struct magic_set *ms, union VALUETYPE *p, const unsigned char *s,
 			 *		sleep;
 			 */
 				}
-			if (m->in_op & OPINVERSE)
+			if (m->in_op & FILE_OPINVERSE)
 				offset = ~offset;
 			break;
 		}
@@ -993,30 +993,30 @@ mcheck(struct magic_set *ms, union VALUETYPE *p, struct magic *m)
 
 
 	switch (m->type) {
-	case BYTE:
+	case FILE_BYTE:
 		v = p->b;
 		break;
 
-	case SHORT:
-	case BESHORT:
-	case LESHORT:
+	case FILE_SHORT:
+	case FILE_BESHORT:
+	case FILE_LESHORT:
 		v = p->h;
 		break;
 
-	case LONG:
-	case BELONG:
-	case LELONG:
-	case DATE:
-	case BEDATE:
-	case LEDATE:
-	case LDATE:
-	case BELDATE:
-	case LELDATE:
+	case FILE_LONG:
+	case FILE_BELONG:
+	case FILE_LELONG:
+	case FILE_DATE:
+	case FILE_BEDATE:
+	case FILE_LEDATE:
+	case FILE_LDATE:
+	case FILE_BELDATE:
+	case FILE_LELDATE:
 		v = p->l;
 		break;
 
-	case STRING:
-	case PSTRING:
+	case FILE_STRING:
+	case FILE_PSTRING:
 	{
 		/*
 		 * What we want here is:
@@ -1062,7 +1062,7 @@ mcheck(struct magic_set *ms, union VALUETYPE *p, struct magic *m)
 		}
 		break;
 	}
-	case REGEX:
+	case FILE_REGEX:
 	{
 		int rc;
 		regex_t rx;
@@ -1085,7 +1085,7 @@ mcheck(struct magic_set *ms, union VALUETYPE *p, struct magic *m)
 		return -1;
 	}
 
-	if(m->type != STRING && m->type != PSTRING)
+	if (m->type != FILE_STRING && m->type != FILE_PSTRING)
 		v = file_signextend(ms, m, v);
 
 	switch (m->reln) {