Pfthb

I want to write function for C#, which will be similar to sprintf(3) and vsnprintf(3) functions in C (or similar to "format" command in Tcl). Currently I have some success with it, but still have a few questions.

Below is the source code. Class "Format" contains few public functions, which accepts variable arguments list (but no more than 7 arguments, see below) and produce formatted string. This is analog of sprintf(3) function. Also function "format" may accept C# tuple, which should hold format string in first element, and arguments for format string in other elements -- this is analog of vsprintf(3) function.

Unfortunately, here I have two major limitations:

1) I can't pass more than seven arguments to format() function, because arguments passed in C# tuple, and tuple can't have more than eight elements (first element is format string itself, this is needed because empty tuples unavailable in C#). I hope to obtain some suggestions, how can I improve my format() function to avoid this limitation.

2) Another major limitation, that not all types can be passed to C# template. Especially, I can't pass pointers to format function (in this case I will got following error: "error CS0306: The type 'int*' may not be used as a type argument"). This is C# limitation? It's possible to rewrite format() function(s) to avoid this limitation?

Another major inconvenience, is that I should open some particular library name, and use C function name, which is different for different operation systems:

• for windows I should use "msvcrt.dll" and "_snprintf";




• for linux I should use "libc.so.6" and "snprintf";




• for linux on embedded platform C-library name might have different name...

It's possible to define which library should be opened at runtime, or extern functions marshalling might be determined only at compile time? So, I see two variants possible here:

1) I need produce different DLL's for different target platforms;

2) Or I can decide at runtime, which function name and libc-library should be used?

I not understood, how can I rewrite the code for first or second variant. Also it looks very inconvenient to have knowledge about libc name. Why just not call dlsym("snprintf") ?

Another question, I trying limit using of dynamic memory, but looks It's impossible to avoid allocating few String and StringBuilder classes on heap. This is looking scary, because when programming on C/C++ it's possible to do almost all work without dynamic memory allocation. May be somebody suggests me, how to improve format() functions to avoid dynamic memory allocation.

using System;
using System.Text;
using System.Runtime.InteropServices;
using System.Runtime.CompilerServices;

namespace FK0

 using Args = ITuple;

 public class Format
 
 // const string LIBC = "msvcrt.dll"; //"libc.so";
 // const string FUNC = "_snprintf";
 const string LIBC = "libc.so.6";
 const string FUNC = "snprintf";
 [DllImport(LIBC, EntryPoint=FUNC)] static private extern int snprintf(StringBuilder result, [MarshalAs(UnmanagedType.SysInt)] IntPtr size, StringBuilder format, [MarshalAs(UnmanagedType.I4)] int a1);
 [DllImport(LIBC, EntryPoint=FUNC)] static private extern int snprintf(StringBuilder result, [MarshalAs(UnmanagedType.SysInt)] IntPtr size, StringBuilder format, [MarshalAs(UnmanagedType.I8)] long a1);
 [DllImport(LIBC, EntryPoint=FUNC)] static private extern int snprintf(StringBuilder result, [MarshalAs(UnmanagedType.SysInt)] IntPtr size, StringBuilder format, double a1);
 [DllImport(LIBC, EntryPoint=FUNC)] static private extern int snprintf(StringBuilder result, [MarshalAs(UnmanagedType.SysInt)] IntPtr size, StringBuilder format, [MarshalAs(UnmanagedType.LPStr)]string a1);

 // function returns length of next format segment (string, copied as is, or single format spec.)
 static private int parse_format(string fmt, int pos)
 
 int p = fmt.IndexOf('%', pos);
 if (p == -1) return fmt.Length - pos; // copy to end of string
 else if (p != pos) return p - pos; // copy till %

 char fmt_term = 'd','i','o','u','x','X','e','E','f','F','g','G','a','A','c','s','p','n','%' ;
 int e = fmt.IndexOfAny(fmt_term, p + 1);
 if (e == -1) throw new System.ArgumentException("invalid format string");
 return e - p + 1; // format specifier length
 

 // call real `snprintf(3)' from C-library, marshal arguments appropriately
 static private int call_snprintf(ref StringBuilder res, int len, StringBuilder fmt, Object arg)
 arg is IntPtr) // XXX can't pass pointer to template!!!
 return snprintf(res, (IntPtr)len, fmt, ((IntPtr)arg).ToInt64());
 //else if (arg.GetType()
 else
 return snprintf(res, (IntPtr)len, fmt, Convert.ToInt32(arg));
 

 // vsnprintf-like function (accepts all arguments in tuple)
 static public string format(Args args)
 
 if (! (args[0] is string)) // check, that first argument is string
 throw new System.ArgumentException("wrong string format type");

 // first pass
 // compute number of arguments, size of output string and max size of formatted output
 string fmt = args[0].ToString();
 StringBuilder ns = null, fs = new StringBuilder();
 int total_len = 0, maxlen = 0, narg = 1;
 int pos = 0;
 while (pos < fmt.Length) 
 int len = parse_format(fmt, pos);
 if (fmt[pos] == '%') // pass format specifier to snprintf(3)
 fs.Clear(); fs.Append(fmt, pos, len);
 int flen = call_snprintf(ref ns, 0, fs, args[narg]);
 if (flen == -1) throw new System.ArgumentException("wrong format string");
 total_len += flen;
 if (flen > maxlen) maxlen = flen;
 narg++;
 
 else // compute size of literal part
 total_len += len;
 
 pos += len;
 

 if (narg != args.Length)
 throw new System.ArgumentException("incorrect # of arguments for format string");

 // second pass
 // print each argument separately
 var result = new StringBuilder(total_len);
 var part = new StringBuilder(maxlen + 1); // include terminating zero
 pos = 0; narg = 1;
 while (pos < fmt.Length) 
 int len = parse_format(fmt, pos);
 if (fmt[pos] == '%') // pass format specifier to snprintf(3)
 fs.Clear(); fs.Append(fmt, pos, len);
 call_snprintf(ref part, part.Capacity, fs, args[narg++]);
 result.Append(part);
 Console.WriteLine(part);
 
 else // copy literal part as is
 result.Append(fmt, pos, len);
 
 pos += len;
 

 return result.ToString();
 

 // C# have no vararg templates, as C++03, also max size of tuple limited to 8 elements,
 // also impossible to create empty tuple, so maximum number arguments limited to 7 (plus format string as 0-th element).

 static public string format<T1, T2, T3, T4, T5, T6, T7>(string fmt, T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6, T7 a7)
 
 return format(Tuple.Create(fmt, a1, a2, a3, a4, a5, a6, a7));
 

 static public string format<T1, T2, T3, T4, T5, T6>(string fmt, T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6)
 
 return format(Tuple.Create(fmt, a1, a2, a3, a4, a5, a6));
 

 static public string format<T1, T2, T3, T4, T5>(string fmt, T1 a1, T2 a2, T3 a3, T4 a4, T5 a5)
 
 return format(Tuple.Create(fmt, a1, a2, a3, a4, a5));
 

 static public string format<T1, T2, T3, T4>(string fmt, T1 a1, T2 a2, T3 a3, T4 a4)
 
 return format(Tuple.Create(fmt, a1, a2, a3, a4));
 

 static public string format<T1, T2, T3>(string fmt, T1 a1, T2 a2, T3 a3)
 
 return format(Tuple.Create(fmt, a1, a2, a3));
 

 static public string format<T1, T2>(string fmt, T1 a1, T2 a2)
 
 return format(Tuple.Create(fmt, a1, a2));
 

 static public string format<T1>(string fmt, T1 a1)
 
 return format(Tuple.Create(fmt, a1));
 

 static public string format(string fmt)
 
 return format(Tuple.Create(fmt));
 
 ;


public class Program

 unsafe public static void Main()
 
 // System.Threading.Thread.Sleep(100000);
 int z = 123;
 int* y = &z;
 IntPtr v = (IntPtr)y;
 string s = FK0.Format.format("%p %d %d", v, *y, z);
 Console.WriteLine(s);
 

Using the C# params parameter modifier, you can have the arguments to a method passed as an array:

public static string format(string format, params object args) 
 var n = 0;
 return String.Format(format.Replace(new Regex(@"%[+-0-9.]*[a-z]"), m => $"n++"), args);

Now you can call it like:

Console.WriteLine(Format.format("test: %s %x", "this", 23));

Of course, this version of format just dumps all arguments in their default format, you would need to process each format specifier in a real implementation.