xlat.C

   1 #include <stdio.h>
   2 #include <stdint.h>
   3 #include <stdlib.h>
   4 #include <string.h>
   5 #include <unistd.h>
   6
   7 #include <string>
   8 #include <map>
   9
  10 #define MX_STR 8192
  11
  12 // test csv    ./a.out csv < data.csv
  13 // test po     ./a.out  po < data.po
  14 // get strings ./a.out key  < xgettext.po
  15 // gen xlation ./a.out xlat < xgettext.po xlat.csv
  16 // gen xlation ./a.out xlat < xgettext.po text,xlat ...
  17 // gen xupdate ./a.out xlat < xgettext.po xlat.csv newer.csv ... newest.csv
  18
  19 unsigned int wnext(uint8_t *&bp)
  20 {
  21   unsigned int ch = *bp++;
  22   if( ch >= 0x80 ) {
  23     static const unsigned char byts[] = {
  24       1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 4, 5,
  25     };
  26     int i = ch - 0xc0;
  27     int n = i<0 ? 0 : byts[i/4];
  28     for( i=n; --i>=0 && *bp>=0x80; ch+=*bp++ ) ch <<= 6;
  29     static const unsigned int ofs[6] = {
  30       0x00000000U, 0x00003080U, 0x000E2080U,
  31       0x03C82080U, 0xFA082080U, 0x82082080U
  32     };
  33     ch = i<0 ?  ch-ofs[n] : '?';
  34   }
  35   return ch;
  36 }
  37
  38 int wnext(uint8_t *&bp, unsigned int ch)
  39 {
  40   if( ch < 0x00000080 ) { *bp++ = ch;  return 1; }
  41   int n = ch < 0x00000800 ? 2 : ch < 0x00010000 ? 3 :
  42           ch < 0x00200000 ? 4 : ch < 0x04000000 ? 5 : 6;
  43   int m = (0xff00 >> n), i = n-1;
  44   *bp++ = (ch>>(6*i)) | m;
  45   while( --i >= 0 ) *bp++ = ((ch>>(6*i)) & 0x3f) | 0x80;
  46   return n;
  47 }
  48
  49 using namespace std;
  50
  51 //csv = comma seperated value file
  52 #define SEP ','
  53 static bool is_sep(int ch) { return ch == SEP; }
  54
  55 static bool is_opnr(int ch)
  56 {
  57   if( ch ==  '\"'  ) return true;
  58   if( ch == 0xab ) return true;
  59   if( ch == 0xbb ) return true;
  60   if( ch == 0x300c ) return true;
  61   if( ch == 0x300d ) return true;
  62   return 0;
  63 }
  64
  65 // converts libreoffice csv stuttered quoted string (with quotes attached)
  66 //  quote marks only
  67 static void xlat1(uint8_t *&in, uint8_t *out)
  68 {
  69   uint8_t *ibp = in, *obp = out;
  70   unsigned ch, lch = 0;
  71   if( (ch=wnext(in)) == '\"' ) {
  72     bool is_nested = in[0] == '\"' && in[1] == '\"';
  73     while( (ch=wnext(in)) != 0 ) {
  74       if( ch == '\"' && lch != '\\' ) {
  75         uint8_t *bp = in;
  76         unsigned nch = wnext(in);
  77         if( nch != '\"' ) { in = bp;  break; }
  78       }
  79       wnext(out, lch = ch);
  80     }
  81     if( is_nested && ch == '"' ) {
  82       while( out > obp && *(out-1) == ' ' ) --out;
  83     }
  84   }
  85   if( ch != '"' ) {
  86     in = ibp;  out = obp;
  87     while( (ch=wnext(in)) && !is_sep(ch) ) wnext(out,ch);
  88   }
  89   *out = 0;
  90 }
  91
  92 static inline unsigned gch(uint8_t *&in) {
  93   unsigned ch = wnext(in);
  94   if( ch == '\\' ) {
  95     switch( (ch=*in++) ) {
  96     case 'a':  ch = '\a';  break;
  97     case 'b':  ch = '\b';  break;
  98     case 'f':  ch = '\f';  break;
  99     case 'n':  ch = '\n';  break;
 100     case 'r':  ch = '\r';  break;
 101     case 't':  ch = '\t';  break;
 102     case 'v':  ch = '\v';  break;
 103     }
 104   }
 105   return ch;
 106 }
 107
 108 // converts string (with opn/cls attached) to c string
 109 static void xlat2(uint8_t *in, uint8_t *out)
 110 {
 111   unsigned lch = gch(in), sep = 0, rch = 0, ch;
 112   if( lch ) {
 113     if( is_opnr(lch) ) {
 114       for( uint8_t *ip=in; (ch=gch(ip))!=0; rch=ch );
 115       if( lch == rch ) { sep = lch;  lch = gch(in); }
 116     }
 117     while( (ch=gch(in)) != 0 ) {
 118       wnext(out, lch);  lch = ch;
 119     }
 120     if( !sep ) wnext(out, lch);
 121   }
 122   *out = 0;
 123 }
 124
 125 int brkput = 0;
 126
 127 // converts c++ string to c string text
 128 static void xlat3(const char *cp, uint8_t *out)
 129 {
 130   wnext(out, '\"');
 131   unsigned ch;
 132   uint8_t *bp = (uint8_t*)cp;
 133   while( (ch=wnext(bp)) != 0 ) {
 134     switch( ch ) {
 135     case '"':   ch = '\"'; break;
 136     case '\a':  ch = 'a';  break;
 137     case '\b':  ch = 'b';  break;
 138     case '\f':  ch = 'f';  break;
 139     case '\n':  ch = 'n';  break;
 140     case '\r':  ch = 'r';  break;
 141     case '\t':  ch = 't';  break;
 142     case '\v':  ch = 'v';  break;
 143     default: wnext(out,ch);  continue;
 144     }
 145     wnext(out,'\\');
 146     wnext(out, ch);
 147     if( brkput && ch == 'n' && *bp ) {
 148       wnext(out, '\"');
 149       wnext(out, '\n');
 150       wnext(out, '\"');
 151     }
 152   }
 153   wnext(out, '\"');
 154   wnext(out, 0);
 155 }
 156
 157 // converts c++ string to csv string text
 158 static void xlat4(const char *cp, uint8_t *out)
 159 {
 160   wnext(out, '\"');
 161   unsigned ch;
 162   uint8_t *bp = (uint8_t*)cp;
 163   while( (ch=wnext(bp)) != 0 ) {
 164     switch( ch ) {
 165     case '\a':  ch = 'a';  break;
 166     case '\b':  ch = 'b';  break;
 167     case '\f':  ch = 'f';  break;
 168     case '\n':  ch = 'n';  break;
 169     case '\r':  ch = 'r';  break;
 170     case '\t':  ch = 't';  break;
 171     case '\v':  ch = 'v';  break;
 172     case '\"': break;
 173     default: wnext(out,ch);  continue;
 174     }
 175     wnext(out,'\\');
 176     wnext(out,ch);
 177   }
 178   wnext(out, '\"');
 179   wnext(out, 0);
 180 }
 181
 182 // parses input to c++ string
 183 static string xlat(uint8_t *&in)
 184 {
 185   uint8_t bfr[MX_STR];  bfr[0] = 0;  xlat1(in, bfr);
 186   uint8_t str[MX_STR];  str[0] = 0;  xlat2(bfr, str);
 187   return string((const char*)str);
 188 }
 189
 190 class tstring : public string {
 191 public:
 192   bool ok;
 193   tstring(const char *sp, bool k) { string::assign(sp); ok = k; }
 194 };
 195
 196 typedef map<string,tstring> Trans;
 197 static Trans trans;
 198
 199 static inline bool prefix_is(uint8_t *bp, const char *cp)
 200 {
 201   return !strncmp((const char *)bp, cp, strlen(cp));
 202 }
 203 static inline uint8_t *bgets(uint8_t *bp, int len, FILE *fp)
 204 {
 205   uint8_t *ret = (uint8_t*)fgets((char*)bp, len, fp);
 206   if( ret ) {
 207     int len = strlen((char *)bp);
 208     if( len > 0 && bp[len-1] == '\n' ) bp[len-1] = 0;
 209   }
 210   return ret;
 211 }
 212 static inline int bputs(uint8_t *bp, FILE *fp)
 213 {
 214   if( !fp ) return 0;
 215   fputs((const char*)bp, fp);
 216   fputc('\n',fp);
 217   int n = 1;
 218   while( *bp ) if( *bp++ == '\n' ) ++n;
 219   return n;
 220 }
 221 static inline int bput(uint8_t *bp, FILE *fp)
 222 {
 223   if( !fp ) return 0;
 224   fputs((const char*)bp, fp);
 225   return 1;
 226 }
 227
 228 static bool goog = false;
 229 static bool nocmts = false;
 230
 231 static inline bool is_nlin(unsigned ch, uint8_t *bp)
 232 {
 233   return ch == ' ' && bp[0] == '\\' && bp[1] == ' ' && ( bp[2] == 'n' || bp[2] == 'N' );
 234 }
 235
 236 static inline bool is_ccln(unsigned ch, uint8_t *bp)
 237 {
 238   return ch == ' ' && bp[0] == ':' && bp[1] == ':' && bp[2] == ' ';
 239 }
 240
 241 static inline bool is_quot(unsigned ch, uint8_t *bp)
 242 {
 243   return ch == ' ' && bp[0] == '\\' && bp[1] == ' ' && bp[2] == '"';
 244 }
 245
 246 static inline bool is_colon(unsigned ch)
 247 {
 248   return ch == 0xff1a;
 249 }
 250
 251 static inline bool is_per(unsigned ch)
 252 {
 253   if( ch == '%' ) return true;
 254   if( ch == 0xff05 ) return true;
 255   return false;
 256 }
 257
 258 static unsigned fmt_flds = 0;
 259
 260 enum { fmt_flg=1, fmt_wid=2, fmt_prc=4, fmt_len=8, fmt_cnv=16, };
 261
 262 static int is_flags(uint8_t *fp)
 263 {
 264   if( (fmt_flds & fmt_flg) != 0 ) return 0;
 265   if( !strchr("#0-+ I", *fp) ) return 0;
 266   fmt_flds |= fmt_flg;
 267   return 1;
 268 }
 269
 270 static int is_width(uint8_t *fp)
 271 {
 272   if( (fmt_flds & fmt_wid) != 0 ) return 0;
 273   if( *fp != '*' && *fp < '0' && *fp > '9' ) return 0;
 274   fmt_flds |= fmt_wid;
 275   uint8_t *bp = fp;
 276   bool argno = *fp++ == '*';
 277   while( *fp >= '0' && *fp <= '9' ) ++fp;
 278   if( argno && *fp++ != '$' ) return 1;
 279   return fp - bp;
 280 }
 281
 282 static int is_prec(uint8_t *fp)
 283 {
 284   if( (fmt_flds & fmt_prc) != 0 ) return 0;
 285   if( *fp != '.' ) return 0;
 286   fmt_flds |= fmt_prc;
 287   if( *fp != '*' && *fp < '0' && *fp > '9' ) return 0;
 288   uint8_t *bp = fp;
 289   bool argno = *fp++ == '*';
 290   while( *fp >= '0' && *fp <= '9' ) ++fp;
 291   if( argno && *fp++ != '$' ) return 1;
 292   return fp - bp;
 293 }
 294
 295 static int is_len(uint8_t *fp)
 296 {
 297   if( (fmt_flds & fmt_len) != 0 ) return 0;
 298   if( !strchr("hlLqjzt", *fp) ) return 0;
 299   fmt_flds |= fmt_len;
 300   if( fp[0] == 'h' && fp[1] == 'h' ) return 2;
 301   if( fp[0] == 'l' && fp[1] == 'l' ) return 2;
 302   return 1;
 303 }
 304
 305 static int is_conv(uint8_t *fp)
 306 {
 307   if( !strchr("diouxXeEfFgGaAscCSpnm", *fp) ) return 0;
 308   return 1;
 309 }
 310
 311
 312 static inline int fmt_spec(uint8_t *fp)
 313 {
 314   if( !*fp ) return 0;
 315   if( is_per(*fp) ) return 1;
 316   fmt_flds = 0;
 317   uint8_t *bp = fp;
 318   while( !is_conv(fp) ) {
 319     int len;
 320     if( !(len=is_flags(fp)) && !(len=is_width(fp)) &&
 321         !(len=is_prec(fp))  && !(len=is_len(fp)) ) return 0;
 322     fp += len;
 323   }
 324   return fp - bp + 1;
 325 }
 326
 327 static bool chkfmt(int no, uint8_t *ap, uint8_t *bp, uint8_t *cp)
 328 {
 329   bool ret = true;
 330   uint8_t *asp = ap, *bsp = bp;
 331   int n = 0;
 332   uint8_t *bep = bp;
 333   unsigned bpr = 0, bch = wnext(bp);
 334   for( ; bch!=0; bch=wnext(bp) ) {
 335     if( goog && is_opnr(bch) ) ++n;
 336     bep = bp;  bpr = bch;
 337   }
 338
 339   // trim solitary opnrs on ends b
 340   if( goog && ( n != 1 || !is_opnr(bpr) ) ) bep = bp;
 341   bp = bsp;  bch = wnext(bp);
 342   if( goog && ( n == 1 && is_opnr(bch) ) ) bch = wnext(bp);
 343
 344   unsigned apr = 0, ach = wnext(ap);
 345   apr = bpr = 0;
 346   while( ach != 0 && bch != 0 ) {
 347     // move to % on a
 348     while( ach != 0 && !is_per(ach) ) {
 349       apr = ach;  ach = wnext(ap);
 350     }
 351     // move to % on b
 352     while( bch != 0 && !is_per(bch) ) {
 353       if( goog ) { // google xlat recoginizers
 354         if( is_nlin(bch, bp) ) {
 355           bch = '\n';  bp += 3;
 356         }
 357         else if( is_ccln(bch, bp) ) {
 358           wnext(cp, bch=':');  bp += 3;
 359         }
 360         else if( is_quot(bch, bp) ) {
 361           bch = '\"';  bp += 3;
 362         }
 363         else if( is_colon(bch) ) {
 364           bch = ':';
 365         }
 366       }
 367       wnext(cp,bch);  bpr = bch;
 368       bch = bp >= bep ? 0 : wnext(bp);
 369     }
 370     if( !ach || !bch ) break;
 371     if( !*ap && !*bp ) break;
 372     // if % on a and % on b and is fmt_spec
 373     if( is_per(ach) && is_per(bch) && (n=fmt_spec(ap)) > 0 ) {
 374       if( apr && apr != bpr ) wnext(cp,apr);
 375       wnext(cp,ach);  apr = ach;  ach = wnext(ap);
 376       // copy format data from a
 377       while( ach != 0 && --n >= 0 ) {
 378         wnext(cp, ach);  apr = ach;  ach = wnext(ap);
 379       }
 380       bpr = bch;  bch = bp >= bep ? 0 : wnext(bp);
 381       if( apr == '%' && bch == '%' ) {
 382         // copy %% format data from b
 383         bpr = bch;
 384         bch = bp >= bep ? 0 : wnext(bp);
 385       }
 386       else {
 387         // skip format data from b (ignore case)
 388         while( bch != 0 && ((bpr ^ apr) & ~('a'-'A')) ) {
 389           bpr = bch;
 390           bch = bp >= bep ? 0 : wnext(bp);
 391         }
 392         // hit eol and didn't find end of spec on b
 393         if( !bch && ((bpr ^ apr) & ~('a'-'A')) != 0 ) {
 394           fprintf(stderr, "line %d: missed spec: %s\n", no, (char*)asp);
 395           ret = false;
 396         }
 397       }
 398     }
 399     else {
 400       fprintf(stderr, "line %d: missed fmt: %s\n", no, (char*)asp);
 401       wnext(cp, bch);
 402       apr = ach;  ach = wnext(ap);
 403       bpr = bch;  bch = bp >= bep ? 0 : wnext(bp);
 404       ret = false;
 405     }
 406   }
 407   while( bch != 0 ) {
 408     wnext(cp, bch);  bpr = bch;
 409     bch = bp >= bep ? 0 : wnext(bp);
 410   }
 411   if( apr == '\n' && bpr != '\n' ) wnext(cp,'\n');
 412   wnext(cp, 0);
 413   return ret;
 414 }
 415
 416 void load(FILE *afp, FILE *bfp)
 417 {
 418   int no = 0;
 419   int ins = 0, rep = 0;
 420   uint8_t inp[MX_STR];
 421
 422   while( bgets(inp, sizeof(inp), afp) ) {
 423     ++no;
 424     uint8_t *bp = inp;
 425     string key = xlat(bp);
 426     if( bfp ) {
 427       if( !bgets(inp, sizeof(inp), bfp) ) {
 428         fprintf(stderr,"xlat file ended early\n");
 429         exit(1);
 430       }
 431       bp = inp;
 432     }
 433     else if( !is_sep(*bp++) ) {
 434       fprintf(stderr, "missing sep at line %d: %s", no, inp);
 435       exit(1);
 436     }
 437     string txt = xlat(bp);
 438     const char *val = (const char *)bp;
 439     uint8_t str[MX_STR];
 440     bool ok = chkfmt(no, (uint8_t*)key.c_str(), (uint8_t*)txt.c_str(), str);
 441       val = (const char*)str;
 442     Trans::iterator it = trans.lower_bound(key);
 443     if( it == trans.end() || it->first.compare(key) ) {
 444       trans.insert(it, Trans::value_type(key, tstring(val, ok)));
 445       ++ins;
 446     }
 447     else {
 448       it->second.assign(val);
 449       it->second.ok = ok;
 450       ++rep;
 451     }
 452   }
 453   fprintf(stderr,"***     ins %d, rep %d\n", ins, rep);
 454 }
 455
 456 void scan_po(FILE *ifp, FILE *ofp)
 457 {
 458   int no = 0;
 459   uint8_t ibfr[MX_STR], tbfr[MX_STR];
 460
 461   while( bgets(ibfr, sizeof(ibfr), ifp) ) {
 462     if( !prefix_is(ibfr, "msgid ") ) {
 463       if( nocmts && ibfr[0] == '#' ) continue;
 464       no += bputs(ibfr, ofp);
 465       continue;
 466     }
 467     uint8_t str[MX_STR]; xlat2(&ibfr[6], str);
 468     string key((const char*)str);
 469     if( !bgets(tbfr, sizeof(tbfr), ifp) ) {
 470       fprintf(stderr, "file truncated line %d: %s", no, ibfr);
 471       exit(1);
 472     }
 473     no += bputs(ibfr, ofp);
 474
 475     while( tbfr[0] == '"' ) {
 476       no += bputs(tbfr, ofp);
 477       xlat2(&tbfr[0], str);  key.append((const char*)str);
 478       if( !bgets(tbfr, sizeof(tbfr), ifp) ) {
 479         fprintf(stderr, "file truncated line %d: %s", no, ibfr);
 480         exit(1);
 481       }
 482     }
 483     if( !prefix_is(tbfr, "msgstr ") ) {
 484       fprintf(stderr, "file truncated line %d: %s", no, ibfr);
 485       exit(1);
 486     }
 487
 488     if( !ofp ) {
 489       if( !key.size() ) continue;
 490       xlat3(key.c_str(), str);
 491       printf("%s\n", (char *)str);
 492       continue;
 493     }
 494
 495     Trans::iterator it = trans.lower_bound(key);
 496     if( it == trans.end() || it->first.compare(key) ) {
 497       fprintf(stderr, "no trans line %d: %s\n", no, ibfr);
 498       xlat3(key.c_str(), &tbfr[7]);
 499       //no += bputs(tbfr, ofp);
 500       no += bputs((uint8_t*)"msgstr \"\"", ofp);
 501     }
 502     else if( 0 && !it->second.ok ) {
 503       fprintf(stderr, "bad fmt line %d: %s\n", no, ibfr);
 504       xlat3(it->first.c_str(), &tbfr[7]);
 505       no += bputs(tbfr, ofp);
 506       xlat3(it->second.c_str(), str);
 507       bput((uint8_t*)"#msgstr ", ofp);
 508       no += bputs(str, ofp);
 509     }
 510     else {
 511       xlat3(it->second.c_str(), &tbfr[7]);
 512       no += bputs(tbfr, ofp);
 513     }
 514   }
 515   if( ifp != stdin ) fclose(ifp);
 516 }
 517
 518 void list_po(FILE *ifp, FILE *ofp, int xeqx = 0, int nnul = 0)
 519 {
 520   int no = 0;
 521   int dup = 0, nul = 0;
 522   uint8_t ibfr[MX_STR], tbfr[MX_STR];
 523
 524   while( bgets(ibfr, sizeof(ibfr), ifp) ) {
 525     ++no;
 526     if( !prefix_is(ibfr, "msgid ") ) continue;
 527     uint8_t str[MX_STR]; xlat2(&ibfr[6], str);
 528     string key((const char*)str);
 529     if( !bgets(tbfr, sizeof(tbfr), ifp) ) {
 530       fprintf(stderr, "file truncated line %d: %s", no, ibfr);
 531       exit(1);
 532     }
 533     ++no;
 534
 535     while( tbfr[0] == '"' ) {
 536       xlat2(&tbfr[0], str);  key.append((const char*)str);
 537       if( !bgets(tbfr, sizeof(tbfr), ifp) ) {
 538         fprintf(stderr, "file truncated line %d: %s", no, ibfr);
 539         exit(1);
 540       }
 541       ++no;
 542     }
 543     if( !prefix_is(tbfr, "msgstr ") ) {
 544       fprintf(stderr, "file truncated line %d: %s", no, ibfr);
 545       exit(1);
 546     }
 547
 548     xlat2(&tbfr[7], str);
 549     string txt((const char*)str);
 550
 551     while( bgets(tbfr, sizeof(tbfr), ifp) && tbfr[0] == '"' ) {
 552       xlat2(&tbfr[0], str);  txt.append((const char*)str);
 553       ++no;
 554     }
 555     if( nnul && !txt.size() ) {
 556       ++nul;
 557       if( nnul > 0 ) continue;
 558     }
 559     else if( xeqx && !key.compare(txt) ) {
 560        ++dup;
 561        if( xeqx > 0 ) continue;
 562     }
 563     else if( nnul < 0 || xeqx < 0 ) continue;
 564     xlat4(key.c_str(), str);
 565     fprintf(ofp, "%s,", (char *)str);
 566     xlat4(txt.c_str(), str);
 567     fprintf(ofp, "%s\n", (char *)str);
 568   }
 569   fprintf(stderr, "*** dup %d, nul %d\n", dup, nul);
 570 }
 571
 572 static void usage(const char *av0)
 573 {
 574   printf("list csv    %s csv < data.csv > data.po\n",av0);
 575   printf("list po     %s po < data.po > data.csv\n",av0);
 576   printf("list po     %s dups < data.po\n",av0);
 577   printf("list po     %s nodups < data.po\n",av0);
 578   printf("get strings %s key  < xgettext.po\n",av0);
 579   printf("gen xlation %s xlat   xgettext.po xlat.csv\n",av0);
 580   printf("gen xlation %s xlat - text,xlat ... < xgettext.po\n",av0);
 581   exit(1);
 582 }
 583
 584 int main(int ac, char **av)
 585 {
 586   if( ac == 1 ) usage(av[0]);
 587
 588   // if to rework google xlat output
 589   if( getenv("GOOG") ) goog = true;
 590   if( getenv("NOCMTS") ) nocmts = true;
 591
 592   if( !strcmp(av[1],"csv") ) {  // test csv
 593     load(stdin, 0);
 594     for( Trans::iterator it = trans.begin(); it!=trans.end(); ++it ) {
 595       uint8_t str1[MX_STR];  xlat3(it->first.c_str(), str1);
 596       printf("msgid %s\n", (char *)str1);
 597       uint8_t str2[MX_STR];  xlat3(it->second.c_str(), str2);
 598       printf("msgstr %s\n\n", (char *)str2);
 599     }
 600     return 0;
 601   }
 602
 603   if( !strcmp(av[1],"dups") ) {  // test po
 604     list_po(stdin, stdout, -1, -1);
 605     return 0;
 606   }
 607
 608   if( !strcmp(av[1],"nodups") ) {  // test po
 609     list_po(stdin, stdout, 1, 1);
 610     return 0;
 611   }
 612
 613   if( !strcmp(av[1],"po") ) {  // test po
 614     list_po(stdin, stdout);
 615     return 0;
 616   }
 617
 618   if( !strcmp(av[1],"key") ) {
 619     scan_po(stdin, 0);
 620     return 0;
 621   }
 622
 623   if( ac < 3 ) usage(av[0]);
 624
 625   FILE *ifp = !strcmp(av[2],"-") ? stdin : fopen(av[2], "r");
 626   if( !ifp ) { perror(av[2]);  exit(1); }
 627
 628 //  if( ac < 4 ) usage(av[0]);
 629
 630   if( strcmp(av[1],"xlat") ) {
 631     fprintf(stderr,"unkn cmd: %s\n", av[1]);
 632     return 1;
 633   }
 634
 635   brkput = 1;
 636   for( int i=3; i<ac; ++i ) {  // create trans mapping
 637     fprintf(stderr,"*** load %s\n", av[i]);
 638     char fn[MX_STR*2];
 639     strncpy(fn, av[i], sizeof(fn));
 640     int k = 0;
 641     FILE *bfp = 0;
 642     // look for <filename> or <filename>,<filename>
 643     while( k<(int)sizeof(fn) && fn[k]!=0 && fn[k]!=',' ) ++k;
 644     if( k<(int)sizeof(fn) && fn[k]==',' ) {
 645       fn[k++] = 0;
 646       bfp = fopen(&fn[k], "r");
 647       if( !bfp ) { perror(&fn[k]);  exit(1); }
 648     }
 649     FILE *afp = fopen(&fn[0], "r");
 650     if( !afp ) { perror(&fn[0]);  exit(1); }
 651     load(afp, bfp);
 652     fclose(afp);
 653     if( bfp ) fclose(bfp);
 654   }
 655
 656   scan_po(ifp, stdout);
 657   return 0;
 658 }
 659