utils/skinupdater/skinupdater.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id: tag_table.c 26346 2010-05-28 02:30:27Z jdgordon $
   9  *
  10  * Copyright (C) 2010 Jonathan Gordon
  11  *
  12  * This program is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU General Public License
  14  * as published by the Free Software Foundation; either version 2
  15  * of the License, or (at your option) any later version.
  16  *
  17  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  18  * KIND, either express or implied.
  19  *
  20  ****************************************************************************/
  21
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <stdbool.h>
  25 #include <string.h>
  26 #include <ctype.h>
  27 #include "tag_table.h"
  28
  29 #define PUTCH(out, c) fprintf(out, "%c", c)
  30 extern struct tag_info legal_tags[];
  31
  32 char images_with_subimages[100];
  33 int image_count = 0;
  34
  35 /** Command line setting **/
  36 bool is_mono_display = false;
  37 bool use_new_vp_tags = true;
  38
  39
  40 /* dump "count" args to output replacing '|' with ',' except after the last count.
  41  * return the amount of chars read. (start+return will be after the last | )
  42  */
  43 int dump_arg(FILE* out, const char* start, int count, bool close)
  44 {
  45     int l = 0;
  46     while (count)
  47     {
  48         if (start[l] == '|')
  49         {
  50             if (count > 1)
  51             {
  52                 PUTCH(out, ',');
  53             } else if (close) {
  54                 PUTCH(out, ')');
  55             }
  56             count--;
  57         } else {
  58             if (find_escape_character(start[l]))
  59             {
  60                 PUTCH(out, '%');
  61             }
  62             PUTCH(out, start[l]);
  63         }
  64         l++;
  65     }
  66     return l;
  67 }
  68
  69 int dump_viewport_tags(FILE* out, const char* start)
  70 {
  71     int len = 0;
  72     if (is_mono_display)
  73     {
  74         return dump_arg(out, start, 5, true);
  75     }
  76     else
  77     {
  78         int arg_count = use_new_vp_tags?5:7;
  79         len += dump_arg(out, start, arg_count, true);
  80         if (!use_new_vp_tags)
  81             return len;
  82         if (start[len] != '-')
  83         {
  84             fprintf(out, "%%Vf(");
  85             len += dump_arg(out, start+len, 1, true);
  86         }
  87         else
  88         {
  89             while (start[len++] != '|');
  90         }
  91         if (start[len] != '-')
  92         {
  93             fprintf(out, "%%Vb(");
  94             len += dump_arg(out, start+len, 1, true);
  95         }
  96         else
  97         {
  98             while (start[len++] != '|');
  99         }
 100     }
 101     return len;
 102 }
 103
 104 #define MATCH(s) (!strcmp(tag->name, s))
 105 int parse_tag(FILE* out, const char* start, bool in_conditional)
 106 {
 107     struct tag_info *tag;
 108     int len = 0;
 109     for(tag = legal_tags;
 110         tag->name[0] && strncmp(start, tag->name, strlen(tag->name)) != 0;
 111         tag++) ;
 112     if (!tag->name[0])
 113         return -1;
 114     if (tag->params[0] == '\0')
 115     {
 116         fprintf(out, "%s", tag->name);
 117         return strlen(tag->name);
 118     }
 119     if (!strcmp(tag->name, "C"))
 120     {
 121         fprintf(out, "Cd");
 122         return 1;
 123     }
 124
 125     fprintf(out, "%s", tag->name);
 126     len += strlen(tag->name);
 127     start += len;
 128     /* handle individual tags which accept params */
 129     if ((MATCH("bl") || MATCH("pb") || MATCH("pv")) && !in_conditional)
 130     {
 131         if (*start == '|')
 132         {
 133             int i=0;
 134             char filename[128];
 135             len++; start++;
 136             PUTCH(out, '(');
 137             /* |file|x|y|width|height| -> (x,y,width,height,file) */
 138             while (start[i] != '|')
 139             {
 140                 filename[i] = start[i];
 141                 i++;
 142             }
 143             filename[i] = '\0';
 144             len +=i+1;
 145             start += i+1;
 146             /* TODO: need to verify that we are actually using the long form... */
 147             len += dump_arg(out, start, 4, false);
 148             if (i>0)
 149             {
 150                 fprintf(out, ",%s", filename);
 151             }
 152             PUTCH(out, ')');
 153         }
 154     }
 155     else if (MATCH("d") || MATCH("D") || MATCH("mv") || MATCH("pS") || MATCH("pE") || MATCH("t") || MATCH("Tl"))
 156     {
 157         char temp[8] = {'\0'};
 158         int i = 0;
 159         /* tags which maybe have a number after them */
 160         while ((*start >= '0' && *start <= '9') || *start == '.')
 161         {
 162             temp[i++] = *start++;
 163         }
 164         if (i!= 0)
 165         {
 166             fprintf(out, "(%s)", temp);
 167             len += i;
 168         }
 169     }
 170     else if (MATCH("xl"))
 171     {
 172         char label = start[1];
 173         PUTCH(out, '(');
 174         int read = 1+dump_arg(out, start+1, 4, false);
 175         len += read;
 176         start += read;
 177         if (*start>= '0' && *start <= '9')
 178         {
 179             images_with_subimages[image_count++] = label;
 180             PUTCH(out, ',');
 181             len += dump_arg(out, start, 1, false);
 182         }
 183         PUTCH(out, ')');
 184     }
 185     else if (MATCH("xd"))
 186     {
 187         char label = start[0];
 188         int i=0;
 189         while (i<image_count)
 190         {
 191             if (images_with_subimages[i] == label)
 192                 break;
 193             i++;
 194         }
 195         PUTCH(out, '(');
 196         PUTCH(out, *start++); len++;
 197         if (i<image_count &&
 198             ((*start >= 'a' && *start <= 'z') ||
 199              (*start >= 'A' && *start <= 'Z')))
 200         {
 201             PUTCH(out, *start); len++;
 202         }
 203         PUTCH(out, ')');
 204     }
 205     else if (MATCH("x"))
 206     {
 207         PUTCH(out, '(');
 208         len += 1+dump_arg(out, start+1, 4, true);
 209     }
 210     else if (MATCH("Fl"))
 211     {
 212         PUTCH(out, '(');
 213         len += 1+dump_arg(out, start+1, 2, true);
 214     }
 215     else if (MATCH("Cl"))
 216     {
 217         int read;
 218         char xalign = '\0', yalign = '\0';
 219         PUTCH(out, '(');
 220         read = 1+dump_arg(out, start+1, 2, false);
 221         len += read;
 222         start += read;
 223         switch (tolower(*start))
 224         {
 225             case 'l':
 226             case 'c':
 227             case 'r':
 228             case '+':
 229             case '-':
 230                 xalign = *start;
 231                 len++;
 232                 start++;
 233                 break;
 234             case 'd':
 235             case 'D':
 236             case 'i':
 237             case 'I':
 238             case 's':
 239             case 'S':
 240                 len++;
 241                 start++;
 242                 break;
 243         }
 244         PUTCH(out,',');
 245         read = dump_arg(out, start, 1, false);
 246         len += read;
 247         start += read;
 248         switch (tolower(*start))
 249         {
 250             case 't':
 251             case 'c':
 252             case 'b':
 253             case '+':
 254             case '-':
 255                 yalign = *start;
 256                 len++;
 257                 start++;
 258                 break;
 259             case 'd':
 260             case 'D':
 261             case 'i':
 262             case 'I':
 263             case 's':
 264             case 'S':
 265                 len++;
 266                 start++;
 267                 break;
 268         }
 269         PUTCH(out,',');
 270         read = dump_arg(out, start, 1, false);
 271         if (xalign)
 272         {
 273             if (xalign == '-')
 274                 xalign = 'l';
 275             if (xalign == '+')
 276                 xalign = 'r';
 277             fprintf(out, ",%c", xalign);
 278         }
 279         if (yalign)
 280         {
 281             if (yalign == '-')
 282                 yalign = 't';
 283             if (yalign == '+')
 284                 yalign = 'b';
 285             fprintf(out, ",%s%c", xalign?"":"-,", yalign);
 286         }
 287         PUTCH(out, ')');
 288         len += read;
 289     }
 290     else if (MATCH("Vd") || MATCH("VI"))
 291     {
 292         PUTCH(out, '(');
 293         PUTCH(out, *start); len++;
 294         PUTCH(out, ')');
 295     }
 296     else if (MATCH("Vp"))
 297     {
 298         int read;
 299         /* NOTE: almost certainly needs work */
 300         PUTCH(out, '(');
 301         read = 1+dump_arg(out, start+1, 1, false);
 302         PUTCH(out, ',');
 303         while (start[read] != '|')
 304         {
 305             PUTCH(out, start[read++]);
 306         }
 307         PUTCH(out, ',');
 308         read++;
 309         while (start[read] != '|')
 310         {
 311             PUTCH(out, start[read++]);
 312         }
 313         PUTCH(out, ')');
 314         read++;
 315         len += read;
 316     }
 317     else if (MATCH("Vi"))
 318     {
 319         int read = 1;
 320
 321         PUTCH(out, '(');
 322         if ((start[1] >= 'a' && start[1] <= 'z') ||
 323             (start[1] >= 'A' && start[1] <= 'Z'))
 324         {
 325             read = 1+dump_arg(out, start+1, 1, false);
 326         }
 327         else
 328         {
 329             PUTCH(out, '-');
 330         }
 331         PUTCH(out, ',');
 332         len += read + dump_viewport_tags(out, start+read);
 333     }
 334     else if (MATCH("Vl") || MATCH("Vi"))
 335     {
 336         int read;
 337         PUTCH(out, '(');
 338         read = 1+dump_arg(out, start+1, 1, false);
 339         PUTCH(out, ',');
 340         len += read + dump_viewport_tags(out, start+read);
 341     }
 342     else if (MATCH("V"))
 343     {
 344         PUTCH(out, '(');
 345         len += 1+dump_viewport_tags(out, start+1);
 346     }
 347     else if (MATCH("X"))
 348     {
 349         if (*start == 'd')
 350         {
 351             fprintf(out, "(d)");
 352             len ++;
 353         }
 354         else
 355         {
 356             PUTCH(out, '(');
 357             len += 1+dump_arg(out, start+1, 1, true);
 358         }
 359     }
 360     else if (MATCH("St") || MATCH("Sx"))
 361     {
 362         PUTCH(out, '(');
 363         len += 1+dump_arg(out, start+1, 1, true);
 364     }
 365
 366     else if (MATCH("T"))
 367     {
 368         PUTCH(out, '(');
 369         len += 1+dump_arg(out, start+1, 5, true);
 370     }
 371     return len;
 372 }
 373
 374 void parse_text(const char* in, FILE* out)
 375 {
 376     const char* end = in+strlen(in);
 377     int level = 0;
 378     int len;
 379 top:
 380     while (in < end && *in)
 381     {
 382         if (*in == '%')
 383         {
 384             PUTCH(out, *in++);
 385             switch(*in)
 386             {
 387
 388                 case '%':
 389                 case '<':
 390                 case '|':
 391                 case '>':
 392                 case ';':
 393                 case '#':
 394                 case ')':
 395                 case '(':
 396                 case ',':
 397                     PUTCH(out, *in++);
 398                     goto top;
 399                     break;
 400                 case '?':
 401                     if (in[1] == 'C' && in[2] == '<')
 402                     {
 403                         fprintf(out, "?C");
 404                         in += 2;
 405                         goto top;
 406                     }
 407                     else
 408                     {
 409                         PUTCH(out, *in++);
 410                     }
 411                     break;
 412             }
 413             len = parse_tag(out, in, level>0);
 414             if (len < 0)
 415             {
 416                 PUTCH(out, *in++);
 417             }
 418             else
 419             {
 420                 in += len;
 421             }
 422         }
 423         else if (*in == '<')
 424         {
 425             level++;
 426             PUTCH(out, *in++);
 427         }
 428         else if (*in == '>')
 429         {
 430             level--;
 431             PUTCH(out, *in++);
 432         }
 433         else if (*in == '|')
 434         {
 435             if (level == 0)
 436             {
 437                 PUTCH(out, '%');
 438             }
 439             PUTCH(out, *in++);
 440         }
 441         else if (*in == '#')
 442         {
 443             while (*in && *in != '\n')
 444             {
 445                 PUTCH(out, *in++);
 446             }
 447         }
 448         else if (*in == ';')
 449         {
 450             PUTCH(out, *in++);
 451         }
 452         else
 453         {
 454             if (find_escape_character(*in))
 455             {
 456                 PUTCH(out, '%');
 457             }
 458             PUTCH(out, *in++);
 459         }
 460     }
 461 }
 462
 463 int main(int argc, char* argv[])
 464 {
 465     char buffer[10*1024], temp[512];
 466     FILE *in, *out = stdout;
 467     int filearg = 1, i=0;
 468     if( (argc < 2) ||
 469         strcmp(argv[1],"-h") == 0 ||
 470         strcmp(argv[1],"--help") == 0 )
 471     {
 472         printf("Usage: %s [OPTIONS] infile [outfile]\n", argv[0]);
 473         printf("\nOPTIONS:\n");
 474         printf("\t-c\tDon't use new viewport colour tags (non-mono displays only)\n");
 475         printf("\t-m\tSkin is for a mono display (different viewport tags)\n");
 476         return 0;
 477     }
 478
 479     while ((argc > filearg) && argv[filearg][0] == '-')
 480     {
 481         i=1;
 482         while (argv[filearg][i])
 483         {
 484             switch(argv[filearg][i])
 485             {
 486                 case 'c': /* disable new colour tags */
 487                     use_new_vp_tags = false;
 488                     break;
 489                 case 'm': /* skin is for a mono display */
 490                     is_mono_display = true;
 491                     break;
 492             }
 493             i++;
 494         }
 495         filearg++;
 496     }
 497     if (argc == filearg)
 498     {
 499         printf("Missing input filename\n");
 500         return 1;
 501     }
 502
 503     in = fopen(argv[filearg], "r");
 504     if (!in)
 505         return 1;
 506     while (fgets(temp, 512, in))
 507         strcat(buffer, temp);
 508     fclose(in);
 509     filearg++;
 510
 511     if (argc > filearg)
 512     {
 513         out = fopen(argv[filearg], "w");
 514         if (!out)
 515         {
 516             printf("Couldn't open %s\n", argv[filearg]);
 517             return 1;
 518         }
 519     }
 520
 521     parse_text(buffer, out);
 522     if (out != stdout)
 523         fclose(out);
 524     return 0;
 525 }