Собственно, вот.
class C
{
private class CFormat
{
[Flags]
private enum FormatFlags
{
None = 0,
LeftAlign = 1,
PlusSign = 2,
FirstZeros = 4,
Blank = 8,
LastZeros = 16
}
private struct NumberParameter
{
public bool Exist;
public int? Value;
}
private delegate object NextArg(Type expectedType);
private string result;
private Stack args;
public CFormat(string format, params object[] args)
{
this.args = new Stack();
for (int i = args.Length - 1; i >= 0; --i)
{
this.args.Push(args[i]);
}
Regex regex = new Regex(@"%(?<flag>[-+0 #]*)(?<width>\*|\d+)?(?<precision>\.\d*)?(?<size>[hlIw]|ll|I32|I64)?(?<type>[cCdiouxXeEfgGnpsS])");
this.result = regex.Replace(format, new MatchEvaluator(this.replace)).Replace("%%", "%");
}
public string Result
{
get
{
return this.result;
}
}
private object getNextArg(Type expectedType)
{
if (this.args.Count == 0)
{
throw new ArgumentOutOfRangeException();
}
object arg = this.args.Pop();
if (arg.GetType() != expectedType)
{
throw new InvalidCastException();
}
return arg;
}
private string replace(Match match)
{
FormatFlags flags = this.parseFlags(match.Groups["flag"].Value);
NumberParameter width = this.parseWidth(match.Groups["width"].Value, this.getNextArg);
NumberParameter precision = this.parsePrecision(match.Groups["precision"].Value);
string type = match.Groups["type"].Value;
object value = this.getNextArg(this.detectValueType(type, match.Groups["size"].Value));
string result = string.Empty;
switch (type)
{
case "i":
case "d":
Int64 intValue = Convert.ToInt64(value);
result = string.Format("{0:D}", Math.Abs(intValue));
string sign = string.Empty;
if (intValue >= 0)
{
if ((flags & FormatFlags.PlusSign) != 0)
{
sign = "+";
}
else if ((flags & FormatFlags.Blank) != 0)
{
sign = " ";
}
}
else
{
sign = "-";
}
int fieldSize = width.Value.HasValue ? width.Value.Value - (sign + result).Length : 0;
StringBuilder fieldBuilder = new StringBuilder();
char fieldChar =
(flags & FormatFlags.FirstZeros) != 0 && !precision.Exist && (flags & FormatFlags.LeftAlign) == 0
? '0' : ' ';
for(int i = 0; i < fieldSize; ++i)
{
fieldBuilder.Append(fieldChar);
}
string field = fieldBuilder.ToString();
if (field.Length > 0 && field[0] == '0')
{
result = sign + field + result;
}
else if ((flags & FormatFlags.LeftAlign) != 0)
{
result = sign + result + field;
}
else
{
result = field + sign + result;
}
break;
default:
throw new InvalidDataException();
}
return result;
}
private Type detectValueType(string type, string size)
{
switch (type)
{
case "i":
case "d":
switch (size)
{
case "h":
return typeof(short);
case "l":
return typeof(long);
case "ll":
case "I64":
return typeof(Int64);
case "I32":
return typeof(Int32);
default:
return typeof(int);
}
default:
return null;
}
}
private FormatFlags parseFlags(string flags)
{
FormatFlags result = FormatFlags.None;
foreach (char c in flags)
{
switch (c)
{
case '-':
result |= FormatFlags.LeftAlign;
break;
case '+':
result |= FormatFlags.PlusSign;
break;
case ' ':
result |= FormatFlags.Blank;
break;
case '0':
result |= FormatFlags.FirstZeros;
break;
case '#':
result |= FormatFlags.LastZeros;
break;
}
}
return result;
}
private NumberParameter parseNumberParameter(string numberParameter)
{
NumberParameter result = new NumberParameter();
result.Exist = numberParameter != string.Empty;
if(result.Exist)
{
result.Value = Convert.ToInt32(numberParameter);
}
else
{
result.Value = null;
}
return result;
}
private NumberParameter parseWidth(string width, NextArg getNextArg)
{
if (width == "*")
{
NumberParameter result = new NumberParameter();
result.Exist = true;
result.Value = Convert.ToInt32(getNextArg(typeof(int)));
return result;
}
else
{
return this.parseNumberParameter(width);
}
}
private NumberParameter parsePrecision(string precision)
{
bool isPoint = precision.Length > 0 && precision[0] == '.';
if (isPoint)
{
NumberParameter result = this.parseNumberParameter(precision.Substring(1));
result.Exist = true;
return result;
}
else
{
return this.parseNumberParameter(precision);
}
}
}
public static string sprintf(string format, params object[] args)
{
return new CFormat(format, args).Result;
}
public static void printf(string format, params object[] args)
{
Console.Write(C.sprintf(format, args));
}
public static void fprintf(Stream openedFile, string format, params object[] args)
{
new StreamWriter(openedFile).Write(C.sprintf(format, args));
}
}
Сделал универсальный и расширяемый анализатор, но из всех возможных значений типов терпения хватило только на целые числа. Остальное мне сейчас не надо, а нуждающиеся допишут сами.
Кто баги найдёт - пишите.
Ведёт оно себя строже, чем в C, в части контроля типов.
P.S. Добавил звёздочку (см. ниже).
