console.d

   1 // WARNING! thread-unsafe!
   2 module console is aliced;
   3
   4 public import conwrt;
   5
   6 private:
   7 import std.traits;
   8 import conwrt;
   9
  10
  11 // ////////////////////////////////////////////////////////////////////////// //
  12 public class ConCommand {
  13 private:
  14   public import std.conv : ConvException, ConvOverflowException;
  15   import std.range;
  16   // this is hack to avoid allocating error exceptions
  17   // don't do this at home!
  18
  19   __gshared ConvException exBadNum;
  20   __gshared ConvException exBadStr;
  21   __gshared ConvException exBadBool;
  22   __gshared ConvException exBadInt;
  23   __gshared ConvOverflowException exIntOverflow;
  24   __gshared ConvException exBadHexEsc;
  25   __gshared ConvException exBadEscChar;
  26   __gshared ConvException exNoArg;
  27   __gshared ConvException exTooManyArgs;
  28   __gshared ConvException exBadArgType;
  29
  30   shared static this () {
  31     exBadNum = new ConvException("invalid number");
  32     exBadStr = new ConvException("invalid string");
  33     exBadBool = new ConvException("invalid boolean");
  34     exBadInt = new ConvException("invalid integer number");
  35     exIntOverflow = new ConvOverflowException("overflow in integral conversion");
  36     exBadHexEsc = new ConvException("invalid hex escape");
  37     exBadEscChar = new ConvException("invalid escape char");
  38     exNoArg = new ConvException("argument expected");
  39     exTooManyArgs = new ConvException("too many arguments");
  40     exBadArgType = new ConvException("can't parse given argument type (internal error)");
  41   }
  42
  43 private:
  44   __gshared char[] wordBuf;
  45
  46 public:
  47   string name;
  48   string help;
  49
  50   this (string aname, string ahelp=null) { name = aname; help = ahelp; }
  51
  52   void showHelp () { conwriteln(name, " -- ", help); }
  53
  54   // can throw, yep
  55   // cmdline doesn't contain command name
  56   void exec (const(char)[] cmdline) {
  57     auto w = getWord(cmdline);
  58     if (w == "?") showHelp;
  59   }
  60
  61 protected:
  62 static:
  63   int digit(TC) (TC ch, uint base) pure nothrow @safe @nogc if (isSomeChar!TC) {
  64     int res = void;
  65          if (ch >= '0' && ch <= '9') res = ch-'0';
  66     else if (ch >= 'A' && ch <= 'Z') res = ch-'A'+10;
  67     else if (ch >= 'a' && ch <= 'z') res = ch-'a'+10;
  68     else return -1;
  69     return (res >= base ? -1 : res);
  70   }
  71
  72   // get word from command line
  73   // note that next call to `getWord()` can destroy result
  74   // returns `null` if there are no more words
  75   // `*strtemp` will be `true` if temporary string storage was used
  76   const(char)[] getWord (ref const(char)[] s, bool *strtemp=null) {
  77     if (strtemp !is null) *strtemp = false;
  78     usize pos;
  79     while (s.length > 0 && s.ptr[0] <= ' ') s = s[1..$];
  80     if (s.length == 0) return null;
  81     // quoted string?
  82     if (s.ptr[0] == '"' || s.ptr[0] == '\'') {
  83       char qch = s.ptr[0];
  84       s = s[1..$];
  85       pos = 0;
  86       bool hasSpecial = false;
  87       while (pos < s.length && s.ptr[pos] != qch) {
  88         if (s.ptr[pos] == '\\') { hasSpecial = true; break; }
  89         ++pos;
  90       }
  91       // simple quoted string?
  92       if (!hasSpecial) {
  93         auto res = s[0..pos];
  94         if (pos < s.length) ++pos; // skip closing quote
  95         s = s[pos..$];
  96         return res;
  97       }
  98       if (strtemp !is null) *strtemp = true;
  99       wordBuf.assumeSafeAppend.length = pos;
 100       if (pos) wordBuf[0..pos] = s[0..pos];
 101       // process special chars
 102       while (pos < s.length && s.ptr[pos] != qch) {
 103         if (s.ptr[pos] == '\\' && s.length-pos > 1) {
 104           ++pos;
 105           switch (s.ptr[pos++]) {
 106             case '"': case '\'': case '\\': wordBuf ~= s.ptr[pos-1]; break;
 107             case '0': wordBuf ~= '\x00'; break;
 108             case 'a': wordBuf ~= '\a'; break;
 109             case 'b': wordBuf ~= '\b'; break;
 110             case 'e': wordBuf ~= '\x1b'; break;
 111             case 'f': wordBuf ~= '\f'; break;
 112             case 'n': wordBuf ~= '\n'; break;
 113             case 'r': wordBuf ~= '\r'; break;
 114             case 't': wordBuf ~= '\t'; break;
 115             case 'v': wordBuf ~= '\v'; break;
 116             case 'x': case 'X':
 117               int n = 0;
 118               foreach (immutable _; 0..2) {
 119                 if (pos >= s.length) throw exBadHexEsc;
 120                 char c2 = s.ptr[pos++];
 121                 if (digit(c2, 16) < 0) throw exBadHexEsc;
 122                 n = n*16+digit(c2, 16);
 123               }
 124               wordBuf ~= cast(char)n;
 125               break;
 126             default: throw exBadEscChar;
 127           }
 128           continue;
 129         }
 130         wordBuf ~= s.ptr[pos++];
 131       }
 132       if (pos < s.length) ++pos; // skip closing quote
 133       s = s[pos..$];
 134       return wordBuf;
 135     } else {
 136       // normal word
 137       pos = 0;
 138       while (pos < s.length && s.ptr[pos] > ' ') ++pos;
 139       auto res = s[0..pos];
 140       s = s[pos..$];
 141       return res;
 142     }
 143   }
 144
 145   T parseType(T) (ref const(char)[] s) {
 146     import std.utf : byCodeUnit;
 147     // number
 148     static if (is(T == bool)) {
 149       auto w = getWord(s);
 150       if (w is null) throw exNoArg;
 151       if (w.length > 5) throw exBadBool;
 152       char[5] tbuf;
 153       usize pos = 0;
 154       foreach (char ch; w[]) {
 155         if (ch >= 'A' && ch <= 'Z') ch += 32; // poor man's tolower
 156         tbuf.ptr[pos++] = ch;
 157       }
 158       w = tbuf[0..w.length];
 159       switch (w) {
 160         case "y": case "t":
 161         case "yes": case "tan":
 162         case "true": case "on":
 163         case "1":
 164           return true;
 165         case "n": case "f":
 166         case "no": case "ona":
 167         case "false": case "off":
 168         case "0":
 169           return false;
 170         default: break;
 171       }
 172       throw exBadBool;
 173     } else static if ((isIntegral!T || isFloatingPoint!T) && !is(T == enum)) {
 174       auto w = getWord(s);
 175       if (w is null) throw exNoArg;
 176       auto ss = w.byCodeUnit;
 177       auto res = parseNum!T(ss);
 178       if (!ss.empty) throw exBadNum;
 179       return res;
 180     } else static if (is(T : const(char)[])) {
 181       bool stemp = false;
 182       auto w = getWord(s);
 183       if (w is null) throw exNoArg;
 184       if (s.length && s.ptr[0] > 32) throw exBadStr;
 185       if (stemp) {
 186         // temp storage was used
 187         static if (is(T == string)) return w.idup; else return w.dup;
 188       } else {
 189         // no temp storage was used
 190         static if (is(T == const(char)[])) return w;
 191         else static if (is(T == string)) return w.idup;
 192         else return w.dup;
 193       }
 194     } else {
 195       throw exBadArgType;
 196     }
 197   }
 198
 199   /** parse integer number.
 200    *
 201    * parser checks for overflows and understands different bases (0x, 0b, 0o, 0d).
 202    * parser skips leading spaces. stops on first non-numeric char.
 203    *
 204    * Params:
 205    *  T = result type
 206    *  s = input range; will be modified
 207    *
 208    * Returns:
 209    *  parsed number
 210    *
 211    * Throws:
 212    *  ConvException or ConvOverflowException
 213    */
 214   private T parseInt(T, TS) (ref TS s) if (isSomeChar!(ElementType!TS) && isIntegral!T && !is(T == enum)) {
 215     import std.traits : isSigned;
 216
 217     uint base = 10;
 218     ulong num = 0;
 219     static if (isSigned!T) bool neg = false;
 220     // skip spaces
 221     while (!s.empty) {
 222       if (s.front > 32) break;
 223       s.popFront();
 224     }
 225     if (s.empty) throw exBadInt;
 226     // check for sign
 227     switch (s.front) {
 228       case '+': // it's ok
 229         s.popFront();
 230         break;
 231       case '-':
 232         static if (isSigned!T) {
 233           neg = true;
 234           s.popFront();
 235           break;
 236         } else {
 237           throw exBadInt;
 238         }
 239       default: // do nothing
 240     }
 241     if (s.empty) throw exBadInt;
 242     // check for various bases
 243     if (s.front == '0') {
 244       s.popFront();
 245       if (s.empty) return cast(T)0;
 246       auto ch = s.front;
 247       switch (/*auto ch = s.front*/ch) {
 248         case 'b': case 'B': base = 2; goto gotbase;
 249         case 'o': case 'O': base = 8; goto gotbase;
 250         case 'd': case 'D': base = 10; goto gotbase;
 251         case 'x': case 'X': base = 16;
 252        gotbase:
 253           s.popFront();
 254           goto checkfirstdigit;
 255         default:
 256           if (ch != '_' && digit(ch, base) < 0) throw exBadInt;
 257           break;
 258       }
 259     } else {
 260       // no base specification; we want at least one digit
 261      checkfirstdigit:
 262       if (s.empty || digit(s.front, base) < 0) throw exBadInt;
 263     }
 264     // parse number
 265     // we already know that the next char is valid
 266     bool needDigit = false;
 267     do {
 268       auto ch = s.front;
 269       int d = digit(ch, base);
 270       if (d < 0) {
 271         if (needDigit) throw exBadInt;
 272         if (ch != '_') break;
 273         needDigit = true;
 274       } else {
 275         // funny overflow checks
 276         auto onum = num;
 277         if ((num *= base) < onum) throw exIntOverflow;
 278         if ((num += d) < onum) throw exIntOverflow;
 279         needDigit = false;
 280       }
 281       s.popFront();
 282     } while (!s.empty);
 283     if (needDigit) throw exBadInt;
 284     // check underflow and overflow
 285     static if (isSigned!T) {
 286       long n = cast(long)num;
 287       if (neg) {
 288         // special case: negative 0x8000_0000_0000_0000uL is ok
 289         if (num > 0x8000_0000_0000_0000uL) throw exIntOverflow;
 290         if (num != 0x8000_0000_0000_0000uL) n = -n;
 291       } else {
 292         if (num >= 0x8000_0000_0000_0000uL) throw exIntOverflow;
 293       }
 294       if (n < T.min || n > T.max) throw exIntOverflow;
 295       return cast(T)n;
 296     } else {
 297       if (num < T.min || num > T.max) throw exIntOverflow;
 298       return cast(T)num;
 299     }
 300   }
 301
 302   /** parse number.
 303    *
 304    * parser checks for overflows and understands different integer bases (0x, 0b, 0o, 0d).
 305    * parser skips leading spaces. stops on first non-numeric char.
 306    *
 307    * Params:
 308    *  T = result type
 309    *  s = input range; will be modified
 310    *
 311    * Returns:
 312    *  parsed number
 313    *
 314    * Throws:
 315    *  ConvException or ConvOverflowException
 316    */
 317   private T parseNum(T, TS) (ref TS s) if (isSomeChar!(ElementType!TS) && (isIntegral!T || isFloatingPoint!T) && !is(T == enum)) {
 318     static if (isIntegral!T) {
 319       return parseInt!T(s);
 320     } else {
 321       import std.conv : parse;
 322       while (!s.empty) {
 323         if (s.front > 32) break;
 324         s.popFront();
 325       }
 326       return std.conv.parse!T(s);
 327     }
 328   }
 329
 330   bool checkHelp (const(char)[] s) {
 331     usize pos = 0;
 332     while (pos < s.length && s.ptr[pos] <= 32) ++pos;
 333     if (pos == s.length || s.ptr[pos] != '?') return false;
 334     ++pos;
 335     while (pos < s.length && s.ptr[pos] <= 32) ++pos;
 336     return (pos >= s.length);
 337   }
 338
 339   bool hasArgs (const(char)[] s) {
 340     usize pos = 0;
 341     while (pos < s.length && s.ptr[pos] <= 32) ++pos;
 342     return (pos < s.length);
 343   }
 344
 345   void writeQuotedString (const(char)[] s) {
 346     static immutable string hexd = "0123456789abcdef";
 347     static bool isBadChar() (char ch) {
 348       pragma(inline, true);
 349       return (ch < ' ' || ch == '\\' || ch == '"' || ch > 126);
 350     }
 351     auto wrt = ConWriter;
 352     wrt("\"");
 353     usize pos = 0;
 354     while (pos < s.length) {
 355       usize end = pos;
 356       while (end < s.length && !isBadChar(s.ptr[end])) ++end;
 357       if (end > pos) wrt(s[pos..end]);
 358       pos = end;
 359       if (pos >= s.length) break;
 360       wrt("\\");
 361       switch (s.ptr[pos++]) {
 362         case '"': case '\'': case '\\': wrt(s.ptr[pos-1..pos]); break;
 363         case '\x00': wrt("0"); break;
 364         case '\a': wrt("a"); break;
 365         case '\b': wrt("b"); break;
 366         case '\e': wrt("e"); break;
 367         case '\f': wrt("f"); break;
 368         case '\n': wrt("n"); break;
 369         case '\r': wrt("r"); break;
 370         case '\t': wrt("t"); break;
 371         case '\v': wrt("c"); break;
 372         default:
 373           ubyte c = cast(ubyte)(s.ptr[pos-1]);
 374           wrt("x");
 375           wrt(hexd[c>>4..(c>>4)+1]);
 376           wrt(hexd[c&0x0f..c&0x0f+1]);
 377           break;
 378       }
 379     }
 380     wrt("\"");
 381   }
 382 }
 383
 384
 385 version(contest_parser) unittest {
 386   auto cc = new ConCommand("!");
 387   string s = "this is 'a test' string \"you\tknow\" ";
 388   auto sc = cast(const(char)[])s;
 389   {
 390     auto w = cc.getWord(sc);
 391     assert(w == "this");
 392   }
 393   {
 394     auto w = cc.getWord(sc);
 395     assert(w == "is");
 396   }
 397   {
 398     auto w = cc.getWord(sc);
 399     assert(w == "a test");
 400   }
 401   {
 402     auto w = cc.getWord(sc);
 403     assert(w == "string");
 404   }
 405   {
 406     auto w = cc.getWord(sc);
 407     assert(w == "you\tknow");
 408   }
 409   {
 410     auto w = cc.getWord(sc);
 411     assert(w is null);
 412     assert(sc.length == 0);
 413   }
 414
 415   import std.conv : ConvException, ConvOverflowException;
 416   import std.exception;
 417   import std.math : abs;
 418
 419   void testnum(T) (string s, T res, int line=__LINE__) {
 420     import std.string : format;
 421     bool ok = false;
 422     try {
 423       import std.utf : byCodeUnit;
 424       auto ss = s.byCodeUnit;
 425       auto v = ConCommand.parseNum!T(ss);
 426       while (!ss.empty && ss.front <= 32) ss.popFront();
 427       if (!ss.empty) throw new ConvException("shit happens!");
 428       static assert(is(typeof(v) == T));
 429       static if (isIntegral!T) ok = (v == res); else ok = (abs(v-res) < T.epsilon);
 430     } catch (ConvException e) {
 431       assert(0, format("unexpected exception thrown, called from line %s", line));
 432     }
 433     if (!ok) assert(0, format("assertion failure, called from line %s", line));
 434   }
 435
 436   void testbadnum(T) (string s, int line=__LINE__) {
 437     import std.string : format;
 438     try {
 439       import std.utf : byCodeUnit;
 440       auto ss = s.byCodeUnit;
 441       auto v = ConCommand.parseNum!T(ss);
 442       while (!ss.empty && ss.front <= 32) ss.popFront();
 443       if (!ss.empty) throw new ConvException("shit happens!");
 444     } catch (ConvException e) {
 445       return;
 446     }
 447     assert(0, format("exception not thrown, called from line %s", line));
 448   }
 449
 450   testnum!int(" -42", -42);
 451   testnum!int(" +42", 42);
 452   testnum!int(" -4_2", -42);
 453   testnum!int(" +4_2", 42);
 454   testnum!int(" -0d42", -42);
 455   testnum!int(" +0d42", 42);
 456   testnum!int("0x2a", 42);
 457   testnum!int("-0x2a", -42);
 458   testnum!int("0o52", 42);
 459   testnum!int("-0o52", -42);
 460   testnum!int("0b00101010", 42);
 461   testnum!int("-0b00101010", -42);
 462   testnum!ulong("+9223372036854775808", 9223372036854775808uL);
 463   testnum!long("9223372036854775807", 9223372036854775807);
 464   testnum!long("-9223372036854775808", -9223372036854775808uL); // uL to workaround issue #13606
 465   testnum!ulong("+0x8000_0000_0000_0000", 9223372036854775808uL);
 466   testnum!long("-0x8000_0000_0000_0000", -9223372036854775808uL); // uL to workaround issue #13606
 467   testbadnum!long("9223372036854775808");
 468   testbadnum!int("_42");
 469   testbadnum!int("42_");
 470   testbadnum!int("42_ ");
 471   testbadnum!int("4__2");
 472   testbadnum!int("0x_2a");
 473   testbadnum!int("-0x_2a");
 474   testbadnum!int("_0x2a");
 475   testbadnum!int("-_0x2a");
 476   testbadnum!int("_00x2a");
 477   testbadnum!int("-_00x2a");
 478   testbadnum!int(" +0x");
 479
 480   testnum!int("666", 666);
 481   testnum!int("+666", 666);
 482   testnum!int("-666", -666);
 483
 484   testbadnum!int("+");
 485   testbadnum!int("-");
 486   testbadnum!int("5a");
 487
 488   testbadnum!int("5.0");
 489   testbadnum!int("5e+2");
 490
 491   testnum!uint("666", 666);
 492   testnum!uint("+666", 666);
 493   testbadnum!uint("-666");
 494
 495   testnum!int("0x29a", 666);
 496   testnum!int("0X29A", 666);
 497   testnum!int("-0x29a", -666);
 498   testnum!int("-0X29A", -666);
 499   testnum!int("0b100", 4);
 500   testnum!int("0B100", 4);
 501   testnum!int("-0b100", -4);
 502   testnum!int("-0B100", -4);
 503   testnum!int("0o666", 438);
 504   testnum!int("0O666", 438);
 505   testnum!int("-0o666", -438);
 506   testnum!int("-0O666", -438);
 507   testnum!int("0d666", 666);
 508   testnum!int("0D666", 666);
 509   testnum!int("-0d666", -666);
 510   testnum!int("-0D666", -666);
 511
 512   testnum!byte("-0x7f", -127);
 513   testnum!byte("-0x80", -128);
 514   testbadnum!byte("0x80");
 515   testbadnum!byte("-0x81");
 516
 517   testbadnum!uint("1a");
 518   testbadnum!uint("0x1g");
 519   testbadnum!uint("0b12");
 520   testbadnum!uint("0o78");
 521   testbadnum!uint("0d1f");
 522
 523   testbadnum!int("0x_2__9_a__");
 524   testbadnum!uint("0x_");
 525
 526   testnum!ulong("0x8000000000000000", 0x8000000000000000UL);
 527   testnum!long("-0x8000000000000000", -0x8000000000000000uL);
 528   testbadnum!long("0x8000000000000000");
 529   testbadnum!ulong("0x80000000000000001");
 530   testbadnum!long("-0x8000000000000001");
 531
 532   testbadnum!float("-0O666");
 533   testnum!float("0x666p0", 1638.0f);
 534   testnum!float("-0x666p0", -1638.0f);
 535   testnum!double("+1.1e+2", 110.0);
 536   testnum!double("2.4", 2.4);
 537   testnum!double("1_2.4", 12.4);
 538   testnum!float("42666e-3", 42.666f);
 539   testnum!float(" 4.2 ", 4.2);
 540
 541   conwriteln("console: parser test passed");
 542 }
 543
 544
 545 // ////////////////////////////////////////////////////////////////////////// //
 546 // variable of some type
 547 public class ConVarBase : ConCommand {
 548   this (string aname, string ahelp=null) { super(aname, ahelp); }
 549
 550   abstract void printValue ();
 551   abstract bool isString () const pure nothrow @nogc;
 552   abstract const(char)[] strval () nothrow @nogc;
 553 }
 554
 555
 556 // ////////////////////////////////////////////////////////////////////////// //
 557 class ConVar(T) : ConVarBase {
 558   T* vptr;
 559   static if (isIntegral!T) {
 560     T minv = T.min;
 561     T maxv = T.max;
 562   }
 563   static if (!is(T : const(char)[])) {
 564     char[256] vbuf;
 565   }
 566
 567   this (T* avptr, string aname, string ahelp=null) { vptr = avptr; super(aname, ahelp); }
 568   static if (isIntegral!T) {
 569     this (T* avptr, T aminv, T amaxv, string aname, string ahelp=null) {
 570       vptr = avptr;
 571       minv = aminv;
 572       maxv = amaxv;
 573       super(aname, ahelp);
 574     }
 575   }
 576
 577   override void exec (const(char)[] cmdline) {
 578     if (checkHelp(cmdline)) { showHelp; return; }
 579     if (!hasArgs(cmdline)) { printValue; return; }
 580     static if (is(T == bool)) {
 581       while (cmdline.length && cmdline[0] <= 32) cmdline = cmdline[1..$];
 582       while (cmdline.length && cmdline[$-1] <= 32) cmdline = cmdline[0..$-1];
 583       if (cmdline == "toggle") {
 584         *vptr = !(*vptr);
 585         return;
 586       }
 587     }
 588     T val = parseType!T(ref cmdline);
 589     if (hasArgs(cmdline)) throw exTooManyArgs;
 590     static if (isIntegral!T) {
 591       if (val < minv) val = minv;
 592       if (val > maxv) val = maxv;
 593     }
 594     *vptr = val;
 595   }
 596
 597   override bool isString () const pure nothrow @nogc {
 598     static if (is(T : const(char)[])) {
 599       return true;
 600     } else {
 601       return false;
 602     }
 603   }
 604
 605   override const(char)[] strval () nothrow @nogc {
 606     //conwriteln("*** strval for '", name, "'");
 607     import core.stdc.stdio : snprintf;
 608     static if (is(T : const(char)[])) {
 609       return *vptr;
 610     } else static if (is(T == bool)) {
 611       return (*vptr ? "tan" : "ona");
 612     } else static if (isIntegral!T) {
 613       static if (isSigned!T) {
 614         auto len = snprintf(vbuf.ptr, vbuf.length, "%lld", cast(long)(*vptr));
 615       } else {
 616         auto len = snprintf(vbuf.ptr, vbuf.length, "%llu", cast(long)(*vptr));
 617       }
 618       return (len >= 0 ? vbuf[0..len] : "?");
 619     } else static if (isFloatingPoint!T) {
 620       auto len = snprintf(vbuf.ptr, vbuf.length, "%f", cast(double)(*vptr));
 621       return (len >= 0 ? vbuf[0..len] : "?");
 622     }
 623   }
 624
 625   override void printValue () {
 626     auto wrt = ConWriter;
 627     static if (is(T : const(char)[])) {
 628       wrt(name);
 629       wrt(" ");
 630       writeQuotedString(*vptr);
 631       wrt("\n");
 632       wrt(null); // flush
 633     } else static if (is(T == bool)) {
 634       conwriteln(name, " ", (*vptr ? "tan" : "ona"));
 635     } else {
 636       conwriteln(name, " ", *vptr);
 637     }
 638   }
 639 }
 640
 641
 642 version(contest_vars) unittest {
 643   __gshared int vi = 42;
 644   __gshared string vs = "str";
 645   __gshared bool vb = true;
 646   auto cvi = new ConVar!int(&vi, "vi", "integer variable");
 647   auto cvs = new ConVar!string(&vs, "vs", "string variable");
 648   auto cvb = new ConVar!bool(&vb, "vb", "bool variable");
 649   cvi.exec("?");
 650   cvs.exec("?");
 651   cvb.exec("?");
 652   cvi.exec("");
 653   cvs.exec("");
 654   cvb.exec("");
 655   cvi.exec("666");
 656   cvs.exec("'fo\to'");
 657   cvi.exec("");
 658   cvs.exec("");
 659   conwriteln("vi=", vi);
 660   conwriteln("vs=[", vs, "]");
 661   cvs.exec("'?'");
 662   cvs.exec("");
 663   cvb.exec("tan");
 664   cvb.exec("");
 665   cvb.exec("ona");
 666   cvb.exec("");
 667 }
 668
 669
 670 public void conRegVar(alias fn, T) (T aminv, T amaxv, string aname, string ahelp=null) if (isIntegral!(typeof(fn)) && isIntegral!T) {
 671   if (aname.length == 0) aname = (&fn).stringof[2..$]; // HACK
 672   if (aname.length > 0) cmdlist[aname] = new ConVar!(typeof(fn))(&fn, cast(typeof(fn))aminv, cast(typeof(fn))amaxv, aname, ahelp);
 673 }
 674
 675 public void conRegVar(alias fn) (string aname, string ahelp=null) if (!isCallable!(typeof(fn))) {
 676   if (aname.length == 0) aname = (&fn).stringof[2..$]; // HACK
 677   if (aname.length > 0) cmdlist[aname] = new ConVar!(typeof(fn))(&fn, aname, ahelp);
 678 }
 679
 680
 681 // ////////////////////////////////////////////////////////////////////////// //
 682 // delegate
 683 public class ConFuncBase : ConCommand {
 684   this (string aname, string ahelp=null) { super(aname, ahelp); }
 685 }
 686
 687
 688 public struct ConFuncVA {
 689   const(char)[] cmdline;
 690 }
 691
 692 // we have to make the class nested, so we can use `dg`, which keeps default args
 693 public void conRegFunc(alias fn) (string aname, string ahelp=null) if (isCallable!fn) {
 694   // hack for inline lambdas
 695   static if (is(typeof(&fn))) {
 696     auto dg = &fn;
 697   } else {
 698     auto dg = fn;
 699   }
 700
 701   class ConFunc : ConFuncBase {
 702     this (string aname, string ahelp=null) { super(aname, ahelp); }
 703
 704     override void exec (const(char)[] cmdline) {
 705       if (checkHelp(cmdline)) { showHelp; return; }
 706       Parameters!dg args;
 707       static if (args.length == 0) {
 708         if (hasArgs(cmdline)) {
 709           conwriteln("too many args for command '", name, "'");
 710         } else {
 711           dg();
 712         }
 713       } else static if (args.length == 1 && is(typeof(args[0]) == ConFuncVA)) {
 714         args[0].cmdline = cmdline;
 715         dg(args);
 716       } else {
 717         alias defaultArguments = ParameterDefaultValueTuple!fn;
 718         //pragma(msg, "defs: ", defaultArguments);
 719         import std.conv : to;
 720         foreach (auto idx, ref arg; args) {
 721           // populate arguments, with user data if available,
 722           // default if not, and throw if no argument provided
 723           if (hasArgs(cmdline)) {
 724             import std.conv : ConvException;
 725             try {
 726               arg = parseType!(typeof(arg))(cmdline);
 727             } catch (ConvException) {
 728               conwriteln("error parsing argument #", idx+1, " for command '", name, "'");
 729               return;
 730             }
 731           } else {
 732             static if (!is(defaultArguments[idx] == void)) {
 733               arg = defaultArguments[idx];
 734             } else {
 735               conwriteln("required argument #", idx+1, " for command '", name, "' is missing");
 736               return;
 737             }
 738           }
 739         }
 740         if (hasArgs(cmdline)) {
 741           conwriteln("too many args for command '", name, "'");
 742           return;
 743         }
 744         //static if (is(ReturnType!dg == void))
 745         dg(args);
 746       }
 747     }
 748   }
 749
 750   static if (is(typeof(&fn))) {
 751     if (aname.length == 0) aname = (&fn).stringof[2..$]; // HACK
 752   }
 753   if (aname.length > 0) cmdlist[aname] = new ConFunc(aname, ahelp);
 754 }
 755
 756
 757 // ////////////////////////////////////////////////////////////////////////// //
 758 __gshared ConCommand[string] cmdlist;
 759
 760
 761 // ////////////////////////////////////////////////////////////////////////// //
 762 public void conExecute (const(char)[] s) {
 763   auto ss = s;
 764   try {
 765     auto w = ConCommand.getWord(s);
 766     if (w is null) return;
 767     if (auto cmd = w in cmdlist) {
 768       while (s.length && s.ptr[0] <= 32) s = s[1..$];
 769       //conwriteln("'", s, "'");
 770       (*cmd).exec(s);
 771     } else {
 772       auto wrt = ConWriter;
 773       wrt("command ");
 774       ConCommand.writeQuotedString(w);
 775       wrt(" not found");
 776       wrt("\n");
 777       wrt(null); // flush
 778     }
 779   } catch (Exception) {
 780     conwriteln("error executing console command:\n ", s);
 781   }
 782 }
 783
 784
 785 // ////////////////////////////////////////////////////////////////////////// //
 786 version(contest_func) unittest {
 787   static void xfunc (int v, int x=42) { conwriteln("xfunc: v=", v, "; x=", x); }
 788
 789   //pragma(msg, typeof(&xfunc), " ", ParameterDefaultValueTuple!xfunc);
 790   conRegFunc!xfunc("", "function with two int args (last has default value '42')");
 791   conExecute("xfunc ?");
 792   conExecute("xfunc 666");
 793   conExecute("xfunc");
 794
 795   conRegFunc!({conwriteln("!!!");})("bang");
 796   conExecute("bang");
 797
 798   conRegFunc!((ConFuncVA va) {
 799     int idx = 1;
 800     for (;;) {
 801       auto w = ConCommand.getWord(va.cmdline);
 802       if (w is null) break;
 803       conwriteln("#", idx, ": [", w, "]");
 804       ++idx;
 805     }
 806   })("doo");
 807   conExecute("doo 1 2 ' 34 '");
 808 }
 809
 810
 811 // ////////////////////////////////////////////////////////////////////////// //
 812 // return `null` when there is no command
 813 public const(char)[] conGetCommand (ref const(char)[] s) {
 814   for (;;) {
 815     while (s.length > 0 && s[0] <= 32) s = s[1..$];
 816     if (s.length == 0) return null;
 817     if (s.ptr[0] != ';') break;
 818     s = s[1..$];
 819   }
 820
 821   usize pos = 0;
 822
 823   void skipString () {
 824     char qch = s.ptr[pos++];
 825     while (pos < s.length) {
 826       if (s.ptr[pos] == qch) { ++pos; break; }
 827       if (s.ptr[pos++] == '\\') {
 828         if (pos < s.length) {
 829           if (s.ptr[pos] == 'x' || s.ptr[pos] == 'X') pos += 2; else ++pos;
 830         }
 831       }
 832     }
 833   }
 834
 835   void skipLine () {
 836     while (pos < s.length) {
 837       if (s.ptr[pos] == '"' || s.ptr[pos] == '\'') {
 838         skipString();
 839       } else if (s.ptr[pos++] == '\n') {
 840         break;
 841       }
 842     }
 843   }
 844
 845   if (s.ptr[0] == '#') {
 846     skipLine();
 847     if (pos >= s.length) { s = s[$..$]; return null; }
 848     s = s[pos..$];
 849     pos = 0;
 850   }
 851
 852   while (pos < s.length) {
 853     if (s.ptr[pos] == '"' || s.ptr[pos] == '\'') {
 854       skipString();
 855     } else if (s.ptr[pos] == ';' || s.ptr[pos] == '#' || s.ptr[pos] == '\n') {
 856       auto res = s[0..pos];
 857       if (s.ptr[pos] == '#') s = s[pos..$]; else s = s[pos+1..$];
 858       return res;
 859     } else {
 860       ++pos;
 861     }
 862   }
 863   auto res = s[];
 864   s = s[$..$];
 865   return res;
 866 }
 867
 868 version(contest_cpx) unittest {
 869   const(char)[] s = "boo; woo \";\" 42#cmt\ntest\nfoo";
 870   {
 871     auto c = conGetCommand(s);
 872     conwriteln("[", c, "] : [", s, "]");
 873   }
 874   {
 875     auto c = conGetCommand(s);
 876     conwriteln("[", c, "] : [", s, "]");
 877   }
 878   {
 879     auto c = conGetCommand(s);
 880     conwriteln("[", c, "] : [", s, "]");
 881   }
 882   {
 883     auto c = conGetCommand(s);
 884     conwriteln("[", c, "] : [", s, "]");
 885   }
 886 }
 887
 888
 889 // ////////////////////////////////////////////////////////////////////////// //
 890 public class ConCommandEcho : ConCommand {
 891   this () { super("echo", "write string to console"); }
 892
 893   override void exec (const(char)[] cmdline) {
 894     if (checkHelp(cmdline)) { showHelp; return; }
 895     if (!hasArgs(cmdline)) return;
 896     bool needSpace = false;
 897     auto wrt = ConWriter;
 898     for (;;) {
 899       auto w = getWord(cmdline);
 900       if (w is null) break;
 901       if (needSpace) wrt(" "); else needSpace = true;
 902       while (w.length) {
 903         usize pos = 0;
 904         while (pos < w.length && w.ptr[pos] != '$') ++pos;
 905         if (w.length-pos > 1 && w.ptr[pos+1] == '$') {
 906           wrt(w[0..pos+1]);
 907           w = w[pos+2..$];
 908         } else if (w.length-pos <= 1) {
 909           wrt(w);
 910           break;
 911         } else {
 912           // variable name
 913           const(char)[] vname;
 914           if (pos > 0) wrt(w[0..pos]);
 915           ++pos;
 916           if (w.ptr[pos] == '{') {
 917             w = w[pos+1..$];
 918             pos = 0;
 919             while (pos < w.length && w.ptr[pos] != '}') ++pos;
 920             vname = w[0..pos];
 921             if (pos < w.length) ++pos;
 922             w = w[pos..$];
 923           } else {
 924             w = w[pos..$];
 925             pos = 0;
 926             while (pos < w.length) {
 927               char ch = w.ptr[pos];
 928               if (ch == '_' || (ch >= '0' && ch <= '9') || (ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z')) {
 929                 ++pos;
 930               } else {
 931                 break;
 932               }
 933             }
 934             vname = w[0..pos];
 935             w = w[pos..$];
 936           }
 937           if (vname.length) {
 938             if (auto cc = vname in cmdlist) {
 939               if (auto cv = cast(ConVarBase)(*cc)) {
 940                 auto v = cv.strval;
 941                 wrt(v);
 942               } else {
 943                 wrt("${!");
 944                 wrt(vname);
 945                 wrt("}");
 946               }
 947             } else {
 948               wrt("${");
 949               wrt(vname);
 950               wrt("}");
 951             }
 952           }
 953         }
 954       }
 955     }
 956     wrt("\n");
 957     wrt(null); // flush
 958   }
 959 }
 960
 961
 962 shared static this () {
 963   cmdlist["echo"] = new ConCommandEcho();
 964 }
 965
 966
 967 public char[] conFormatStr (char[] dest, const(char)[] s) {
 968   usize dpos = 0;
 969
 970   void put (const(char)[] ss) {
 971     if (ss.length == 0) return;
 972     auto len = ss.length;
 973     if (dest.length-dpos < len) len = dest.length-dpos;
 974     if (len) {
 975       dest[dpos..dpos+len] = ss[];
 976       dpos += len;
 977     }
 978   }
 979
 980   while (s.length) {
 981     usize pos = 0;
 982     while (pos < s.length && s.ptr[pos] != '$') ++pos;
 983     if (s.length-pos > 1 && s.ptr[pos+1] == '$') {
 984       put(s[0..pos+1]);
 985       s = s[pos+2..$];
 986     } else if (s.length-pos <= 1) {
 987       put(s);
 988       break;
 989     } else {
 990       // variable name
 991       const(char)[] vname;
 992       if (pos > 0) put(s[0..pos]);
 993       ++pos;
 994       if (s.ptr[pos] == '{') {
 995         s = s[pos+1..$];
 996         pos = 0;
 997         while (pos < s.length && s.ptr[pos] != '}') ++pos;
 998         vname = s[0..pos];
 999         if (pos < s.length) ++pos;
1000         s = s[pos..$];
1001       } else {
1002         s = s[pos..$];
1003         pos = 0;
1004         while (pos < s.length) {
1005           char ch = s.ptr[pos];
1006           if (ch == '_' || (ch >= '0' && ch <= '9') || (ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z')) {
1007             ++pos;
1008           } else {
1009             break;
1010           }
1011         }
1012         vname = s[0..pos];
1013         s = s[pos..$];
1014       }
1015       if (vname.length) {
1016         if (auto cc = vname in cmdlist) {
1017           if (auto cv = cast(ConVarBase)(*cc)) {
1018             auto v = cv.strval;
1019             put(v);
1020           } else {
1021             put("${!");
1022             put(vname);
1023             put("}");
1024           }
1025         } else {
1026           put("${");
1027           put(vname);
1028           put("}");
1029         }
1030       }
1031     }
1032   }
1033   return dest[0..dpos];
1034 }
1035
1036
1037 version(contest_echo) unittest {
1038   __gshared int vi = 42;
1039   __gshared string vs = "str";
1040   __gshared bool vb = true;
1041   conRegVar!vi("vi");
1042   conRegVar!vs("vs");
1043   conRegVar!vb("vb");
1044   conRegVar!vb("r_interpolation");
1045   conwriteln("=================");
1046   conExecute("r_interpolation");
1047   conExecute("echo ?");
1048   conExecute("echo vs=$vs,  vi=${vi},  vb=${vb}!");
1049   {
1050     char[44] buf;
1051     auto s = buf.conFormatStr("vs=$vs,  vi=${vi},  vb=${vb}!");
1052     conwriteln("[", s, "]");
1053     foreach (auto kv; cmdlist.byKeyValue) conwriteln(" ", kv.key);
1054     assert("r_interpolation" in cmdlist);
1055     s = buf.conFormatStr("Interpolation: $r_interpolation");
1056     conwriteln("[", s, "]");
1057   }
1058 }