fix: ogg/vorbis file classification problems.

CVS patchset: 6038
CVS date: 2003/02/14 20:20:20

2 files changed, 916 insertions, 983 deletions

diff --git a/file/Magdir/vorbis b/file/Magdir/vorbis
index dab2c3b07..5e4084285 100644
--- a/file/Magdir/vorbis
+++ b/file/Magdir/vorbis
@@ -26,47 +26,47 @@
 >>>>39		ubyte		2		stereo,
 >>>>39		ubyte		>2		%u channels,
 >>>>40		lelong		x		%lu Hz
-## Minimal, nominal and maximal bitrates specified when encoding
-#>>>>48		string		<\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff	\b,
-## The above tests if at least one of these is specified:
-#>>>>>44		lelong		!-1
-## Vorbis RC2 has a bug which puts -1000 in the min/max bitrate fields
-## instead of -1.
-#>>>>>>44	lelong		!-1000
-#>>>>>>>44	lelong		x		>%lu
-#>>>>>48		lelong		!-1
-#>>>>>>48	lelong		x		~%lu
-#>>>>>52		lelong		!-1
-#>>>>>>52	lelong		!-1000
-#>>>>>>>52	lelong		x		<%lu
-#>>>>>48		string		<\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff	kbps
-## -- Second vorbis header packet - the comments
-## A kludge to read the vendor string.  It's a counted string, not a
-## zero-terminated one, so file(1) can't read it in a generic way.
-## libVorbis is the only one existing currently, so I detect specifically
-## it.  The interesting value is the cvs date (8 digits decimal).
-## Post-RC1 Ogg files have the second header packet (and thus the version)
-## in a different place, so we must use an indirect offset.
-#>>>(84.b+85)		string		\x03vorbis
-#>>>>(84.b+96)		string/c	Xiphophorus\ libVorbis\ I	\b, created by: Xiphophorus libVorbis I
-#>>>>>(84.b+120)		string		>00000000	%.8s
-## Map to beta version numbers:
-#>>>>>>(84.b+120)	string		<20000508	(<beta1 - prepublic)
-#>>>>>>(84.b+120)	string		20000508	(beta1/2)
-#>>>>>>(84.b+120)	string		>20000508
-#>>>>>>>(84.b+120)	string		<20001031	(beta2-3)
-#>>>>>>(84.b+120)	string		20001031	(beta3)
-#>>>>>>(84.b+120)	string		>20001031
-#>>>>>>>(84.b+120)	string		<20010225	(beta3-4)
-#>>>>>>(84.b+120)	string		20010225	(beta4)
-#>>>>>>(84.b+120)	string		>20010225
-#>>>>>>>(84.b+120)	string		<20010615	(beta4-RC1)
-#>>>>>>(84.b+120)	string		20010615	(RC1)
-#>>>>>>(84.b+120)	string		20010813	(RC2)
-#>>>>>>(84.b+120)	string		20010816	(RC2 - Garf tuned v1)
-#>>>>>>(84.b+120)	string		20011014	(RC2 - Garf tuned v2)
-#>>>>>>(84.b+120)	string		20011217	(pre-RC3 CVS)
-#>>>>>>(84.b+120)	string		20011231	(RC3)
+# Minimal, nominal and maximal bitrates specified when encoding
+>>>>48		string		<\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff	\b,
+# The above tests if at least one of these is specified:
+>>>>>44		lelong		!-1
+# Vorbis RC2 has a bug which puts -1000 in the min/max bitrate fields
+# instead of -1.
+>>>>>>44	lelong		!-1000
+>>>>>>>44	lelong		x		>%lu
+>>>>>48		lelong		!-1
+>>>>>>48	lelong		x		~%lu
+>>>>>52		lelong		!-1
+>>>>>>52	lelong		!-1000
+>>>>>>>52	lelong		x		<%lu
+>>>>>48		string		<\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff	kbps
+# -- Second vorbis header packet - the comments
+# A kludge to read the vendor string.  It's a counted string, not a
+# zero-terminated one, so file(1) can't read it in a generic way.
+# libVorbis is the only one existing currently, so I detect specifically
+# it.  The interesting value is the cvs date (8 digits decimal).
+# Post-RC1 Ogg files have the second header packet (and thus the version)
+# in a different place, so we must use an indirect offset.
+>>>(84.b+85)		string		\x03vorbis
+>>>>(84.b+96)		string/c	Xiphophorus\ libVorbis\ I	\b, created by: Xiphophorus libVorbis I
+>>>>>(84.b+120)		string		>00000000	%.8s
+# Map to beta version numbers:
+>>>>>>(84.b+120)	string		<20000508	(<beta1 - prepublic)
+>>>>>>(84.b+120)	string		20000508	(beta1/2)
+>>>>>>(84.b+120)	string		>20000508
+>>>>>>>(84.b+120)	string		<20001031	(beta2-3)
+>>>>>>(84.b+120)	string		20001031	(beta3)
+>>>>>>(84.b+120)	string		>20001031
+>>>>>>>(84.b+120)	string		<20010225	(beta3-4)
+>>>>>>(84.b+120)	string		20010225	(beta4)
+>>>>>>(84.b+120)	string		>20010225
+>>>>>>>(84.b+120)	string		<20010615	(beta4-RC1)
+>>>>>>(84.b+120)	string		20010615	(RC1)
+>>>>>>(84.b+120)	string		20010813	(RC2)
+>>>>>>(84.b+120)	string		20010816	(RC2 - Garf tuned v1)
+>>>>>>(84.b+120)	string		20011014	(RC2 - Garf tuned v2)
+>>>>>>(84.b+120)	string		20011217	(pre-RC3 CVS)
+>>>>>>(84.b+120)	string		20011231	(RC3)
 # The string has not changed from beta1 to 2 - they are indistinguishable.
 # Then come the comments, again length-counted (and number-counted).
 # Some looping constructs and registers would allow reading them but now
diff --git a/file/softmagic.c b/file/softmagic.c
index 5d1ef3bfb..9a420767d 100644
--- a/file/softmagic.c
+++ b/file/softmagic.c
@@ -39,83 +39,83 @@ fmagicSPrint(const fmagic fm, struct magic *m)
 	/*@globals fileSystem @*/
 	/*@modifies fm, fileSystem @*/
 {
-	union VALUETYPE * p = &fm->val;
-	uint32_t v;
-	int32_t t = 0;
+    union VALUETYPE * p = &fm->val;
+    uint32_t v;
+    int32_t t = 0;
 
-  	switch (m->type) {
-  	case BYTE:
-		v = signextend(m, p->b);
-		fmagicPrintf(fm, m->desc, (unsigned char) v);
+    switch (m->type) {
+    case BYTE:
+	v = signextend(m, p->b);
+	fmagicPrintf(fm, m->desc, (unsigned char) v);
 /*@-sizeoftype@*/
-		t = m->offset + sizeof(char);
+	t = m->offset + sizeof(char);
 /*@=sizeoftype@*/
-		break;
+	break;
 
-  	case SHORT:
-  	case BESHORT:
-  	case LESHORT:
-		v = signextend(m, p->h);
-		fmagicPrintf(fm, m->desc, (unsigned short) v);
+    case SHORT:
+    case BESHORT:
+    case LESHORT:
+	v = signextend(m, p->h);
+	fmagicPrintf(fm, m->desc, (unsigned short) v);
 /*@-sizeoftype@*/
-		t = m->offset + sizeof(short);
+	t = m->offset + sizeof(short);
 /*@=sizeoftype@*/
-		break;
+	break;
 
-  	case LONG:
-  	case BELONG:
-  	case LELONG:
-		v = signextend(m, p->l);
-		fmagicPrintf(fm, m->desc, (uint32_t) v);
+    case LONG:
+    case BELONG:
+    case LELONG:
+	v = signextend(m, p->l);
+	fmagicPrintf(fm, m->desc, (uint32_t) v);
 /*@-sizeoftype@*/
-		t = m->offset + sizeof(int32_t);
+	t = m->offset + sizeof(int32_t);
 /*@=sizeoftype@*/
-  		break;
+  	break;
 
-  	case STRING:
-  	case PSTRING:
-		if (m->reln == '=') {
-			fmagicPrintf(fm, m->desc, m->value.s);
-			t = m->offset + strlen(m->value.s);
-		}
-		else {
-			if (*m->value.s == '\0') {
-				char *cp = strchr(p->s,'\n');
-				if (cp != NULL)
-					*cp = '\0';
-			}
-			fmagicPrintf(fm, m->desc, p->s);
-			t = m->offset + strlen(p->s);
-		}
-		break;
+    case STRING:
+    case PSTRING:
+	if (m->reln == '=') {
+	    fmagicPrintf(fm, m->desc, m->value.s);
+	    t = m->offset + strlen(m->value.s);
+	} else {
+	    if (*m->value.s == '\0') {
+		char *cp = strchr(p->s,'\n');
+		if (cp != NULL)
+		    *cp = '\0';
+	    }
+	    fmagicPrintf(fm, m->desc, p->s);
+	    t = m->offset + strlen(p->s);
+	}
+	break;
 
-	case DATE:
-	case BEDATE:
-	case LEDATE:
-		fmagicPrintf(fm, m->desc, fmttime(p->l, 1));
+    case DATE:
+    case BEDATE:
+    case LEDATE:
+	fmagicPrintf(fm, m->desc, fmttime(p->l, 1));
 /*@-sizeoftype@*/
-		t = m->offset + sizeof(time_t);
+	t = m->offset + sizeof(time_t);
 /*@=sizeoftype@*/
-		break;
+	break;
 
-	case LDATE:
-	case BELDATE:
-	case LELDATE:
-		fmagicPrintf(fm, m->desc, fmttime(p->l, 0));
+    case LDATE:
+    case BELDATE:
+    case LELDATE:
+	fmagicPrintf(fm, m->desc, fmttime(p->l, 0));
 /*@-sizeoftype@*/
-		t = m->offset + sizeof(time_t);
+	t = m->offset + sizeof(time_t);
 /*@=sizeoftype@*/
-		break;
-	case REGEX:
-	  	fmagicPrintf(fm, m->desc, p->s);
-		t = m->offset + strlen(p->s);
-		break;
+	break;
 
-	default:
-		error(EXIT_FAILURE, 0, "invalid m->type (%d) in fmagicSPrint().\n", m->type);
-		/*@notreached@*/ break;
-	}
-	return(t);
+    case REGEX:
+  	fmagicPrintf(fm, m->desc, p->s);
+	t = m->offset + strlen(p->s);
+	break;
+
+    default:
+	error(EXIT_FAILURE, 0, "invalid m->type (%d) in fmagicSPrint().\n", m->type);
+	/*@notreached@*/ break;
+    }
+    return(t);
 }
 /*@=bounds@*/
 
@@ -130,270 +130,270 @@ fmagicSConvert(fmagic fm, struct magic *m)
 	/*@globals fileSystem @*/
 	/*@modifies fm, fileSystem @*/
 {
-	union VALUETYPE * p = &fm->val;
+    union VALUETYPE * p = &fm->val;
 
-	switch (m->type) {
-	case BYTE:
-		if (m->mask)
-			switch (m->mask_op&0x7F) {
-			case OPAND:
-				p->b &= m->mask;
-				/*@innerbreak@*/ break;
-			case OPOR:
-				p->b |= m->mask;
-				/*@innerbreak@*/ break;
-			case OPXOR:
-				p->b ^= m->mask;
-				/*@innerbreak@*/ break;
-			case OPADD:
-				p->b += m->mask;
-				/*@innerbreak@*/ break;
-			case OPMINUS:
-				p->b -= m->mask;
-				/*@innerbreak@*/ break;
-			case OPMULTIPLY:
-				p->b *= m->mask;
-				/*@innerbreak@*/ break;
-			case OPDIVIDE:
-				p->b /= m->mask;
-				/*@innerbreak@*/ break;
-			case OPMODULO:
-				p->b %= m->mask;
-				/*@innerbreak@*/ break;
-			}
-		if (m->mask_op & OPINVERSE)
-			p->b = ~p->b;
-		return 1;
-	case SHORT:
-		if (m->mask)
-			switch (m->mask_op&0x7F) {
-			case OPAND:
-				p->h &= m->mask;
-				/*@innerbreak@*/ break;
-			case OPOR:
-				p->h |= m->mask;
-				/*@innerbreak@*/ break;
-			case OPXOR:
-				p->h ^= m->mask;
-				/*@innerbreak@*/ break;
-			case OPADD:
-				p->h += m->mask;
-				/*@innerbreak@*/ break;
-			case OPMINUS:
-				p->h -= m->mask;
-				/*@innerbreak@*/ break;
-			case OPMULTIPLY:
-				p->h *= m->mask;
-				/*@innerbreak@*/ break;
-			case OPDIVIDE:
-				p->h /= m->mask;
-				/*@innerbreak@*/ break;
-			case OPMODULO:
-				p->h %= m->mask;
-				/*@innerbreak@*/ break;
-			}
-		if (m->mask_op & OPINVERSE)
-			p->h = ~p->h;
-		return 1;
-	case LONG:
-	case DATE:
-	case LDATE:
-		if (m->mask)
-			switch (m->mask_op&0x7F) {
-			case OPAND:
-				p->l &= m->mask;
-				/*@innerbreak@*/ break;
-			case OPOR:
-				p->l |= m->mask;
-				/*@innerbreak@*/ break;
-			case OPXOR:
-				p->l ^= m->mask;
-				/*@innerbreak@*/ break;
-			case OPADD:
-				p->l += m->mask;
-				/*@innerbreak@*/ break;
-			case OPMINUS:
-				p->l -= m->mask;
-				/*@innerbreak@*/ break;
-			case OPMULTIPLY:
-				p->l *= m->mask;
-				/*@innerbreak@*/ break;
-			case OPDIVIDE:
-				p->l /= m->mask;
-				/*@innerbreak@*/ break;
-			case OPMODULO:
-				p->l %= m->mask;
-				/*@innerbreak@*/ break;
-			}
-		if (m->mask_op & OPINVERSE)
-			p->l = ~p->l;
-		return 1;
-	case STRING:
-		{
-			int n;
+    switch (m->type) {
+    case BYTE:
+	if (m->mask)
+	    switch (m->mask_op&0x7F) {
+	    case OPAND:
+		p->b &= m->mask;
+		/*@innerbreak@*/ break;
+	    case OPOR:
+		p->b |= m->mask;
+		/*@innerbreak@*/ break;
+	    case OPXOR:
+		p->b ^= m->mask;
+		/*@innerbreak@*/ break;
+	    case OPADD:
+		p->b += m->mask;
+		/*@innerbreak@*/ break;
+	    case OPMINUS:
+		p->b -= m->mask;
+		/*@innerbreak@*/ break;
+	    case OPMULTIPLY:
+		p->b *= m->mask;
+		/*@innerbreak@*/ break;
+	    case OPDIVIDE:
+		p->b /= m->mask;
+		/*@innerbreak@*/ break;
+	    case OPMODULO:
+		p->b %= m->mask;
+		/*@innerbreak@*/ break;
+	    }
+	if (m->mask_op & OPINVERSE)
+	    p->b = ~p->b;
+	return 1;
+    case SHORT:
+	if (m->mask)
+	    switch (m->mask_op&0x7F) {
+	    case OPAND:
+		p->h &= m->mask;
+		/*@innerbreak@*/ break;
+	    case OPOR:
+		p->h |= m->mask;
+		/*@innerbreak@*/ break;
+	    case OPXOR:
+		p->h ^= m->mask;
+		/*@innerbreak@*/ break;
+	    case OPADD:
+		p->h += m->mask;
+		/*@innerbreak@*/ break;
+	    case OPMINUS:
+		p->h -= m->mask;
+		/*@innerbreak@*/ break;
+	    case OPMULTIPLY:
+		p->h *= m->mask;
+		/*@innerbreak@*/ break;
+	    case OPDIVIDE:
+		p->h /= m->mask;
+		/*@innerbreak@*/ break;
+	    case OPMODULO:
+		p->h %= m->mask;
+		/*@innerbreak@*/ break;
+	    }
+	if (m->mask_op & OPINVERSE)
+	    p->h = ~p->h;
+	return 1;
+    case LONG:
+    case DATE:
+    case LDATE:
+	if (m->mask)
+	    switch (m->mask_op&0x7F) {
+	    case OPAND:
+		p->l &= m->mask;
+		/*@innerbreak@*/ break;
+	    case OPOR:
+		p->l |= m->mask;
+		/*@innerbreak@*/ break;
+	    case OPXOR:
+		p->l ^= m->mask;
+		/*@innerbreak@*/ break;
+	    case OPADD:
+		p->l += m->mask;
+		/*@innerbreak@*/ break;
+	    case OPMINUS:
+		p->l -= m->mask;
+		/*@innerbreak@*/ break;
+	    case OPMULTIPLY:
+		p->l *= m->mask;
+		/*@innerbreak@*/ break;
+	    case OPDIVIDE:
+		p->l /= m->mask;
+		/*@innerbreak@*/ break;
+	    case OPMODULO:
+		p->l %= m->mask;
+		/*@innerbreak@*/ break;
+	    }
+	if (m->mask_op & OPINVERSE)
+	    p->l = ~p->l;
+	return 1;
+    case STRING:
+	{
+	    int n;
 
-			/* Null terminate and eat *trailing* return */
-			p->s[sizeof(p->s) - 1] = '\0';
-			n = strlen(p->s) - 1;
-			if (p->s[n] == '\n')
-				p->s[n] = '\0';
-			return 1;
-		}
-	case PSTRING:
-		{
-			char *ptr1 = p->s, *ptr2 = ptr1 + 1;
-			int n = *p->s;
-			if (n >= sizeof(p->s))
-				n = sizeof(p->s) - 1;
-			while (n--)
-				*ptr1++ = *ptr2++;
-			*ptr1 = '\0';
-			n = strlen(p->s) - 1;
-			if (p->s[n] == '\n')
-				p->s[n] = '\0';
-			return 1;
-		}
-	case BESHORT:
-		p->h = (short)((p->hs[0]<<8)|(p->hs[1]));
-		if (m->mask)
-			switch (m->mask_op&0x7F) {
-			case OPAND:
-				p->h &= m->mask;
-				/*@innerbreak@*/ break;
-			case OPOR:
-				p->h |= m->mask;
-				/*@innerbreak@*/ break;
-			case OPXOR:
-				p->h ^= m->mask;
-				/*@innerbreak@*/ break;
-			case OPADD:
-				p->h += m->mask;
-				/*@innerbreak@*/ break;
-			case OPMINUS:
-				p->h -= m->mask;
-				/*@innerbreak@*/ break;
-			case OPMULTIPLY:
-				p->h *= m->mask;
-				/*@innerbreak@*/ break;
-			case OPDIVIDE:
-				p->h /= m->mask;
-				/*@innerbreak@*/ break;
-			case OPMODULO:
-				p->h %= m->mask;
-				/*@innerbreak@*/ break;
-			}
-		if (m->mask_op & OPINVERSE)
-			p->h = ~p->h;
-		return 1;
-	case BELONG:
-	case BEDATE:
-	case 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:
-				p->l &= m->mask;
-				/*@innerbreak@*/ break;
-			case OPOR:
-				p->l |= m->mask;
-				/*@innerbreak@*/ break;
-			case OPXOR:
-				p->l ^= m->mask;
-				/*@innerbreak@*/ break;
-			case OPADD:
-				p->l += m->mask;
-				/*@innerbreak@*/ break;
-			case OPMINUS:
-				p->l -= m->mask;
-				/*@innerbreak@*/ break;
-			case OPMULTIPLY:
-				p->l *= m->mask;
-				/*@innerbreak@*/ break;
-			case OPDIVIDE:
-				p->l /= m->mask;
-				/*@innerbreak@*/ break;
-			case OPMODULO:
-				p->l %= m->mask;
-				/*@innerbreak@*/ break;
-			}
-		if (m->mask_op & OPINVERSE)
-			p->l = ~p->l;
-		return 1;
-	case LESHORT:
-		p->h = (short)((p->hs[1]<<8)|(p->hs[0]));
-		if (m->mask)
-			switch (m->mask_op&0x7F) {
-			case OPAND:
-				p->h &= m->mask;
-				/*@innerbreak@*/ break;
-			case OPOR:
-				p->h |= m->mask;
-				/*@innerbreak@*/ break;
-			case OPXOR:
-				p->h ^= m->mask;
-				/*@innerbreak@*/ break;
-			case OPADD:
-				p->h += m->mask;
-				/*@innerbreak@*/ break;
-			case OPMINUS:
-				p->h -= m->mask;
-				/*@innerbreak@*/ break;
-			case OPMULTIPLY:
-				p->h *= m->mask;
-				/*@innerbreak@*/ break;
-			case OPDIVIDE:
-				p->h /= m->mask;
-				/*@innerbreak@*/ break;
-			case OPMODULO:
-				p->h %= m->mask;
-				/*@innerbreak@*/ break;
-			}
-		if (m->mask_op & OPINVERSE)
-			p->h = ~p->h;
-		return 1;
-	case LELONG:
-	case LEDATE:
-	case 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:
-				p->l &= m->mask;
-				/*@innerbreak@*/ break;
-			case OPOR:
-				p->l |= m->mask;
-				/*@innerbreak@*/ break;
-			case OPXOR:
-				p->l ^= m->mask;
-				/*@innerbreak@*/ break;
-			case OPADD:
-				p->l += m->mask;
-				/*@innerbreak@*/ break;
-			case OPMINUS:
-				p->l -= m->mask;
-				/*@innerbreak@*/ break;
-			case OPMULTIPLY:
-				p->l *= m->mask;
-				/*@innerbreak@*/ break;
-			case OPDIVIDE:
-				p->l /= m->mask;
-				/*@innerbreak@*/ break;
-			case OPMODULO:
-				p->l %= m->mask;
-				/*@innerbreak@*/ break;
-			}
-		if (m->mask_op & OPINVERSE)
-			p->l = ~p->l;
-		return 1;
-	case REGEX:
-		return 1;
-	default:
-		error(EXIT_FAILURE, 0, "invalid type %d in fmagicSConvert().\n", m->type);
-		/*@notreached@*/
-		return 0;
+	    /* Null terminate and eat *trailing* return */
+	    p->s[sizeof(p->s) - 1] = '\0';
+	    n = strlen(p->s) - 1;
+	    if (p->s[n] == '\n')
+		p->s[n] = '\0';
+	    return 1;
+	}
+    case PSTRING:
+	{
+	    char *ptr1 = p->s, *ptr2 = ptr1 + 1;
+	    int n = *p->s;
+	    if (n >= sizeof(p->s))
+		n = sizeof(p->s) - 1;
+	    while (n--)
+		*ptr1++ = *ptr2++;
+	    *ptr1 = '\0';
+	    n = strlen(p->s) - 1;
+	    if (p->s[n] == '\n')
+		p->s[n] = '\0';
+	    return 1;
 	}
+    case BESHORT:
+	p->h = (short)((p->hs[0]<<8)|(p->hs[1]));
+	if (m->mask)
+	    switch (m->mask_op&0x7F) {
+	    case OPAND:
+		p->h &= m->mask;
+		/*@innerbreak@*/ break;
+	    case OPOR:
+		p->h |= m->mask;
+		/*@innerbreak@*/ break;
+	    case OPXOR:
+		p->h ^= m->mask;
+		/*@innerbreak@*/ break;
+	    case OPADD:
+		p->h += m->mask;
+		/*@innerbreak@*/ break;
+	    case OPMINUS:
+		p->h -= m->mask;
+		/*@innerbreak@*/ break;
+	    case OPMULTIPLY:
+		p->h *= m->mask;
+		/*@innerbreak@*/ break;
+	    case OPDIVIDE:
+		p->h /= m->mask;
+		/*@innerbreak@*/ break;
+	    case OPMODULO:
+		p->h %= m->mask;
+		/*@innerbreak@*/ break;
+	    }
+	if (m->mask_op & OPINVERSE)
+	    p->h = ~p->h;
+	return 1;
+    case BELONG:
+    case BEDATE:
+    case 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:
+		p->l &= m->mask;
+		/*@innerbreak@*/ break;
+	    case OPOR:
+		p->l |= m->mask;
+		/*@innerbreak@*/ break;
+	    case OPXOR:
+		p->l ^= m->mask;
+		/*@innerbreak@*/ break;
+	    case OPADD:
+		p->l += m->mask;
+		/*@innerbreak@*/ break;
+	    case OPMINUS:
+		p->l -= m->mask;
+		/*@innerbreak@*/ break;
+	    case OPMULTIPLY:
+		p->l *= m->mask;
+		/*@innerbreak@*/ break;
+	    case OPDIVIDE:
+		p->l /= m->mask;
+		/*@innerbreak@*/ break;
+	    case OPMODULO:
+		p->l %= m->mask;
+		/*@innerbreak@*/ break;
+	    }
+	if (m->mask_op & OPINVERSE)
+	    p->l = ~p->l;
+	return 1;
+    case LESHORT:
+	p->h = (short)((p->hs[1]<<8)|(p->hs[0]));
+	if (m->mask)
+	    switch (m->mask_op&0x7F) {
+	    case OPAND:
+		p->h &= m->mask;
+		/*@innerbreak@*/ break;
+	    case OPOR:
+		p->h |= m->mask;
+		/*@innerbreak@*/ break;
+	    case OPXOR:
+		p->h ^= m->mask;
+		/*@innerbreak@*/ break;
+	    case OPADD:
+		p->h += m->mask;
+		/*@innerbreak@*/ break;
+	    case OPMINUS:
+		p->h -= m->mask;
+		/*@innerbreak@*/ break;
+	    case OPMULTIPLY:
+		p->h *= m->mask;
+		/*@innerbreak@*/ break;
+	    case OPDIVIDE:
+		p->h /= m->mask;
+		/*@innerbreak@*/ break;
+	    case OPMODULO:
+		p->h %= m->mask;
+		/*@innerbreak@*/ break;
+	    }
+	if (m->mask_op & OPINVERSE)
+	    p->h = ~p->h;
+	return 1;
+    case LELONG:
+    case LEDATE:
+    case 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:
+		p->l &= m->mask;
+		/*@innerbreak@*/ break;
+	    case OPOR:
+		p->l |= m->mask;
+		/*@innerbreak@*/ break;
+	    case OPXOR:
+		p->l ^= m->mask;
+		/*@innerbreak@*/ break;
+	    case OPADD:
+		p->l += m->mask;
+		/*@innerbreak@*/ break;
+	    case OPMINUS:
+		p->l -= m->mask;
+		/*@innerbreak@*/ break;
+	    case OPMULTIPLY:
+		p->l *= m->mask;
+		/*@innerbreak@*/ break;
+	    case OPDIVIDE:
+		p->l /= m->mask;
+		/*@innerbreak@*/ break;
+	    case OPMODULO:
+		p->l %= m->mask;
+		/*@innerbreak@*/ break;
+	    }
+	if (m->mask_op & OPINVERSE)
+	    p->l = ~p->l;
+	return 1;
+    case REGEX:
+	return 1;
+    default:
+	error(EXIT_FAILURE, 0, "invalid type %d in fmagicSConvert().\n", m->type);
+	/*@notreached@*/
+	return 0;
+    }
 }
 /*@=bounds@*/
 
@@ -403,10 +403,10 @@ fmagicSDebug(int32_t offset, char *str, int len)
 	/*@globals fileSystem @*/
 	/*@modifies fileSystem @*/
 {
-	(void) fprintf(stderr, "fmagicSGet @%d: ", offset);
-	showstr(stderr, (char *) str, len);
-	(void) fputc('\n', stderr);
-	(void) fputc('\n', stderr);
+    (void) fprintf(stderr, "fmagicSGet @%d: ", offset);
+    showstr(stderr, (char *) str, len);
+    (void) fputc('\n', stderr);
+    (void) fputc('\n', stderr);
 }
 
 /*@-bounds@*/
@@ -415,384 +415,336 @@ fmagicSGet(fmagic fm, struct magic *m)
 	/*@globals fileSystem @*/
 	/*@modifies fm, fileSystem @*/
 {
-	unsigned char * buf = fm->buf;
-	int nb = fm->nb;
-	union VALUETYPE * p = &fm->val;
-	int32_t offset = m->offset;
+    unsigned char * buf = fm->buf;
+    int nb = fm->nb;
+    union VALUETYPE * p = &fm->val;
+    int32_t offset = m->offset;
 
 /*@-branchstate@*/
-	if (m->type == REGEX) {
-		/*
-		* offset is interpreted as last line to search,
-		* (starting at 1), not as bytes-from start-of-file
-		*/
-		char *last = NULL;
+    if (m->type == REGEX) {
+	/*
+	* offset is interpreted as last line to search,
+	* (starting at 1), not as bytes-from start-of-file
+	*/
+	char *last = NULL;
 /*@-temptrans@*/
-		p->buf = buf;
+	p->buf = buf;
 /*@=temptrans@*/
-		for (; offset && (buf = strchr(buf, '\n')) != NULL; offset--, buf++)
-			last = buf;
-		if (last != NULL)
-			*last = '\0';
-	} else if (offset + sizeof(*p) <= nb)
-		memcpy(p, buf + offset, sizeof(*p));
-	else {
-		/*
-		 * the usefulness of padding with zeroes eludes me, it
-		 * might even cause problems
-		 */
-		int32_t have = nb - offset;
-		memset(p, 0, sizeof(*p));
-		if (have > 0)
-			memcpy(p, buf + offset, have);
-	}
+	for (; offset && (buf = strchr(buf, '\n')) != NULL; offset--, buf++)
+	    last = buf;
+	if (last != NULL)
+	    *last = '\0';
+    } else if (offset + sizeof(*p) <= nb)
+	memcpy(p, buf + offset, sizeof(*p));
+    else {
+	/*
+	 * the usefulness of padding with zeroes eludes me, it
+	 * might even cause problems
+	 */
+	int32_t have = nb - offset;
+	memset(p, 0, sizeof(*p));
+	if (have > 0)
+	    memcpy(p, buf + offset, have);
+    }
 /*@=branchstate@*/
 
-	if (fm->flags & FMAGIC_FLAGS_DEBUG) {
-		fmagicSDebug(offset, (char *) p, sizeof(*p));
-		mdump(m);
-	}
+    if (fm->flags & FMAGIC_FLAGS_DEBUG) {
+	fmagicSDebug(offset, (char *) p, sizeof(*p));
+	mdump(m);
+    }
 
-	if (m->flag & INDIR) {
-		switch (m->in_type) {
-		case BYTE:
-			if (m->in_offset)
-				switch (m->in_op&0x7F) {
-				case OPAND:
-					offset = p->b & m->in_offset;
-					/*@innerbreak@*/ break;
-				case OPOR:
-					offset = p->b | m->in_offset;
-					/*@innerbreak@*/ break;
-				case OPXOR:
-					offset = p->b ^ m->in_offset;
-					/*@innerbreak@*/ break;
-				case OPADD:
-					offset = p->b + m->in_offset;
-					/*@innerbreak@*/ break;
-				case OPMINUS:
-					offset = p->b - m->in_offset;
-					/*@innerbreak@*/ break;
-				case OPMULTIPLY:
-					offset = p->b * m->in_offset;
-					/*@innerbreak@*/ break;
-				case OPDIVIDE:
-					offset = p->b / m->in_offset;
-					/*@innerbreak@*/ break;
-				case OPMODULO:
-					offset = p->b % m->in_offset;
-					/*@innerbreak@*/ break;
-				}
-			if (m->in_op & OPINVERSE)
-				offset = ~offset;
-			break;
-		case BESHORT:
-			if (m->in_offset)
-				switch (m->in_op&0x7F) {
-				case OPAND:
-					offset = (short)((p->hs[0]<<8)|
-							 (p->hs[1])) &
-						 m->in_offset;
-					/*@innerbreak@*/ break;
-				case OPOR:
-					offset = (short)((p->hs[0]<<8)|
-							 (p->hs[1])) |
-						 m->in_offset;
-					/*@innerbreak@*/ break;
-				case OPXOR:
-					offset = (short)((p->hs[0]<<8)|
-							 (p->hs[1])) ^
-						 m->in_offset;
-					/*@innerbreak@*/ break;
-				case OPADD:
-					offset = (short)((p->hs[0]<<8)|
-							 (p->hs[1])) +
-						 m->in_offset;
-					/*@innerbreak@*/ break;
-				case OPMINUS:
-					offset = (short)((p->hs[0]<<8)|
-							 (p->hs[1])) -
-						 m->in_offset;
-					/*@innerbreak@*/ break;
-				case OPMULTIPLY:
-					offset = (short)((p->hs[0]<<8)|
-							 (p->hs[1])) *
-						 m->in_offset;
-					/*@innerbreak@*/ break;
-				case OPDIVIDE:
-					offset = (short)((p->hs[0]<<8)|
-							 (p->hs[1])) /
-						 m->in_offset;
-					/*@innerbreak@*/ break;
-				case OPMODULO:
-					offset = (short)((p->hs[0]<<8)|
-							 (p->hs[1])) %
-						 m->in_offset;
-					/*@innerbreak@*/ break;
-				}
-			if (m->in_op & OPINVERSE)
-				offset = ~offset;
-			break;
-		case LESHORT:
-			if (m->in_offset)
-				switch (m->in_op&0x7F) {
-				case OPAND:
-					offset = (short)((p->hs[1]<<8)|
-							 (p->hs[0])) &
-						 m->in_offset;
-					/*@innerbreak@*/ break;
-				case OPOR:
-					offset = (short)((p->hs[1]<<8)|
-							 (p->hs[0])) |
-						 m->in_offset;
-					/*@innerbreak@*/ break;
-				case OPXOR:
-					offset = (short)((p->hs[1]<<8)|
-							 (p->hs[0])) ^
-						 m->in_offset;
-					/*@innerbreak@*/ break;
-				case OPADD:
-					offset = (short)((p->hs[1]<<8)|
-							 (p->hs[0])) +
-						 m->in_offset;
-					/*@innerbreak@*/ break;
-				case OPMINUS:
-					offset = (short)((p->hs[1]<<8)|
-							 (p->hs[0])) -
-						 m->in_offset;
-					/*@innerbreak@*/ break;
-				case OPMULTIPLY:
-					offset = (short)((p->hs[1]<<8)|
-							 (p->hs[0])) *
-						 m->in_offset;
-					/*@innerbreak@*/ break;
-				case OPDIVIDE:
-					offset = (short)((p->hs[1]<<8)|
-							 (p->hs[0])) /
-						 m->in_offset;
-					/*@innerbreak@*/ break;
-				case OPMODULO:
-					offset = (short)((p->hs[1]<<8)|
-							 (p->hs[0])) %
-						 m->in_offset;
-					/*@innerbreak@*/ break;
-				}
-			if (m->in_op & OPINVERSE)
-				offset = ~offset;
-			break;
-		case SHORT:
-			if (m->in_offset)
-				switch (m->in_op&0x7F) {
-				case OPAND:
-					offset = p->h & m->in_offset;
-					/*@innerbreak@*/ break;
-				case OPOR:
-					offset = p->h | m->in_offset;
-					/*@innerbreak@*/ break;
-				case OPXOR:
-					offset = p->h ^ m->in_offset;
-					/*@innerbreak@*/ break;
-				case OPADD:
-					offset = p->h + m->in_offset;
-					/*@innerbreak@*/ break;
-				case OPMINUS:
-					offset = p->h - m->in_offset;
-					/*@innerbreak@*/ break;
-				case OPMULTIPLY:
-					offset = p->h * m->in_offset;
-					/*@innerbreak@*/ break;
-				case OPDIVIDE:
-					offset = p->h / m->in_offset;
-					/*@innerbreak@*/ break;
-				case OPMODULO:
-					offset = p->h % m->in_offset;
-					/*@innerbreak@*/ break;
-				}
-			if (m->in_op & OPINVERSE)
-				offset = ~offset;
-			break;
-		case BELONG:
-			if (m->in_offset)
-				switch (m->in_op&0x7F) {
-				case OPAND:
-					offset = (int32_t)((p->hl[0]<<24)|
-							 (p->hl[1]<<16)|
-							 (p->hl[2]<<8)|
-							 (p->hl[3])) &
-						 m->in_offset;
-					/*@innerbreak@*/ break;
-				case OPOR:
-					offset = (int32_t)((p->hl[0]<<24)|
-							 (p->hl[1]<<16)|
-							 (p->hl[2]<<8)|
-							 (p->hl[3])) |
-						 m->in_offset;
-					/*@innerbreak@*/ break;
-				case OPXOR:
-					offset = (int32_t)((p->hl[0]<<24)|
-							 (p->hl[1]<<16)|
-							 (p->hl[2]<<8)|
-							 (p->hl[3])) ^
-						 m->in_offset;
-					/*@innerbreak@*/ break;
-				case OPADD:
-					offset = (int32_t)((p->hl[0]<<24)|
-							 (p->hl[1]<<16)|
-							 (p->hl[2]<<8)|
-							 (p->hl[3])) +
-						 m->in_offset;
-					/*@innerbreak@*/ break;
-				case OPMINUS:
-					offset = (int32_t)((p->hl[0]<<24)|
-							 (p->hl[1]<<16)|
-							 (p->hl[2]<<8)|
-							 (p->hl[3])) -
-						 m->in_offset;
-					/*@innerbreak@*/ break;
-				case OPMULTIPLY:
-					offset = (int32_t)((p->hl[0]<<24)|
-							 (p->hl[1]<<16)|
-							 (p->hl[2]<<8)|
-							 (p->hl[3])) *
-						 m->in_offset;
-					/*@innerbreak@*/ break;
-				case OPDIVIDE:
-					offset = (int32_t)((p->hl[0]<<24)|
-							 (p->hl[1]<<16)|
-							 (p->hl[2]<<8)|
-							 (p->hl[3])) /
-						 m->in_offset;
-					/*@innerbreak@*/ break;
-				case OPMODULO:
-					offset = (int32_t)((p->hl[0]<<24)|
-							 (p->hl[1]<<16)|
-							 (p->hl[2]<<8)|
-							 (p->hl[3])) %
-						 m->in_offset;
-					/*@innerbreak@*/ break;
-				}
-			if (m->in_op & OPINVERSE)
-				offset = ~offset;
-			break;
-		case LELONG:
-			if (m->in_offset)
-				switch (m->in_op&0x7F) {
-				case OPAND:
-					offset = (int32_t)((p->hl[3]<<24)|
-							 (p->hl[2]<<16)|
-							 (p->hl[1]<<8)|
-							 (p->hl[0])) &
-						 m->in_offset;
-					/*@innerbreak@*/ break;
-				case OPOR:
-					offset = (int32_t)((p->hl[3]<<24)|
-							 (p->hl[2]<<16)|
-							 (p->hl[1]<<8)|
-							 (p->hl[0])) |
-						 m->in_offset;
-					/*@innerbreak@*/ break;
-				case OPXOR:
-					offset = (int32_t)((p->hl[3]<<24)|
-							 (p->hl[2]<<16)|
-							 (p->hl[1]<<8)|
-							 (p->hl[0])) ^
-						 m->in_offset;
-					/*@innerbreak@*/ break;
-				case OPADD:
-					offset = (int32_t)((p->hl[3]<<24)|
-							 (p->hl[2]<<16)|
-							 (p->hl[1]<<8)|
-							 (p->hl[0])) +
-						 m->in_offset;
-					/*@innerbreak@*/ break;
-				case OPMINUS:
-					offset = (int32_t)((p->hl[3]<<24)|
-							 (p->hl[2]<<16)|
-							 (p->hl[1]<<8)|
-							 (p->hl[0])) -
-						 m->in_offset;
-					/*@innerbreak@*/ break;
-				case OPMULTIPLY:
-					offset = (int32_t)((p->hl[3]<<24)|
-							 (p->hl[2]<<16)|
-							 (p->hl[1]<<8)|
-							 (p->hl[0])) *
-						 m->in_offset;
-					/*@innerbreak@*/ break;
-				case OPDIVIDE:
-					offset = (int32_t)((p->hl[3]<<24)|
-							 (p->hl[2]<<16)|
-							 (p->hl[1]<<8)|
-							 (p->hl[0])) /
-						 m->in_offset;
-					/*@innerbreak@*/ break;
-				case OPMODULO:
-					offset = (int32_t)((p->hl[3]<<24)|
-							 (p->hl[2]<<16)|
-							 (p->hl[1]<<8)|
-							 (p->hl[0])) %
-						 m->in_offset;
-					/*@innerbreak@*/ break;
-				}
-			if (m->in_op & OPINVERSE)
-				offset = ~offset;
-			break;
-		case LONG:
-			if (m->in_offset)
-				switch (m->in_op&0x7F) {
-				case OPAND:
-					offset = p->l & m->in_offset;
-					/*@innerbreak@*/ break;
-				case OPOR:
-					offset = p->l | m->in_offset;
-					/*@innerbreak@*/ break;
-				case OPXOR:
-					offset = p->l ^ m->in_offset;
-					/*@innerbreak@*/ break;
-				case OPADD:
-					offset = p->l + m->in_offset;
-					/*@innerbreak@*/ break;
-				case OPMINUS:
-					offset = p->l - m->in_offset;
-					/*@innerbreak@*/ break;
-				case OPMULTIPLY:
-					offset = p->l * m->in_offset;
-					/*@innerbreak@*/ break;
-				case OPDIVIDE:
-					offset = p->l / m->in_offset;
-					/*@innerbreak@*/ break;
-				case OPMODULO:
-					offset = p->l % m->in_offset;
-					/*@innerbreak@*/ break;
-			/*	case TOOMANYSWITCHBLOCKS:
-			 *		ugh = p->eye % m->strain;
-			 *		rub;
-			 *	case BEER:
-			 *		off = p->tab & m->in_gest;
-			 *		sleep;
-			 */
-				}
-			if (m->in_op & OPINVERSE)
-				offset = ~offset;
-			break;
+    if (m->flag & INDIR) {
+	switch (m->in_type) {
+	case BYTE:
+	    if (m->in_offset)
+		switch (m->in_op&0x7F) {
+		case OPAND:
+		    offset = p->b & m->in_offset;
+		    /*@innerbreak@*/ break;
+		case OPOR:
+		    offset = p->b | m->in_offset;
+		    /*@innerbreak@*/ break;
+		case OPXOR:
+		    offset = p->b ^ m->in_offset;
+		    /*@innerbreak@*/ break;
+		case OPADD:
+		    offset = p->b + m->in_offset;
+		    /*@innerbreak@*/ break;
+		case OPMINUS:
+		    offset = p->b - m->in_offset;
+		    /*@innerbreak@*/ break;
+		case OPMULTIPLY:
+		    offset = p->b * m->in_offset;
+		    /*@innerbreak@*/ break;
+		case OPDIVIDE:
+		    offset = p->b / m->in_offset;
+		    /*@innerbreak@*/ break;
+		case OPMODULO:
+		    offset = p->b % m->in_offset;
+		    /*@innerbreak@*/ break;
+		}
+	    if (m->in_op & OPINVERSE)
+		offset = ~offset;
+	    break;
+	case BESHORT:
+	    if (m->in_offset)
+		switch (m->in_op&0x7F) {
+		case OPAND:
+		    offset = (short)((p->hs[0]<<8) | (p->hs[1])) &
+				 m->in_offset;
+		    /*@innerbreak@*/ break;
+		case OPOR:
+		    offset = (short)((p->hs[0]<<8) | (p->hs[1])) |
+				 m->in_offset;
+		    /*@innerbreak@*/ break;
+		case OPXOR:
+		    offset = (short)((p->hs[0]<<8) | (p->hs[1])) ^
+				 m->in_offset;
+		    /*@innerbreak@*/ break;
+		case OPADD:
+		    offset = (short)((p->hs[0]<<8) | (p->hs[1])) +
+				 m->in_offset;
+		    /*@innerbreak@*/ break;
+		case OPMINUS:
+		    offset = (short)((p->hs[0]<<8) | (p->hs[1])) -
+				 m->in_offset;
+		    /*@innerbreak@*/ break;
+		case OPMULTIPLY:
+		    offset = (short)((p->hs[0]<<8) | (p->hs[1])) *
+				 m->in_offset;
+		    /*@innerbreak@*/ break;
+		case OPDIVIDE:
+		    offset = (short)((p->hs[0]<<8) | (p->hs[1])) /
+				 m->in_offset;
+		    /*@innerbreak@*/ break;
+		case OPMODULO:
+		    offset = (short)((p->hs[0]<<8) | (p->hs[1])) %
+				 m->in_offset;
+		    /*@innerbreak@*/ break;
 		}
+	    if (m->in_op & OPINVERSE)
+		offset = ~offset;
+	    break;
+	case LESHORT:
+	    if (m->in_offset)
+		switch (m->in_op&0x7F) {
+		case OPAND:
+		    offset = (short)((p->hs[1]<<8) | (p->hs[0])) &
+				 m->in_offset;
+		    /*@innerbreak@*/ break;
+		case OPOR:
+		    offset = (short)((p->hs[1]<<8) | (p->hs[0])) |
+				 m->in_offset;
+		    /*@innerbreak@*/ break;
+		case OPXOR:
+		    offset = (short)((p->hs[1]<<8) | (p->hs[0])) ^
+				 m->in_offset;
+		    /*@innerbreak@*/ break;
+		case OPADD:
+		    offset = (short)((p->hs[1]<<8) | (p->hs[0])) +
+				 m->in_offset;
+		    /*@innerbreak@*/ break;
+		case OPMINUS:
+		    offset = (short)((p->hs[1]<<8) | (p->hs[0])) -
+				 m->in_offset;
+		    /*@innerbreak@*/ break;
+		case OPMULTIPLY:
+		    offset = (short)((p->hs[1]<<8) | (p->hs[0])) *
+				 m->in_offset;
+		    /*@innerbreak@*/ break;
+		case OPDIVIDE:
+		    offset = (short)((p->hs[1]<<8) | (p->hs[0])) /
+				 m->in_offset;
+		    /*@innerbreak@*/ break;
+		case OPMODULO:
+		    offset = (short)((p->hs[1]<<8) | (p->hs[0])) %
+				 m->in_offset;
+		    /*@innerbreak@*/ break;
+		}
+	    if (m->in_op & OPINVERSE)
+		offset = ~offset;
+	    break;
+	case SHORT:
+	    if (m->in_offset)
+		switch (m->in_op&0x7F) {
+		case OPAND:
+		    offset = p->h & m->in_offset;
+		    /*@innerbreak@*/ break;
+		case OPOR:
+		    offset = p->h | m->in_offset;
+		    /*@innerbreak@*/ break;
+		case OPXOR:
+		    offset = p->h ^ m->in_offset;
+		    /*@innerbreak@*/ break;
+		case OPADD:
+		    offset = p->h + m->in_offset;
+		    /*@innerbreak@*/ break;
+		case OPMINUS:
+		    offset = p->h - m->in_offset;
+		    /*@innerbreak@*/ break;
+		case OPMULTIPLY:
+		    offset = p->h * m->in_offset;
+		    /*@innerbreak@*/ break;
+		case OPDIVIDE:
+		    offset = p->h / m->in_offset;
+		    /*@innerbreak@*/ break;
+		case OPMODULO:
+		    offset = p->h % m->in_offset;
+		    /*@innerbreak@*/ break;
+		}
+	    if (m->in_op & OPINVERSE)
+		offset = ~offset;
+	    break;
+	case BELONG:
+	    if (m->in_offset)
+		switch (m->in_op&0x7F) {
+		case OPAND:
+		    offset = (int32_t)(	(p->hl[0]<<24) | (p->hl[1]<<16) |
+					(p->hl[2]<< 8) | (p->hl[3])) &
+				 m->in_offset;
+		    /*@innerbreak@*/ break;
+		case OPOR:
+		    offset = (int32_t)(	(p->hl[0]<<24) | (p->hl[1]<<16) |
+					(p->hl[2]<< 8) | (p->hl[3])) |
+				 m->in_offset;
+		    /*@innerbreak@*/ break;
+		case OPXOR:
+		    offset = (int32_t)(	(p->hl[0]<<24) | (p->hl[1]<<16) |
+					(p->hl[2]<< 8) | (p->hl[3])) ^
+				 m->in_offset;
+		    /*@innerbreak@*/ break;
+		case OPADD:
+		    offset = (int32_t)(	(p->hl[0]<<24) | (p->hl[1]<<16) |
+					(p->hl[2]<< 8) | (p->hl[3])) +
+				 m->in_offset;
+		    /*@innerbreak@*/ break;
+		case OPMINUS:
+		    offset = (int32_t)(	(p->hl[0]<<24) | (p->hl[1]<<16) |
+					(p->hl[2]<< 8) | (p->hl[3])) -
+				 m->in_offset;
+		    /*@innerbreak@*/ break;
+		case OPMULTIPLY:
+		    offset = (int32_t)(	(p->hl[0]<<24) | (p->hl[1]<<16) |
+					(p->hl[2]<< 8) | (p->hl[3])) *
+				 m->in_offset;
+		    /*@innerbreak@*/ break;
+		case OPDIVIDE:
+		    offset = (int32_t)(	(p->hl[0]<<24) | (p->hl[1]<<16) |
+					(p->hl[2]<< 8) | (p->hl[3])) /
+				 m->in_offset;
+		    /*@innerbreak@*/ break;
+		case OPMODULO:
+		    offset = (int32_t)(	(p->hl[0]<<24) | (p->hl[1]<<16) |
+					(p->hl[2]<< 8) | (p->hl[3])) %
+				 m->in_offset;
+		    /*@innerbreak@*/ break;
+		}
+	    if (m->in_op & OPINVERSE)
+		offset = ~offset;
+	    break;
+	case LELONG:
+	    if (m->in_offset)
+		switch (m->in_op&0x7F) {
+		case OPAND:
+		    offset = (int32_t)(	(p->hl[3]<<24) | (p->hl[2]<<16) |
+					(p->hl[1]<< 8) | (p->hl[0])) &
+				 m->in_offset;
+		    /*@innerbreak@*/ break;
+		case OPOR:
+		    offset = (int32_t)(	(p->hl[3]<<24) | (p->hl[2]<<16) |
+					(p->hl[1]<< 8) | (p->hl[0])) |
+				 m->in_offset;
+		    /*@innerbreak@*/ break;
+		case OPXOR:
+		    offset = (int32_t)(	(p->hl[3]<<24) | (p->hl[2]<<16) |
+					(p->hl[1]<< 8) | (p->hl[0])) ^
+				 m->in_offset;
+		    /*@innerbreak@*/ break;
+		case OPADD:
+		    offset = (int32_t)(	(p->hl[3]<<24) | (p->hl[2]<<16) |
+					(p->hl[1]<< 8) | (p->hl[0])) +
+				 m->in_offset;
+		    /*@innerbreak@*/ break;
+		case OPMINUS:
+		    offset = (int32_t)(	(p->hl[3]<<24) | (p->hl[2]<<16) |
+					(p->hl[1]<< 8) | (p->hl[0])) -
+				 m->in_offset;
+		    /*@innerbreak@*/ break;
+		case OPMULTIPLY:
+		    offset = (int32_t)(	(p->hl[3]<<24) | (p->hl[2]<<16) |
+					(p->hl[1]<< 8) | (p->hl[0])) *
+				 m->in_offset;
+		    /*@innerbreak@*/ break;
+		case OPDIVIDE:
+		    offset = (int32_t)(	(p->hl[3]<<24) | (p->hl[2]<<16) |
+					 (p->hl[1]<< 8) | (p->hl[0])) /
+				 m->in_offset;
+		    /*@innerbreak@*/ break;
+		case OPMODULO:
+		    offset = (int32_t)(	(p->hl[3]<<24) | (p->hl[2]<<16) |
+					(p->hl[1]<< 8) | (p->hl[0])) %
+				 m->in_offset;
+		    /*@innerbreak@*/ break;
+		}
+	    if (m->in_op & OPINVERSE)
+		offset = ~offset;
+	    break;
+	case LONG:
+	    if (m->in_offset)
+		switch (m->in_op&0x7F) {
+		case OPAND:
+		    offset = p->l & m->in_offset;
+		    /*@innerbreak@*/ break;
+		case OPOR:
+		    offset = p->l | m->in_offset;
+		    /*@innerbreak@*/ break;
+		case OPXOR:
+		    offset = p->l ^ m->in_offset;
+		    /*@innerbreak@*/ break;
+		case OPADD:
+		    offset = p->l + m->in_offset;
+		    /*@innerbreak@*/ break;
+		case OPMINUS:
+		    offset = p->l - m->in_offset;
+		    /*@innerbreak@*/ break;
+		case OPMULTIPLY:
+		    offset = p->l * m->in_offset;
+		    /*@innerbreak@*/ break;
+		case OPDIVIDE:
+		    offset = p->l / m->in_offset;
+		    /*@innerbreak@*/ break;
+		case OPMODULO:
+		    offset = p->l % m->in_offset;
+		    /*@innerbreak@*/ break;
+	    /*	case TOOMANYSWITCHBLOCKS:
+	     *	    ugh = p->eye % m->strain;
+	     *	    rub;
+	     *	case BEER:
+	     *	    off = p->tab & m->in_gest;
+	     *	    sleep;
+	     */
+		}
+	    if (m->in_op & OPINVERSE)
+		offset = ~offset;
+	    break;
+	}
 
 /*@-compmempass@*/
-		if (buf == NULL || offset + sizeof(*p) > nb)
-			return 0;
+	if (buf == NULL || offset + sizeof(*p) > nb)
+	    return 0;
 /*@=compmempass@*/
 
-		memcpy(p, buf + offset, sizeof(*p));
+	memcpy(p, buf + offset, sizeof(*p));
 
-		if (fm->flags & FMAGIC_FLAGS_DEBUG) {
-			fmagicSDebug(offset, (char *) p, sizeof(*p));
-			mdump(m);
-		}
+	if (fm->flags & FMAGIC_FLAGS_DEBUG) {
+	    fmagicSDebug(offset, (char *) p, sizeof(*p));
+	    mdump(m);
 	}
+    }
 /*@-compmempass@*/
-	if (!fmagicSConvert(fm, m))
-	  return 0;
-	return 1;
+    if (!fmagicSConvert(fm, m))
+	return 0;
+    return 1;
 /*@=compmempass@*/
 }
 /*@=bounds@*/
@@ -803,184 +755,177 @@ fmagicSCheck(const fmagic fm, struct magic *m)
 	/*@globals fileSystem @*/
 	/*@modifies fileSystem @*/
 {
-	union VALUETYPE * p = &fm->val;
-	uint32_t l = m->value.l;
-	uint32_t v = 0;
-	int matched;
+    union VALUETYPE * p = &fm->val;
+    uint32_t l = m->value.l;
+    uint32_t v = 0;
+    int matched;
 
-	if ( (m->value.s[0] == 'x') && (m->value.s[1] == '\0') ) {
-		fprintf(stderr, "BOINK");
-		return 1;
-	}
+    if ( (m->value.s[0] == 'x') && (m->value.s[1] == '\0') ) {
+	fprintf(stderr, "BOINK");
+	return 1;
+    }
 
-	switch (m->type) {
-	case BYTE:
-		v = p->b;
-		break;
+    switch (m->type) {
+    case BYTE:
+	v = p->b;
+	break;
 
-	case SHORT:
-	case BESHORT:
-	case LESHORT:
-		v = p->h;
-		break;
+    case SHORT:
+    case BESHORT:
+    case LESHORT:
+	v = p->h;
+	break;
 
-	case LONG:
-	case BELONG:
-	case LELONG:
-	case DATE:
-	case BEDATE:
-	case LEDATE:
-	case LDATE:
-	case BELDATE:
-	case LELDATE:
-		v = p->l;
-		break;
+    case LONG:
+    case BELONG:
+    case LELONG:
+    case DATE:
+    case BEDATE:
+    case LEDATE:
+    case LDATE:
+    case BELDATE:
+    case LELDATE:
+	v = p->l;
+	break;
 
-	case STRING:
-	case PSTRING:
-	{
-		/*
-		 * What we want here is:
-		 * v = strncmp(m->value.s, p->s, m->vallen);
-		 * but ignoring any nulls.  bcmp doesn't give -/+/0
-		 * and isn't universally available anyway.
-		 */
-		unsigned char *a = (unsigned char*)m->value.s;
-		unsigned char *b = (unsigned char*)p->s;
-		int len = m->vallen;
-		l = 0;
-		v = 0;
-		if (0L == m->mask) { /* normal string: do it fast */
-			while (--len >= 0)
-				if ((v = *b++ - *a++) != '\0')
-					/*@loopbreak@*/ break; 
-		} else { /* combine the others */
-			while (--len >= 0) {
-				if ((m->mask & STRING_IGNORE_LOWERCASE) &&
-				    islower(*a)) {
-					if ((v = tolower(*b++) - *a++) != '\0')
-						/*@loopbreak@*/ break;
-				} else if ((m->mask & STRING_COMPACT_BLANK) && 
-				    isspace(*a)) { 
-					a++;
-					if (isspace(*b++)) {
-						while (isspace(*b))
-							b++;
-					} else {
-						v = 1;
-						/*@loopbreak@*/ break;
-					}
-				} else if (isspace(*a) &&
-				    (m->mask & STRING_COMPACT_OPTIONAL_BLANK)) {
-					a++;
-					while (isspace(*b))
-						b++;
-				} else {
-					if ((v = *b++ - *a++) != '\0')
-						/*@loopbreak@*/ break;
-				}
-			}
-		}
-		break;
-	}
-	case REGEX:
-	{
-		int rc;
-		regex_t rx;
-		char errmsg[512];
-
-		rc = regcomp(&rx, m->value.s, REG_EXTENDED|REG_NOSUB);
-		if (rc) {
-			(void) regerror(rc, &rx, errmsg, sizeof(errmsg));
-			error(EXIT_FAILURE, 0, "regex error %d, (%s)\n", rc, errmsg);
-			/*@notreached@*/
+    case STRING:
+    case PSTRING:
+    {
+	/*
+	 * What we want here is:
+	 * v = strncmp(m->value.s, p->s, m->vallen);
+	 * but ignoring any nulls.  bcmp doesn't give -/+/0
+	 * and isn't universally available anyway.
+	 */
+	unsigned char *a = (unsigned char*)m->value.s;
+	unsigned char *b = (unsigned char*)p->s;
+	int len = m->vallen;
+	l = 0;
+	v = 0;
+	if (0L == m->mask) { /* normal string: do it fast */
+	    while (--len >= 0)
+		if ((v = *b++ - *a++) != '\0')
+		    /*@loopbreak@*/ break; 
+	} else { /* combine the others */
+	    while (--len >= 0) {
+		if ((m->mask & STRING_IGNORE_LOWERCASE) && islower(*a)) {
+		    if ((v = tolower(*b++) - *a++) != '\0')
+			/*@loopbreak@*/ break;
+		} else
+		if ((m->mask & STRING_COMPACT_BLANK) && isspace(*a)) { 
+		    a++;
+		    if (isspace(*b++)) {
+			while (isspace(*b))
+			    b++;
+		    } else {
+			v = 1;
+			/*@loopbreak@*/ break;
+		    }
+		} else
+		if (isspace(*a) && (m->mask & STRING_COMPACT_OPTIONAL_BLANK)) {
+		    a++;
+		    while (isspace(*b))
+			b++;
 		} else {
-			rc = regexec(&rx, p->buf, 0, NULL, 0);
-			return !rc;
+		    if ((v = *b++ - *a++) != '\0')
+			/*@loopbreak@*/ break;
 		}
+	    }
 	}
-		/*@notreached@*/ break;
-	default:
-		error(EXIT_FAILURE, 0, "invalid type %d in fmagicSCheck().\n", m->type);
-		/*@notreached@*/
-		return 0;
+	break;
+    }
+    case REGEX:
+    {
+	int rc;
+	regex_t rx;
+	char errmsg[512];
+
+	rc = regcomp(&rx, m->value.s, REG_EXTENDED|REG_NOSUB);
+	if (rc) {
+	    (void) regerror(rc, &rx, errmsg, sizeof(errmsg));
+	    error(EXIT_FAILURE, 0, "regex error %d, (%s)\n", rc, errmsg);
+	    /*@notreached@*/
+	} else {
+	    rc = regexec(&rx, p->buf, 0, NULL, 0);
+	    return !rc;
 	}
+    }
+	/*@notreached@*/ break;
+    default:
+	error(EXIT_FAILURE, 0, "invalid type %d in fmagicSCheck().\n", m->type);
+	/*@notreached@*/
+	return 0;
+    }
 
-	if(m->type != STRING && m->type != PSTRING)
-		v = signextend(m, v);
+    if(m->type != STRING && m->type != PSTRING)
+	v = signextend(m, v);
 
-	switch (m->reln) {
-	case 'x':
-		if (fm->flags & FMAGIC_FLAGS_DEBUG)
-			(void) fprintf(stderr, "%u == *any* = 1\n", v);
-		matched = 1;
-		break;
+    switch (m->reln) {
+    case 'x':
+	if (fm->flags & FMAGIC_FLAGS_DEBUG)
+	    (void) fprintf(stderr, "%u == *any* = 1\n", v);
+	matched = 1;
+	break;
 
-	case '!':
-		matched = v != l;
-		if (fm->flags & FMAGIC_FLAGS_DEBUG)
-			(void) fprintf(stderr, "%u != %u = %d\n",
-				       v, l, matched);
-		break;
+    case '!':
+	matched = v != l;
+	if (fm->flags & FMAGIC_FLAGS_DEBUG)
+	    (void) fprintf(stderr, "%u != %u = %d\n",
+			       v, l, matched);
+	break;
 
-	case '=':
-		matched = v == l;
-		if (fm->flags & FMAGIC_FLAGS_DEBUG)
-			(void) fprintf(stderr, "%u == %u = %d\n",
-				       v, l, matched);
-		break;
+    case '=':
+	matched = v == l;
+	if (fm->flags & FMAGIC_FLAGS_DEBUG)
+	    (void) fprintf(stderr, "%u == %u = %d\n",
+			       v, l, matched);
+	break;
 
-	case '>':
-		if (m->flag & UNSIGNED) {
-			matched = v > l;
-			if (fm->flags & FMAGIC_FLAGS_DEBUG)
-				(void) fprintf(stderr, "%u > %u = %d\n",
-					       v, l, matched);
-		}
-		else {
-			matched = (int32_t) v > (int32_t) l;
-			if (fm->flags & FMAGIC_FLAGS_DEBUG)
-				(void) fprintf(stderr, "%d > %d = %d\n",
-					       v, l, matched);
-		}
-		break;
+    case '>':
+	if (m->flag & UNSIGNED) {
+	    matched = v > l;
+	    if (fm->flags & FMAGIC_FLAGS_DEBUG)
+		(void) fprintf(stderr, "%u > %u = %d\n", v, l, matched);
+	}
+	else {
+	    matched = (int32_t) v > (int32_t) l;
+	    if (fm->flags & FMAGIC_FLAGS_DEBUG)
+		(void) fprintf(stderr, "%d > %d = %d\n", v, l, matched);
+	}
+	break;
 
-	case '<':
-		if (m->flag & UNSIGNED) {
-			matched = v < l;
-			if (fm->flags & FMAGIC_FLAGS_DEBUG)
-				(void) fprintf(stderr, "%u < %u = %d\n",
-					       v, l, matched);
-		}
-		else {
-			matched = (int32_t) v < (int32_t) l;
-			if (fm->flags & FMAGIC_FLAGS_DEBUG)
-				(void) fprintf(stderr, "%d < %d = %d\n",
-					       v, l, matched);
-		}
-		break;
+    case '<':
+	if (m->flag & UNSIGNED) {
+	    matched = v < l;
+	    if (fm->flags & FMAGIC_FLAGS_DEBUG)
+		(void) fprintf(stderr, "%u < %u = %d\n", v, l, matched);
+	}
+	else {
+	    matched = (int32_t) v < (int32_t) l;
+	    if (fm->flags & FMAGIC_FLAGS_DEBUG)
+		(void) fprintf(stderr, "%d < %d = %d\n", v, l, matched);
+	}
+	break;
 
-	case '&':
-		matched = (v & l) == l;
-		if (fm->flags & FMAGIC_FLAGS_DEBUG)
-			(void) fprintf(stderr, "((%x & %x) == %x) = %d\n",
-				       v, l, l, matched);
-		break;
+    case '&':
+	matched = (v & l) == l;
+	if (fm->flags & FMAGIC_FLAGS_DEBUG)
+	    (void) fprintf(stderr, "((%x & %x) == %x) = %d\n", v, l, l, matched);
+	break;
 
-	case '^':
-		matched = (v & l) != l;
-		if (fm->flags & FMAGIC_FLAGS_DEBUG)
-			(void) fprintf(stderr, "((%x & %x) != %x) = %d\n",
-				       v, l, l, matched);
-		break;
+    case '^':
+	matched = (v & l) != l;
+	if (fm->flags & FMAGIC_FLAGS_DEBUG)
+	    (void) fprintf(stderr, "((%x & %x) != %x) = %d\n", v, l, l, matched);
+	break;
 
-	default:
-		matched = 0;
-		error(EXIT_FAILURE, 0, "fmagicSCheck: can't happen: invalid relation %d.\n", m->reln);
-		/*@notreached@*/ break;
-	}
+    default:
+	matched = 0;
+	error(EXIT_FAILURE, 0, "fmagicSCheck: can't happen: invalid relation %d.\n", m->reln);
+	/*@notreached@*/ break;
+    }
 
-	return matched;
+    return matched;
 }
 /*@=bounds@*/
 
@@ -1017,104 +962,92 @@ fmagicSMatch(const fmagic fm)
 	/*@globals fileSystem @*/
 	/*@modifies fm, fileSystem @*/
 {
-	struct magic * m;
-	uint32_t nmagic = fm->ml->nmagic;
-	int cont_level = 0;
-	int need_separator = 0;
-	/*@only@*/
-	static int32_t * tmpoff = NULL;
-	static int tmpdelta = 64;
-	static size_t tmplen = 0;
-	int32_t oldoff = 0;
-	int firstline = 1; /* a flag to print X\n  X\n- X */
-	int ret = 0; /* if a match is found it is set to 1*/
-	int i;
+    struct magic * m;
+    uint32_t nmagic = fm->ml->nmagic;
+    int cont_level = 0;
+    int need_separator = 0;
+    /*@only@*/
+    static int32_t * tmpoff = NULL;
+    static int tmpdelta = 64;
+    static size_t tmplen = 0;
+    int32_t oldoff = 0;
+    int firstline = 1; /* a flag to print X\n  X\n- X */
+    int ret = 0; /* if a match is found it is set to 1*/
+    int i;
 
-	for (i = 0; i < nmagic; i++) {
-		m = &fm->ml->magic[i];
-		/* if main entry matches, print it... */
-		if (!fmagicSGet(fm, m) ||
-		    !fmagicSCheck(fm, m)) {
-			    /* 
-			     * main entry didn't match,
-			     * flush its continuations
-			     */
-			    while ((m+1)->cont_level != 0 && ++i < nmagic)
-				   m++;
-			    continue;
-		}
+    for (i = 0; i < nmagic; i++) {
+	m = &fm->ml->magic[i];
+	/* if main entry matches, print it... */
+	if (!fmagicSGet(fm, m) || !fmagicSCheck(fm, m)) {
+	    /* main entry didn't match, flush its continuations */
+	    while ((m+1)->cont_level != 0 && ++i < nmagic)
+		m++;
+	    continue;
+	}
 
-		if (! firstline) { /* we found another match */
-			/* put a newline and '-' to do some simple formatting */
-			fmagicPrintf(fm, "\n- ");
-		}
+	if (! firstline) { /* we found another match */
+	    /* put a newline and '-' to do some simple formatting */
+	    fmagicPrintf(fm, "\n- ");
+	}
+
+	if ((cont_level+1) >= tmplen) {
+	    tmplen += tmpdelta;
+	    tmpoff = xrealloc(tmpoff, tmplen * sizeof(*tmpoff));
+	}
+	tmpoff[cont_level] = fmagicSPrint(fm, m);
+	cont_level++;
 
+	/*
+	 * If we printed something, we'll need to print
+	 * a blank before we print something else.
+	 */
+	if (m->desc[0])
+	    need_separator = 1;
+
+	/* and any continuations that match */
+	while ((m+1)->cont_level != 0 && ++i < nmagic) {
+	    m++;
+	    if (cont_level < m->cont_level)
+		/*@innercontinue@*/ continue;
+	    if (cont_level > m->cont_level) {
+		/* We're at the end of the level "cont_level" continuations. */
+		cont_level = m->cont_level;
+	    }
+	    if (m->flag & OFFADD) {
+		oldoff = m->offset;
+		m->offset += tmpoff[cont_level-1];
+	    }
+	    if (fmagicSGet(fm, m) && fmagicSCheck(fm, m)) {
+		/*
+		 * This continuation matched.
+		 * Print its message, with a blank before it if the previous
+		 * item printed and this item isn't empty.
+		 */
+		/* space if previous printed */
+		if (need_separator
+		   && (m->nospflag == 0) && (m->desc[0] != '\0'))
+		{
+		    fmagicPrintf(fm, " ");
+		    need_separator = 0;
+		}
 		if ((cont_level+1) >= tmplen) {
-			tmplen += tmpdelta;
-			tmpoff = xrealloc(tmpoff, tmplen);
+		    tmplen += tmpdelta;
+		    tmpoff = xrealloc(tmpoff, tmplen * sizeof(*tmpoff));
 		}
 		tmpoff[cont_level] = fmagicSPrint(fm, m);
 		cont_level++;
-
-		/*
-		 * If we printed something, we'll need to print
-		 * a blank before we print something else.
-		 */
 		if (m->desc[0])
-			need_separator = 1;
-
-		/* and any continuations that match */
-		while ((m+1)->cont_level != 0 && ++i < nmagic) {
-			m++;
-			if (cont_level < m->cont_level)
-				/*@innercontinue@*/ continue;
-			if (cont_level > m->cont_level) {
-				/*
-				 * We're at the end of the level
-				 * "cont_level" continuations.
-				 */
-				cont_level = m->cont_level;
-			}
-			if (m->flag & OFFADD) {
-				oldoff = m->offset;
-				m->offset += tmpoff[cont_level-1];
-			}
-			if (fmagicSGet(fm, m) &&
-			    fmagicSCheck(fm, m))
-			{
-				/*
-				 * This continuation matched.
-				 * Print its message, with
-				 * a blank before it if
-				 * the previous item printed
-				 * and this item isn't empty.
-				 */
-				/* space if previous printed */
-				if (need_separator
-				   && (m->nospflag == 0)
-				   && (m->desc[0] != '\0')
-				   ) {
-					fmagicPrintf(fm, " ");
-					need_separator = 0;
-				}
-				if ((cont_level+1) >= tmplen) {
-					tmplen += tmpdelta;
-					tmpoff = xrealloc(tmpoff, tmplen);
-				}
-				tmpoff[cont_level] = fmagicSPrint(fm, m);
-				cont_level++;
-				if (m->desc[0])
-					need_separator = 1;
-			}
-			if (m->flag & OFFADD)
-				m->offset = oldoff;
-		}
-		firstline = 0;
-		ret = 1;
-		if (!(fm->flags & FMAGIC_FLAGS_CONTINUE))	/* don't keep searching */
-			return 1;
+		    need_separator = 1;
+	    }
+	    if (m->flag & OFFADD)
+		m->offset = oldoff;
 	}
-	return ret;	/* This is hit if -k is set or there is no match */
+	firstline = 0;
+	ret = 1;
+	if (!(fm->flags & FMAGIC_FLAGS_CONTINUE)) /* don't keep searching */
+	    return 1;
+    }
+    return ret;	/* This is hit if -k is set or there is no match */
 }
 /*@=bounds@*/
 
@@ -1127,16 +1060,16 @@ int
 fmagicS(fmagic fm)
 {
 /*@-branchstate@*/
-	if (fm->mlist != NULL)
-	for (fm->ml = fm->mlist->next; fm->ml != fm->mlist; fm->ml = fm->ml->next) {
+    if (fm->mlist != NULL)
+    for (fm->ml = fm->mlist->next; fm->ml != fm->mlist; fm->ml = fm->ml->next) {
 /*@-compmempass@*/
-		if (fmagicSMatch(fm))
-			return 1;
+	if (fmagicSMatch(fm))
+	    return 1;
 /*@=compmempass@*/
-	}
+    }
 /*@=branchstate@*/
 
 /*@-compmempass@*/
-	return 0;
+    return 0;
 /*@=compmempass@*/
 }