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     fprintf(out, "%s", tag->name);
 120     len += strlen(tag->name);
 121     start += len;
 122     /* handle individual tags which accept params */
 123     if ((MATCH("bl") || MATCH("pb") || MATCH("pv")) && !in_conditional)
 124     {
 125         if (*start == '|')
 126         {
 127             len++; start++;
 128             PUTCH(out, '(');
 129             /* TODO: need to verify that we are actually using the long form... */
 130             len += dump_arg(out, start, 5, true);
 131         }
 132     }
 133     else if (MATCH("d") || MATCH("D") || MATCH("mv") || MATCH("pS") || MATCH("pE") || MATCH("t") || MATCH("Tl"))
 134     {
 135         char temp[8] = {'\0'};
 136         int i = 0;
 137         /* tags which maybe have a number after them */
 138         while ((*start >= '0' && *start <= '9') || *start == '.')
 139         {
 140             temp[i++] = *start++;
 141         }
 142         if (i!= 0)
 143         {
 144             fprintf(out, "(%s)", temp);
 145             len += i;
 146         }
 147     }
 148     else if (MATCH("xl"))
 149     {
 150         char label = start[1];
 151         PUTCH(out, '(');
 152         int read = 1+dump_arg(out, start+1, 4, false);
 153         len += read;
 154         start += read;
 155         if (*start>= '0' && *start <= '9')
 156         {
 157             images_with_subimages[image_count++] = label;
 158             PUTCH(out, ',');
 159             len += dump_arg(out, start, 1, false);
 160         }
 161         PUTCH(out, ')');
 162     }
 163     else if (MATCH("xd"))
 164     {
 165         char label = start[0];
 166         int i=0;
 167         while (i<image_count)
 168         {
 169             if (images_with_subimages[i] == label)
 170                 break;
 171             i++;
 172         }
 173         PUTCH(out, '(');
 174         PUTCH(out, *start++); len++;
 175         if (i<image_count &&
 176             ((*start >= 'a' && *start <= 'z') ||
 177              (*start >= 'A' && *start <= 'Z')))
 178         {
 179             PUTCH(out, *start); len++;
 180         }
 181         PUTCH(out, ')');
 182     }
 183     else if (MATCH("x"))
 184     {
 185         PUTCH(out, '(');
 186         len += 1+dump_arg(out, start+1, 4, true);
 187     }
 188     else if (MATCH("Fl"))
 189     {
 190         PUTCH(out, '(');
 191         len += 1+dump_arg(out, start+1, 2, true);
 192     }
 193     else if (MATCH("C"))
 194     {
 195         fprintf(out, "%%Cd");
 196     }
 197     else if (MATCH("Cl"))
 198     {
 199         int read;
 200         char xalign = '\0', yalign = '\0';
 201         PUTCH(out, '(');
 202         read = 1+dump_arg(out, start+1, 2, false);
 203         len += read;
 204         start += read;
 205         switch (tolower(*start))
 206         {
 207             case 'l':
 208             case 'c':
 209             case 'r':
 210             case '+':
 211             case '-':
 212                 xalign = *start;
 213                 len++;
 214                 start++;
 215                 break;
 216             case 'd':
 217             case 'D':
 218             case 'i':
 219             case 'I':
 220             case 's':
 221             case 'S':
 222                 len++;
 223                 start++;
 224                 break;
 225         }
 226         PUTCH(out,',');
 227         read = dump_arg(out, start, 1, false);
 228         len += read;
 229         start += read;
 230         switch (tolower(*start))
 231         {
 232             case 't':
 233             case 'c':
 234             case 'b':
 235             case '+':
 236             case '-':
 237                 yalign = *start;
 238                 len++;
 239                 start++;
 240                 break;
 241             case 'd':
 242             case 'D':
 243             case 'i':
 244             case 'I':
 245             case 's':
 246             case 'S':
 247                 len++;
 248                 start++;
 249                 break;
 250         }
 251         PUTCH(out,',');
 252         read = dump_arg(out, start, 1, false);
 253         if (xalign)
 254         {
 255             if (xalign == '-')
 256                 xalign = 'l';
 257             if (xalign == '+')
 258                 xalign = 'r';
 259             fprintf(out, ",%c", xalign);
 260         }
 261         if (yalign)
 262         {
 263             if (yalign == '-')
 264                 yalign = 't';
 265             if (yalign == '+')
 266                 yalign = 'b';
 267             fprintf(out, ",%s%c", xalign?"":"-,", yalign);
 268         }
 269         PUTCH(out, ')');
 270         len += read;
 271     }
 272     else if (MATCH("Vd") || MATCH("VI"))
 273     {
 274         PUTCH(out, '(');
 275         PUTCH(out, *start); len++;
 276         PUTCH(out, ')');
 277     }
 278     else if (MATCH("Vp"))
 279     {
 280         /* NOTE: almost certainly needs work */
 281         PUTCH(out, '(');
 282         len += 1+dump_arg(out, start+1, 3, true);
 283     }
 284     else if (MATCH("Vi"))
 285     {
 286         int read = 1;
 287
 288         PUTCH(out, '(');
 289         if ((start[1] >= 'a' && start[1] <= 'z') ||
 290             (start[1] >= 'A' && start[1] <= 'Z'))
 291         {
 292             read = 1+dump_arg(out, start+1, 1, false);
 293         }
 294         else
 295         {
 296             PUTCH(out, '-');
 297         }
 298         PUTCH(out, ',');
 299         len += read + dump_viewport_tags(out, start+read);
 300     }
 301     else if (MATCH("Vl") || MATCH("Vi"))
 302     {
 303         int read;
 304         PUTCH(out, '(');
 305         read = 1+dump_arg(out, start+1, 1, false);
 306         PUTCH(out, ',');
 307         len += read + dump_viewport_tags(out, start+read);
 308     }
 309     else if (MATCH("V"))
 310     {
 311         PUTCH(out, '(');
 312         len += 1+dump_viewport_tags(out, start+1);
 313     }
 314     else if (MATCH("X"))
 315     {
 316         if (*start == 'd')
 317         {
 318             fprintf(out, "(d)");
 319             len ++;
 320         }
 321         else
 322         {
 323             PUTCH(out, '(');
 324             len += 1+dump_arg(out, start+1, 1, true);
 325         }
 326     }
 327     else if (MATCH("St") || MATCH("Sx"))
 328     {
 329         PUTCH(out, '(');
 330         len += 1+dump_arg(out, start+1, 1, true);
 331     }
 332
 333     else if (MATCH("T"))
 334     {
 335         PUTCH(out, '(');
 336         len += 1+dump_arg(out, start+1, 5, true);
 337     }
 338     return len;
 339 }
 340
 341 void parse_text(const char* in, FILE* out)
 342 {
 343     const char* end = in+strlen(in);
 344     int level = 0;
 345     int len;
 346 top:
 347     while (in < end && *in)
 348     {
 349         if (*in == '%')
 350         {
 351             PUTCH(out, *in++);
 352             switch(*in)
 353             {
 354
 355                 case '%':
 356                 case '<':
 357                 case '|':
 358                 case '>':
 359                 case ';':
 360                 case '#':
 361                 case ')':
 362                 case '(':
 363                 case ',':
 364                     PUTCH(out, *in++);
 365                     goto top;
 366                     break;
 367                 case '?':
 368                     PUTCH(out, *in++);
 369                     break;
 370             }
 371             len = parse_tag(out, in, level>0);
 372             if (len < 0)
 373             {
 374                 PUTCH(out, *in++);
 375             }
 376             else
 377             {
 378                 in += len;
 379             }
 380         }
 381         else if (*in == '<')
 382         {
 383             level++;
 384             PUTCH(out, *in++);
 385         }
 386         else if (*in == '>')
 387         {
 388             level--;
 389             PUTCH(out, *in++);
 390         }
 391         else if (*in == '|')
 392         {
 393             if (level == 0)
 394             {
 395                 PUTCH(out, '%');
 396             }
 397             PUTCH(out, *in++);
 398         }
 399         else if (*in == '#')
 400         {
 401             while (*in && *in != '\n')
 402             {
 403                 PUTCH(out, *in++);
 404             }
 405         }
 406         else if (*in == ';')
 407         {
 408             PUTCH(out, *in++);
 409         }
 410         else
 411         {
 412             if (find_escape_character(*in))
 413             {
 414                 PUTCH(out, '%');
 415             }
 416             PUTCH(out, *in++);
 417         }
 418     }
 419 }
 420
 421 int main(int argc, char* argv[])
 422 {
 423     char buffer[10*1024], temp[512];
 424     FILE *in, *out = stdout;
 425     int filearg = 1, i=0;
 426     if( (argc < 2) ||
 427         strcmp(argv[1],"-h") == 0 ||
 428         strcmp(argv[1],"--help") == 0 )
 429     {
 430         printf("Usage: %s [OPTIONS] infile [outfile]\n", argv[0]);
 431         printf("\nOPTIONS:\n");
 432         printf("\t-c\tDon't use new viewport colour tags (non-mono displays only)\n");
 433         printf("\t-m\tSkin is for a mono display (different viewport tags)\n");
 434         return 0;
 435     }
 436
 437     while ((argc > filearg) && argv[filearg][0] == '-')
 438     {
 439         i=1;
 440         while (argv[filearg][i])
 441         {
 442             switch(argv[filearg][i])
 443             {
 444                 case 'c': /* disable new colour tags */
 445                     use_new_vp_tags = false;
 446                     break;
 447                 case 'm': /* skin is for a mono display */
 448                     is_mono_display = true;
 449                     break;
 450             }
 451             i++;
 452         }
 453         filearg++;
 454     }
 455     if (argc == filearg)
 456     {
 457         printf("Missing input filename\n");
 458         return 1;
 459     }
 460
 461     in = fopen(argv[filearg], "r");
 462     if (!in)
 463         return 1;
 464     while (fgets(temp, 512, in))
 465         strcat(buffer, temp);
 466     fclose(in);
 467     filearg++;
 468
 469     if (argc > filearg)
 470     {
 471         out = fopen(argv[filearg], "w");
 472         if (!out)
 473         {
 474             printf("Couldn't open %s\n", argv[filearg]);
 475             return 1;
 476         }
 477     }
 478
 479     parse_text(buffer, out);
 480     if (out != stdout)
 481         fclose(out);
 482     return 0;
 483 }