Implicit enum conversions are a stupid PITA

[Adam D. Ruppe]

On Thu, Mar 25, 2010 at 04:52:29PM -0500, Andrei Alexandrescu wrote:
> It does work well, but there's one more issue: the type of octal!x is 
> always ulong. To make the code industrial strength, you should observe 
> the usual D rules:

I think I made it work. Also used template constraints to pretty up the
error messages a little on bad strings. The line number is still that of
the template instead of the instantiation, but maybe it is just because
my dmd is a few months old. I seem to recall seeing this improved in the
compiler itself, so I'm not worrying about it here.

The code is way at the bottom of this message. I'm going to show off a bit
first :)


Error messages:

int w = octal!845;
octal.d(106): Error: static assert  "845 is not a valid octal literal"

int w = octal!"spam";
octal.d(106): Error: static assert  "spam is not a valid octal literal"



The type magic works pretty well too:

int w = octal!"017777777777"; // compiles
int w = octal!"020000000000"; // but this doesn't... (this is int.max+1 btw)
octal.d(147): Error: cannot implicitly convert expression (octal()) of type long to int

int w = octal!"1L";
octal.d(147): Error: cannot implicitly convert expression (octal()) of type long to int

int w = octal!"1uL";
octal.d(147): Error: cannot implicitly convert expression (octal()) of type ulong to int

This also works with integer literals instead of strings:
	auto w = octal!1L;
	pragma(msg, typeof(w)); // prints "long"
	auto w = octal!1;
	pragma(msg, typeof(w)); // prints "int"
	auto w = octal!1u;
	pragma(msg, typeof(w)); // prints "uint"


The only bug I'm seeing is if the integer literal is type long,
but once converted to octal it will fit in an int, the template returns a
long. Passing a string does the right thing and returns int, but the literal
doesn't.

I don't see a way to fix this without breaking the octal!1777[...]7L case.
(To make the suffixes on literals work, I did typeof an alias for the helper
template instead of analyzing the string like I did for the main template.
I couldn't think of any other way to make it work; I even tried parsing
stringof the alias, but alas.


Anyway, aside from that, it works perfectly in my battery of tests. Handles
suffixes, embedded underscores, bad strings, types. Pretty cool.



Here's the code, with some comments added too:

===============================

/*
	Take a look at int.max and int.max+1 in octal and the logic for this function follows directly.
*/
template octalFitsInInt(string octalNum) {
	// note it is important to strip the literal of all non-numbers. kill the suffix and underscores
	// lest they mess up the number of digits here that we depend on.
	static if(strippedOctalLiteral(octalNum).length < 11)
		enum bool octalFitsInInt = true;
	else static if(strippedOctalLiteral(octalNum).length == 11 && strippedOctalLiteral(octalNum)[0] == '1')
		enum bool octalFitsInInt = true;
	else
		enum bool octalFitsInInt = false;
}

string strippedOctalLiteral(string original) {
	string stripped = "";
	foreach(c; original)
		if(c >= '0' && c <= '7')
			stripped ~= c;
	return stripped;
}

template literalIsLong(string num) {
	static if(num.length > 1)
		enum literalIsLong = (num[$-1] == 'L' || num[$-2] == 'L'); // can be xxL or xxLu according to spec
	else
		enum literalIsLong = false;
}

template literalIsUnsigned(string num) {
	static if(num.length > 1)
		enum literalIsUnsigned = (num[$-1] == 'u' || num[$-2] == 'u') // can be xxL or xxLu according to spec
		   || (num[$-1] == 'U' || num[$-2] == 'U'); // both cases are allowed too
	else
		enum literalIsUnsigned = false;
}

/**
	These pass out the correctly typed literal based on the specifiers on the end of the string
	and the size of the literal.

	If it can fit in an int, it is an int. Otherwise, it is a long.

	But, if the user specifically asks for a long with the L suffix, always give the long.

	Give an unsigned iff it is asked for with the U or u suffix.
*/

int octal(string num)() if((octalFitsInInt!(num) && !literalIsLong!(num)) && !literalIsUnsigned!(num)) {
	return octal!(int, num);
}

long octal(string num)() if((!octalFitsInInt!(num) || literalIsLong!(num)) && !literalIsUnsigned!(num)) {
	return octal!(long, num);
}

uint octal(string num)() if((octalFitsInInt!(num) && !literalIsLong!(num)) && literalIsUnsigned!(num)) {
	return octal!(int, num);
}

ulong octal(string num)() if((!octalFitsInInt!(num) || literalIsLong!(num)) && literalIsUnsigned!(num)) {
	return octal!(long, num);
}

/*
	Returns if the given string is a correctly formatted octal literal.

	The format is specified in lex.html. The leading zero is allowed, but not required.
*/
bool isOctalLiteralString(string num) {
	if(num.length == 0)
		return false;

	// must start with a number
	if(num[0] < '0' || num[0] > '7')
		return false;
	
	foreach(i, c; num) {
		if((c < '0' || c > '7') && c != '_') // not a legal character
			if(i < num.length - 2)
				return false;
			else { // gotta check for those suffixes
				if(c != 'U' && c != 'u' && c != 'L')
					return false;
				if(i != num.length - 1) { // if we're not the last one, the next one must also be a suffix to be valid
					char c2 = num[$-1];
					if(c2 != 'U' && c2 != 'u' && c2 != 'L')
						return false; // spam at the end of the string
					if(c2 == c)
						return false; // repeats are disallowed
				}
			}
	}

	return true;
}

/*
	Returns true if the given compile time string is an octal literal.
*/
template isOctalLiteral(string num) {
	enum bool isOctalLiteral = isOctalLiteralString(num);
}

/*
	Takes a string, num, which is an octal literal, and returns its value, in the
	type T specified.

	So:

	int a = octal!(int, "10");

	assert(a == 8);
*/
T octal(T, string num)() {
    static assert(isOctalLiteral!num, num ~ " is not a valid octal literal");

    ulong pow = 1;
    T value = 0;

    for(int pos = num.length - 1; pos >= 0; pos--) {
        char s = num[pos];
	if(s < '0' || s > '7') // we only care about digits; skip the rest
		continue; // safe to skip - this is checked out in the assert so these are just suffixes
	
	value += pow * (s - '0');
	pow *= 8;
  }

  return value;
}

import std.metastrings: toStringNow;
import std.traits: isIntegral;

/**
	Constructs an octal literal from a number, maintaining the type of the original number.
	For example:

	octal!10
	
	is exactly the same as integer literal 8.

	octal!10U

	is identical to the literal 8U.
*/
template octal(alias s) if(isIntegral!(typeof(s))) {
	enum auto octal = octal!(typeof(s), toStringNow!(s));
}

unittest
{

	// ensure that you get the right types, even with embedded underscores
	auto w = octal!"100_000_000_000";
	static assert(!is(typeof(w) == int));
	auto w2 = octal!"1_000_000_000";
	static assert(is(typeof(w2) == int));

    static assert(octal!"45" == 37);
    static assert(octal!"0" == 0);
    static assert(octal!"7" == 7);
    static assert(octal!"10" == 8);
    static assert(octal!"666" == 438);

    static assert(octal!45 == 37);
    static assert(octal!0 == 0);
    static assert(octal!7 == 7);
    static assert(octal!10 == 8);
    static assert(octal!666 == 438);

    static assert(octal!"66_6" == 438);

    static assert(octal!2520046213 == 356535435);
    static assert(octal!"2520046213" == 356535435);

    static assert(octal!17777777777 == int.max);

    static assert(!__traits(compiles, octal!823));
//    static assert(!__traits(compiles, octal!"823")); // for some reason, this line fails, though if you try it in code, it indeed doesn't compile... weird.
    static assert(!__traits(compiles, octal!"_823"));
    static assert(!__traits(compiles, octal!"spam"));
    static assert(!__traits(compiles, octal!"77%"));

    int a;
    long b;

    static assert(__traits(compiles,  a = octal!"17777777777")); // biggest value that should fit in an it
    static assert(!__traits(compiles, a = octal!"20000000000")); // should not fit in the int
    static assert(__traits(compiles, b = octal!"20000000000")); // ... but should fit in a long

   static assert(!__traits(compiles, a = octal!"1L"));
   //static assert(!__traits(compiles, a = octal!1L)); // this should pass, but it doesn't, since the int converter doesn't pass along its suffix to helper templates

   static assert(__traits(compiles, b = octal!"1L"));
   static assert(__traits(compiles, b = octal!1L));
}

===============================

-- 
Adam D. Ruppe
http://arsdnet.net