parse.cc

   1 #include <cassert>
   2 #include <cstdarg>
   3 #include <cstdlib>
   4 #include <cstdio>
   5
   6 #include "jam.h"
   7
   8 /*** Lexer ***/
   9
  10 enum token_type {
  11   TOK_NONE,
  12   TOK_END,
  13   TOK_EQUAL,
  14   TOK_COMMA,
  15   TOK_COLON,
  16   TOK_DOTDOT,
  17   TOK_OPEN_PAREN,
  18   TOK_CLOSE_PAREN,
  19   TOK_OPEN_BRACE,
  20   TOK_CLOSE_BRACE,
  21   TOK_IDENT,
  22   TOK_STRING,
  23   TOK_NUMBER,
  24 };
  25
  26 const char *in_pos;
  27 static token_type this_token = TOK_NONE;
  28 static token_type buffered_token = TOK_NONE;
  29 static string token;
  30 static double token_num;
  31
  32 static void NONRET parse_error(const char *msg, ...);
  33 static void parse_commands(list<cmd *> &cmds);
  34
  35 static void parse_error(const char *msg, ...)
  36 {
  37   va_list args;
  38   va_start(args, msg);
  39   fprintf(stderr, "Parse error: ");
  40   vfprintf(stderr, msg, args);
  41   fprintf(stderr, "\n");
  42   va_end(args);
  43   exit(1);
  44 }
  45
  46 static token_type get_next_token()
  47 {
  48   while (*in_pos == ' ' || *in_pos == '\t' || *in_pos == '\r' || *in_pos == '\n')
  49     in_pos++;
  50
  51   token = "";
  52   if (!*in_pos)
  53     return TOK_END;
  54
  55   if (*in_pos >= '0' && *in_pos <= '9' ||
  56       *in_pos == '-' && in_pos[1] >= '0' && in_pos[1] <= '9')
  57     {
  58       token += *in_pos++;
  59       while (*in_pos >= '0' && *in_pos <= '9' || *in_pos == '.' && in_pos[1] != '.')
  60         token += *in_pos++;
  61
  62       size_t end_pos;
  63       token_num = stod(token, &end_pos);
  64       if (end_pos < token.length())
  65         parse_error("Invalid number %s", token.c_str());
  66       return TOK_NUMBER;
  67     }
  68
  69   if (*in_pos >= 'A' && *in_pos <= 'Z' ||
  70       *in_pos >= 'a' && *in_pos <= 'z')
  71     {
  72       while (*in_pos >= 'A' && *in_pos <= 'Z' ||
  73              *in_pos >= 'a' && *in_pos <= 'z' ||
  74              *in_pos >= '0' && *in_pos <= '9' ||
  75              *in_pos == '_')
  76         token += *in_pos++;
  77       return TOK_IDENT;
  78     }
  79
  80   if (*in_pos == '"')
  81     {
  82       in_pos++;
  83       while (*in_pos != '"')
  84         {
  85           if (!*in_pos)
  86             parse_error("Unterminated string");
  87           if (*in_pos == '\\')
  88             {
  89               in_pos++;
  90               if (*in_pos != '"' && *in_pos != '\\')
  91                 parse_error("Unrecognized escape sequence \\%c", *in_pos);
  92             }
  93           token += *in_pos++;
  94         }
  95       in_pos++;
  96       return TOK_STRING;
  97     }
  98
  99   uint c = *in_pos++;
 100   switch (c)
 101     {
 102     case '=':
 103       return TOK_EQUAL;
 104     case ',':
 105       return TOK_COMMA;
 106     case ':':
 107       return TOK_COLON;
 108     case '(':
 109       return TOK_OPEN_PAREN;
 110     case ')':
 111       return TOK_CLOSE_PAREN;
 112     case '{':
 113       return TOK_OPEN_BRACE;
 114     case '}':
 115       return TOK_CLOSE_BRACE;
 116     default:
 117       if (c == '.' && *in_pos == '.')
 118         {
 119           in_pos++;
 120           return TOK_DOTDOT;
 121         }
 122       parse_error("Unrecognized character '%c'", c);
 123     }
 124 }
 125
 126 static token_type next_token()
 127 {
 128   if (buffered_token != TOK_NONE)
 129     this_token = buffered_token;
 130   else
 131     this_token = get_next_token();
 132   buffered_token = TOK_NONE;
 133   return this_token;
 134 }
 135
 136 static void return_token()
 137 {
 138   assert(this_token != TOK_NONE);
 139   assert(buffered_token == TOK_NONE);
 140   buffered_token = this_token;
 141   this_token = TOK_NONE;
 142 }
 143
 144 static token_type peek_token()
 145 {
 146   next_token();
 147   return_token();
 148   return buffered_token;
 149 }
 150
 151 static bool token_is_int()
 152 {
 153   return token_num == (double)(int) token_num;
 154 }
 155
 156 /*** Argument types ***/
 157
 158 class arg_int : public arg_val {
 159   int val;
 160 public:
 161   arg_int(int x) { val = x; }
 162   bool given() { return true; }
 163   int as_int(int def UNUSED) { return val; }
 164   string dump() { return "<int> " + to_string(val); }
 165 };
 166
 167 class arg_double : public arg_val {
 168   double val;
 169 public:
 170   arg_double(double x) { val = x; }
 171   bool given() { return true; }
 172   double as_double(double def UNUSED) { return val; }
 173   string dump() { return "<double> " + to_string(val); }
 174 };
 175
 176 class arg_string : public arg_val {
 177   string val;
 178 public:
 179   arg_string(string x) { val = x; }
 180   bool given() { return true; }
 181   const string as_string(string def UNUSED) { return val; }
 182   string dump() { return "<string> \"" + val + '"'; }
 183 };
 184
 185 static arg_val null_arg;
 186
 187 /*** Parser ***/
 188
 189 struct unit {
 190   const char *name;
 191   double multiplier;
 192 };
 193
 194 #define MM (72/25.4)
 195
 196 static const unit units[] = {
 197   { "mm",       MM },
 198   { "cm",       10*MM },
 199   { "dm",       100*MM },
 200   { "m",        1000*MM },
 201   { "in",       72 },
 202   { "pt",       1 },
 203   { NULL,       0 }
 204 };
 205
 206 static double parse_dimen(const arg_def *adef)
 207 {
 208   token_type t = next_token();
 209   if (t != TOK_NUMBER)
 210     parse_error("Parameter %s must be a dimension", adef->name);
 211   double tmp = token_num;
 212
 213   t = next_token();
 214   if (t != TOK_IDENT)
 215     parse_error("Parameter %s must have a unit", adef->name);
 216   for (uint i=0; units[i].name; i++)
 217     if (token == units[i].name)
 218       return tmp * units[i].multiplier;
 219   parse_error("Unknown unit %s", token.c_str());
 220 }
 221
 222 static void parse_pipeline(cmd *c)
 223 {
 224   pipeline *pp = new pipeline;
 225   next_token();
 226
 227   while (peek_token() != TOK_CLOSE_BRACE)
 228     {
 229       if (pp->branches.size() && next_token() != TOK_COMMA)
 230         parse_error("Comma expected between pipeline branches");
 231
 232       pipeline_branch *pb = new pipeline_branch;
 233       pp->branches.push_back(pb);
 234
 235       token_type t;
 236       for (;;)
 237         {
 238           t = next_token();
 239           if (t == TOK_END)
 240             parse_error("Missing close brace");
 241           if (t == TOK_CLOSE_BRACE || t == TOK_COLON || t == TOK_COMMA)
 242             break;
 243
 244           pipeline_selector ps;
 245           if (t != TOK_NUMBER)
 246             parse_error("Pipeline selectors must start with a number");
 247           if (!token_is_int())
 248             parse_error("Pipeline selectors must be integers");
 249           ps.from = (int) token_num;
 250           ps.to = ps.from;
 251
 252           if (peek_token() == TOK_DOTDOT)
 253             {
 254               next_token();
 255               t = next_token();
 256               if (t != TOK_NUMBER)
 257                 parse_error("Pipeline selectors must be numbers or ranges");
 258               if (!token_is_int())
 259                 parse_error("Pipeline selectors must be integers");
 260               ps.to = (int) token_num;
 261             }
 262
 263           pb->selectors.push_back(ps);
 264         }
 265
 266       if (t == TOK_COLON)
 267         parse_commands(pb->commands);
 268       else
 269         return_token();
 270     }
 271
 272   c->pipe = pp;
 273   next_token();
 274 }
 275
 276 static void parse_args(cmd *c)
 277 {
 278   const cmd_def *cdef = c->def;
 279   const arg_def *adefs = cdef->arg_defs;
 280   uint num_args = 0;
 281   while (adefs[num_args].name)
 282     num_args++;
 283
 284   c->args.resize(num_args, &null_arg);
 285
 286   token_type t = next_token();
 287   if (t != TOK_OPEN_PAREN)
 288     {
 289       return_token();
 290       return;
 291     }
 292
 293   bool saw_named = false;
 294   uint next_pos = 0;
 295   for (;;)
 296     {
 297       t = next_token();
 298       uint argi = 0;
 299       if (t == TOK_IDENT)
 300         {
 301           while (adefs[argi].name && token != adefs[argi].name)
 302             argi++;
 303           if (!adefs[argi].name)
 304             parse_error("Command %s has no parameter %s", cdef->name, token.c_str());
 305           if (c->args.at(argi)->given())
 306             parse_error("Parameter %s given multiple times", token.c_str());
 307           t = next_token();
 308           if (t != TOK_EQUAL)
 309             parse_error("Parameter name must be followed by '='");
 310           saw_named = true;
 311         }
 312       else if (saw_named)
 313         parse_error("Positional parameters must precede named ones");
 314       else
 315         {
 316           return_token();
 317           while (next_pos < num_args && !(adefs[next_pos].type & AT_POSITIONAL))
 318             next_pos++;
 319           if (next_pos >= num_args)
 320             parse_error("Too many positional arguments for command %s", cdef->name);
 321           argi = next_pos++;
 322         }
 323
 324       const arg_def *adef = &adefs[argi];
 325       arg_val *val = NULL;
 326       switch (adef->type & AT_TYPE_MASK)
 327         {
 328         case AT_STRING:
 329           t = next_token();
 330           if (t != TOK_STRING)
 331             parse_error("Parameter %s must be a string", adef->name);
 332           val = new arg_string(token);
 333           break;
 334         case AT_INT:
 335           t = next_token();
 336           if (t != TOK_NUMBER || !token_is_int())
 337             parse_error("Parameter %s must be an integer", adef->name);
 338           val = new arg_int((int) token_num);
 339           break;
 340         case AT_DOUBLE:
 341           t = next_token();
 342           if (t != TOK_NUMBER)
 343             parse_error("Parameter %s must be a number", adef->name);
 344           val = new arg_double(token_num);
 345           break;
 346         case AT_DIMEN:
 347           val = new arg_double(parse_dimen(adef));
 348           break;
 349         default:
 350           abort();
 351         }
 352
 353       c->args.at(argi) = val;
 354
 355       t = next_token();
 356       if (t == TOK_CLOSE_PAREN)
 357         break;
 358       if (t != TOK_COMMA)
 359         parse_error("Comma expected after parameter %s", adef->name);
 360     }
 361
 362   for (uint i=0; i<num_args; i++)
 363     if ((adefs[i].type & AT_MANDATORY) && !c->args.at(i)->given())
 364       parse_error("Command %s is missing a parameter %s", cdef->name, adefs[i].name);
 365 }
 366
 367 static void debug_cmd(cmd *c, uint indent=0)
 368 {
 369   printf("%*sCommand %s\n", indent, "", c->def->name);
 370   for (size_t i=0; i < c->args.size(); i++)
 371     {
 372       const arg_def *adef = &c->def->arg_defs[i];
 373       string dump = c->args.at(i)->dump();
 374       printf("%*sArg #%d: %s = %s\n", indent+4, "", (int) i, adef->name, dump.c_str());
 375     }
 376   if (c->pipe)
 377     {
 378       printf("%*sPipeline:\n", indent+4, "");
 379       for (auto pb: c->pipe->branches)
 380         {
 381           printf("%*sSelector:\n", indent+8, "");
 382           for (auto ps: pb->selectors)
 383             printf("%*s%d - %d\n", indent+12, "", ps.from, ps.to);
 384           printf("%*sCommands:\n", indent+8, "");
 385           for (auto cc: pb->commands)
 386             debug_cmd(cc, indent+12);
 387         }
 388     }
 389 }
 390
 391 static void debug_cmds(list<cmd *> &cmds)
 392 {
 393   for (auto c: cmds)
 394     debug_cmd(c);
 395 }
 396
 397 static cmd *parse_cmd()
 398 {
 399   const cmd_def *cdef = cmd_table;
 400   while (cdef->name && token != cdef->name)
 401     cdef++;
 402   if (!cdef->name)
 403     parse_error("Unknown command %s", token.c_str());
 404
 405   cmd *c = new cmd;
 406   c->def = cdef;
 407   c->pipe = NULL;
 408
 409   parse_args(c);
 410
 411   if (peek_token() == TOK_OPEN_BRACE)
 412     {
 413       if (!cdef->has_pipeline)
 414         parse_error("Command %s does not accept a pipeline", cdef->name);
 415       parse_pipeline(c);
 416     }
 417   else if (cdef->has_pipeline)
 418     parse_error("Command %s requires a pipeline", cdef->name);
 419
 420   return c;
 421 }
 422
 423 static void parse_commands(list<cmd *> &cmds)
 424 {
 425   for (;;)
 426     {
 427       token_type t = next_token();
 428       if (t != TOK_IDENT)
 429         {
 430           return_token();
 431           return;
 432         }
 433
 434       cmd *c = parse_cmd();
 435       cmds.push_back(c);
 436     }
 437 }
 438
 439 static void instantiate(list<cmd *> &cmds)
 440 {
 441   for (auto c: cmds)
 442     {
 443       c->exec = c->def->constructor(c);
 444       if (c->pipe)
 445         {
 446           for (auto pb: c->pipe->branches)
 447             instantiate(pb->commands);
 448         }
 449     }
 450 }
 451
 452 void parse(const char *in, list<cmd *> &cmds)
 453 {
 454   in_pos = in;
 455   parse_commands(cmds);
 456   if (next_token() != TOK_END)
 457     parse_error("Extra tokens after commands");
 458
 459   debug_cmds(cmds);
 460   instantiate(cmds);
 461 }