apps/filetypes.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *
   8  * $Id$
   9  *
  10  * Copyright (C) 2004 Henrik Backe
  11  *
  12  * All files in this archive are subject to the GNU General Public License.
  13  * See the file COPYING in the source tree root for full license agreement.
  14  *
  15  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  16  * KIND, either express or implied.
  17  *
  18  ****************************************************************************/
  19
  20 #include <stdio.h>
  21 #include <string.h>
  22 #include <stdlib.h>
  23 #include <stdbool.h>
  24
  25 #include "sprintf.h"
  26 #include "settings.h"
  27 #include "debug.h"
  28 #include "lang.h"
  29 #include "language.h"
  30 #include "kernel.h"
  31 #include "plugin.h"
  32 #include "filetypes.h"
  33 #include "screens.h"
  34 #include "icons.h"
  35 #include "dir.h"
  36 #include "file.h"
  37 #include "icons.h"
  38 #include "splash.h"
  39
  40 /* max plugin name size without extensions and path */
  41 #define MAX_PLUGIN_LENGTH 32
  42
  43 /* max filetypes (plugins & icons stored here) */
  44 #if CONFIG_CODEC == SWCODEC
  45 #define MAX_FILETYPES 64
  46 #else
  47 #define MAX_FILETYPES 32
  48 #endif
  49
  50 /* max exttypes (extensions stored here) */
  51 #if CONFIG_CODEC == SWCODEC
  52 /* Software codecs require more file extensions */
  53 #define MAX_EXTTYPES 64
  54 #else
  55 #define MAX_EXTTYPES 32
  56 #endif
  57
  58 /* string buffer length */
  59 #define STRING_BUFFER_SIZE 512
  60
  61 /* number of bytes for the binary icon */
  62 #define ICON_LENGTH 6
  63
  64 /* mask for dynamic filetype info in attribute */
  65 #define FILETYPES_MASK 0xFF00
  66
  67 /* filenames */
  68 #define ROCK_EXTENSION ".rock"
  69 #define VIEWERS_CONFIG ROCKBOX_DIR "/viewers.config"
  70 #define VIEWERS_DIR    ROCKBOX_DIR "/viewers"
  71
  72 /* global variables */
  73 static int    cnt_filetypes;
  74 static int    cnt_exttypes;
  75 static struct ext_type  exttypes [MAX_EXTTYPES];
  76 static struct file_type filetypes[MAX_FILETYPES];
  77 static int    first_soft_exttype;
  78 static int    first_soft_filetype;
  79 static char*  next_free_string;
  80 static char   plugin_name[sizeof(VIEWERS_DIR) + 7 + MAX_PLUGIN_LENGTH];
  81 static char   string_buffer[STRING_BUFFER_SIZE];
  82
  83 /* prototypes */
  84 #ifdef HAVE_LCD_BITMAP
  85 static char*  string2icon(const char*);
  86 static int    add_plugin(char*,char*);
  87 #else
  88 static int    add_plugin(char*);
  89 #endif
  90 static char*  get_string(const char*);
  91 static int    find_attr_index(int);
  92 static bool   read_config(const char*);
  93 static void   rm_whitespaces(char*);
  94 static void   scan_plugins(void);
  95
  96 /* initialize dynamic filetypes (called at boot from tree.c) */
  97 void filetype_init(void)
  98 {
  99     int cnt,i,ix;
 100     const struct filetype* ftypes;
 101
 102     memset(exttypes,0,sizeof(exttypes));
 103     memset(filetypes,0,sizeof(filetypes));
 104     next_free_string=string_buffer;
 105
 106 /* The special filetype folder must always be stored at index 0 */
 107 #ifdef HAVE_LCD_BITMAP
 108     if (!filetypes[0].icon)
 109         filetypes[0].icon = bitmap_icons_6x8[Icon_Folder];
 110 #else
 111     if (!filetypes[0].icon)
 112         filetypes[0].icon = Icon_Folder;
 113     for (i=1; i < MAX_FILETYPES; i++)
 114         filetypes[i].icon = -1;
 115 #endif
 116
 117     /* register hardcoded filetypes */
 118     tree_get_filetypes(&ftypes, &cnt);
 119     cnt_exttypes=0;
 120     cnt_filetypes=0;
 121
 122     for (i = 0; i < cnt ; i++)
 123     {
 124         ix = ((ftypes[i].tree_attr & FILETYPES_MASK) >> 8);
 125         if (ix < MAX_FILETYPES && i < MAX_EXTTYPES)
 126         {
 127 #ifdef HAVE_LCD_BITMAP
 128             if (filetypes[ix].icon == NULL)
 129                 filetypes[ix].icon=bitmap_icons_6x8[ftypes[i].icon];
 130 #else
 131             if (filetypes[ix].icon == -1)
 132                 filetypes[ix].icon=ftypes[i].icon;
 133 #endif
 134             if (ix > cnt_filetypes)
 135                 cnt_filetypes=ix;
 136             exttypes[cnt_exttypes].type=&filetypes[ix];
 137             exttypes[cnt_exttypes].extension=ftypes[i].extension;
 138             cnt_exttypes++;
 139         }
 140     }
 141     first_soft_exttype=cnt_exttypes;
 142     cnt_filetypes++;
 143     first_soft_filetype=cnt_filetypes;
 144
 145     /* register dynamic filetypes */
 146     read_config(VIEWERS_CONFIG);
 147     scan_plugins();
 148 }
 149
 150 /* get icon */
 151 #ifdef HAVE_LCD_BITMAP
 152 const unsigned char* filetype_get_icon(int attr)
 153 #else
 154 int   filetype_get_icon(int attr)
 155 #endif
 156 {
 157     int ix;
 158
 159     ix = find_attr_index(attr);
 160
 161     if (ix < 0)
 162     {
 163 #ifdef HAVE_LCD_BITMAP
 164         return NULL;
 165 #else
 166         return Icon_Unknown;
 167 #endif
 168     }
 169     else
 170     {
 171         return filetypes[ix].icon;
 172     }
 173 }
 174
 175 /* get plugin */
 176 char* filetype_get_plugin(const struct entry* file)
 177 {
 178     int ix;
 179
 180     ix=find_attr_index(file->attr);
 181
 182     if (ix < 0)
 183     {
 184         return NULL;
 185     }
 186
 187     if ((filetypes[ix].plugin == NULL) ||
 188         (strlen(filetypes[ix].plugin) > MAX_PLUGIN_LENGTH))
 189         return NULL;
 190
 191     snprintf(plugin_name, sizeof(plugin_name),
 192              "%s/%s.rock", ROCKBOX_DIR, filetypes[ix].plugin);
 193
 194     return plugin_name;
 195 }
 196
 197 /* check if filetype is supported */
 198 bool filetype_supported(int attr)
 199 {
 200     int ix;
 201
 202     ix=find_attr_index(attr);
 203
 204     /* hard filetypes and soft filetypes with plugins is supported */
 205     if (ix > 0)
 206         if (filetypes[ix].plugin || ix < first_soft_filetype)
 207             return true;
 208
 209     return false;
 210 }
 211
 212 /* get the "dynamic" attribute for an extension */
 213 int filetype_get_attr(const char* name)
 214 {
 215     int i;
 216     const char *cp = strrchr(name,'.');
 217
 218     if (!cp)  /* no extension? -> can't be a supported type */
 219         return 0;
 220     cp++;
 221
 222     for (i=0; i < cnt_exttypes; i++)
 223     {
 224         if (exttypes[i].extension)
 225         {
 226             if (!strcasecmp(cp,exttypes[i].extension))
 227             {
 228                 return ((((unsigned long)exttypes[i].type -
 229                           (unsigned long)&filetypes[0]) /
 230                          sizeof(struct file_type)) << 8);
 231             }
 232         }
 233     }
 234
 235     return 0;
 236 }
 237
 238 /* fill a menu list with viewers (used in onplay.c) */
 239 int filetype_load_menu(struct menu_item*  menu,int max_items)
 240 {
 241     int i;
 242     char *cp;
 243     int cnt=0;
 244
 245     for (i=0; i < cnt_filetypes; i++)
 246     {
 247         if (filetypes[i].plugin)
 248         {
 249             int j;
 250             for (j=0;j<cnt;j++) /* check if the plugin is in the list yet */
 251             {
 252                 if (!strcmp(menu[j].desc,filetypes[i].plugin))
 253                     break;
 254             }
 255             if (j<cnt) continue; /* it is so grab the next plugin */
 256             cp=strrchr(filetypes[i].plugin,'/');
 257             if (cp) cp++;
 258             else    cp=filetypes[i].plugin;
 259             menu[cnt].desc = (unsigned char *)cp;
 260             cnt++;
 261             if (cnt == max_items)
 262                 break;
 263         }
 264     }
 265     return cnt;
 266 }
 267
 268 /* start a plugin with an argument (called from onplay.c) */
 269 int filetype_load_plugin(const char* plugin, char* file)
 270 {
 271     int fd;
 272     snprintf(plugin_name,sizeof(plugin_name),"%s/%s.rock",
 273              VIEWERS_DIR,plugin);
 274     if ((fd = open(plugin_name,O_RDONLY))>=0)
 275     {
 276         close(fd);
 277         return plugin_load(plugin_name,file);
 278     }
 279     else
 280     {
 281         snprintf(plugin_name,sizeof(plugin_name),"%s/%s.rock",
 282              PLUGIN_DIR,plugin);
 283         if ((fd = open(plugin_name,O_RDONLY))>=0)
 284         {
 285             close(fd);
 286             return plugin_load(plugin_name,file);
 287         }
 288     }
 289     return PLUGIN_ERROR;
 290 }
 291
 292 /* get index to filetypes[] from the file attribute */
 293 static int find_attr_index(int attr)
 294 {
 295     int ix;
 296     ix = ((attr & FILETYPES_MASK) >> 8);
 297
 298     if ((attr & ATTR_DIRECTORY)==ATTR_DIRECTORY)
 299     {
 300         ix=0;
 301     }
 302     else
 303     {
 304         if (ix==0)
 305             ix=-1;
 306         if (ix > cnt_filetypes)
 307             ix=-1;
 308         else
 309             if ((filetypes[ix].plugin == NULL) &&
 310 #ifdef HAVE_LCD_BITMAP
 311                 (filetypes[ix].icon == NULL)
 312 #else
 313                 (filetypes[ix].icon == -1)
 314 #endif
 315                 )
 316                 ix=-1;
 317     }
 318
 319     return ix;
 320 }
 321
 322 /* scan the plugin directory and register filetypes */
 323 static void scan_plugins(void)
 324 {
 325     DIR *dir;
 326     struct dirent *entry;
 327     char* cp;
 328     char* dot;
 329     char* dash;
 330     int   ix;
 331     int   i;
 332     bool  found;
 333
 334     dir = opendir(VIEWERS_DIR);
 335     if(!dir)
 336         return;
 337
 338     while (true)
 339     {
 340         /* exttypes[] full, bail out */
 341         if (cnt_exttypes >= MAX_EXTTYPES)
 342         {
 343             gui_syncsplash(HZ, true, str(LANG_FILETYPES_EXTENSION_FULL));
 344             break;
 345         }
 346
 347         /* filetypes[] full, bail out */
 348         if (cnt_filetypes >= MAX_FILETYPES)
 349         {
 350             gui_syncsplash(HZ, true, str(LANG_FILETYPES_FULL));
 351             break;
 352         }
 353
 354         entry = readdir(dir);
 355
 356         if (!entry)
 357             break;
 358
 359         /* skip directories */
 360         if ((entry->attribute & ATTR_DIRECTORY))
 361             continue;
 362
 363         /* Skip FAT volume ID */
 364         if (entry->attribute & ATTR_VOLUME_ID)
 365             continue;
 366
 367         /* filter out dotfiles and hidden files */
 368         if ((entry->d_name[0]=='.') ||
 369             (entry->attribute & ATTR_HIDDEN)) {
 370             continue;
 371         }
 372
 373         /* filter out non rock files */
 374         if (strcasecmp((char *)&entry->d_name[strlen((char *)entry->d_name) -
 375                                               sizeof(ROCK_EXTENSION) + 1],
 376                        ROCK_EXTENSION)) {
 377             continue;
 378         }
 379
 380         /* filter out to long filenames */
 381         if (strlen((char *)entry->d_name) > MAX_PLUGIN_LENGTH + 5)
 382         {
 383             gui_syncsplash(HZ, true, str(LANG_FILETYPES_PLUGIN_NAME_LONG));
 384             continue;
 385         }
 386
 387         dot=strrchr((char *)entry->d_name,'.');
 388         *dot='\0';
 389         dash=strchr((char *)entry->d_name,'-');
 390
 391         /* add plugin and extension */
 392         if (dash)
 393         {
 394             *dash='\0';
 395             ix=(filetype_get_attr((char *)entry->d_name) >> 8);
 396             if (!ix)
 397             {
 398                 cp=get_string((char *)entry->d_name);
 399                 if (cp)
 400                 {
 401                     exttypes[cnt_exttypes].extension=cp;
 402                     exttypes[cnt_exttypes].type=&filetypes[cnt_filetypes];
 403 #ifdef HAVE_LCD_BITMAP
 404                     exttypes[cnt_exttypes].type->icon = bitmap_icons_6x8[Icon_Plugin];
 405 #else
 406                     exttypes[cnt_exttypes].type->icon = Icon_Plugin;
 407 #endif
 408                     cnt_exttypes++;
 409
 410                     *dash='-';
 411                     cp=get_string((char *)entry->d_name);
 412                     if (cp)
 413                     {
 414                         filetypes[cnt_filetypes].plugin=cp;
 415                         cnt_filetypes++;
 416                     }
 417                     else
 418                         break;
 419                 }
 420                 else
 421                     break;
 422             }
 423             else
 424             {
 425                 *dash='-';
 426                 if (!filetypes[ix].plugin)
 427                 {
 428                     cp=get_string((char *)entry->d_name);
 429                     if (cp)
 430                     {
 431                         filetypes[cnt_filetypes].plugin=cp;
 432                         cnt_filetypes++;
 433                     }
 434                     else
 435                         break;
 436                 }
 437             }
 438             *dash='-';
 439         }
 440         /* add plugin only */
 441         else
 442         {
 443             found=false;
 444             for (i = first_soft_filetype; i < cnt_filetypes; i++)
 445             {
 446                 if (filetypes[i].plugin)
 447                     if (!strcasecmp(filetypes[i].plugin, (char *)entry->d_name))
 448                     {
 449                         found=true;
 450                         break;
 451                     }
 452             }
 453
 454             if (!found)
 455             {
 456                 cp=get_string((char *)entry->d_name);
 457                 if (cp)
 458                 {
 459                     filetypes[cnt_filetypes].plugin=cp;
 460                     filetypes[cnt_filetypes].no_extension=true;
 461                     cnt_filetypes++;
 462                 }
 463                 else
 464                     break;
 465             }
 466         }
 467         *dot='.';
 468     }
 469     closedir(dir);
 470 }
 471
 472 #ifdef HAVE_LCD_BITMAP
 473 static int add_plugin(char *plugin, char *icon)
 474 #else
 475 static int add_plugin(char *plugin)
 476 #endif
 477 {
 478     char *cp;
 479     int i;
 480
 481     if (!plugin)
 482         return 0;
 483
 484 #if 0
 485     /* starting now, Oct 2005, the plugins are given without extension in the
 486        viewers.config file */
 487     cp=strrchr(plugin, '.');
 488     if (cp)
 489         *cp='\0';
 490 #endif
 491
 492     for (i=first_soft_filetype; i < cnt_filetypes; i++)
 493     {
 494         if (filetypes[i].plugin)
 495         {
 496             if (!strcasecmp(plugin, filetypes[i].plugin))
 497             {
 498 #ifdef HAVE_LCD_BITMAP
 499                 if (filetypes[i].icon == NULL && icon)
 500                 {
 501                     cp = string2icon(icon);
 502                     if (cp)
 503                         filetypes[cnt_filetypes].icon = (unsigned char *)cp;
 504                     else
 505                         return 0;
 506                 }
 507 #endif
 508                 return i;
 509             }
 510         }
 511     }
 512
 513     /* new plugin */
 514     cp = get_string(plugin);
 515     if (cp)
 516     {
 517         filetypes[cnt_filetypes].plugin = cp;
 518 #ifdef HAVE_LCD_BITMAP
 519         /* add icon */
 520         if (icon)
 521         {
 522             cp = string2icon(icon);
 523             if (cp)
 524                 filetypes[cnt_filetypes].icon = (unsigned char *)cp;
 525             else
 526                 return 0;
 527         }
 528 #endif
 529     }
 530     else
 531     {
 532         return 0;
 533     }
 534
 535     cnt_filetypes++;
 536     return cnt_filetypes - 1;
 537 }
 538
 539 /* read config file (or cahe file) */
 540 bool read_config(const char* file)
 541 {
 542     enum {extension,
 543           plugin,
 544 #ifdef HAVE_LCD_BITMAP
 545           icon,
 546 #endif
 547           last};
 548
 549     int   i,ix;
 550     int   fd;
 551     char* end;
 552     char* cp;
 553     char* str[last];
 554     char   buf[80];
 555
 556     fd = open(file, O_RDONLY);
 557     if (fd < 0)
 558         return false;
 559
 560     while (read_line(fd, buf, sizeof(buf)))
 561     {
 562         if (cnt_exttypes >= MAX_EXTTYPES)
 563         {
 564             gui_syncsplash(HZ, true, str(LANG_FILETYPES_EXTENSION_FULL));
 565             break;
 566         }
 567
 568         if (cnt_filetypes >= MAX_FILETYPES)
 569         {
 570             gui_syncsplash(HZ, true, str(LANG_FILETYPES_FULL));
 571             break;
 572         }
 573
 574         /* parse buffer */
 575         rm_whitespaces(buf);
 576
 577         if (strlen(buf) == 0)
 578             continue;
 579
 580         if (buf[0] == '#')
 581             continue;
 582
 583         memset(str,0,sizeof(str));
 584         i=0;
 585         cp=buf;
 586         while (*cp==',') {
 587             cp++;
 588             i++;
 589         }
 590         str[i] = strtok_r(cp, ",", &end);
 591         i++;
 592
 593         while (end && i < last)
 594         {
 595             if (end)
 596             {
 597                 cp=end;
 598                 while (*cp==',') {
 599                     cp++;
 600                     i++;
 601                 }
 602             }
 603             str[i] = strtok_r(NULL, ",", &end);
 604             if (str[i])
 605                 if (!strlen(str[i]))
 606                     str[i]=NULL;
 607             i++;
 608         }
 609
 610         /* bail out if no icon and no plugin */
 611         if (!str[plugin]
 612 #ifdef HAVE_LCD_BITMAP
 613             && !str[icon]
 614 #endif
 615            )
 616             continue;
 617
 618         /* bail out if no plugin and icon is incorrect*/
 619         if (!str[plugin]
 620 #ifdef HAVE_LCD_BITMAP
 621             && strlen(str[icon]) != ICON_LENGTH*2
 622 #endif
 623            )
 624             continue;
 625
 626         /* bail out if no icon and no plugin and no extension*/
 627         if (!str[plugin] &&
 628 #ifdef HAVE_LCD_BITMAP
 629             !str[icon] &&
 630 #endif
 631             !str[extension])
 632             continue;
 633
 634         /* bail out if we are not able to start plugin from onplay.c ?*/
 635         if (str[plugin])
 636         {
 637             if (strlen(str[plugin]) > MAX_PLUGIN_LENGTH)
 638             {
 639                 gui_syncsplash(HZ, true, str(LANG_FILETYPES_PLUGIN_NAME_LONG));
 640                 str[plugin] = NULL;
 641                 continue;
 642             }
 643         }
 644
 645         ix=0;
 646         /* if extension already exist don't add a new one */
 647         for (i=0; i < cnt_exttypes; i++)
 648         {
 649             if (!strcasecmp(str[extension],exttypes[i].extension))
 650             {
 651 #ifdef HAVE_LCD_BITMAP
 652                 ix=add_plugin(str[plugin],NULL);
 653                 if (ix)
 654                 {
 655                     if (str[icon] && filetypes[ix].icon == NULL)
 656                     {
 657                         if (exttypes[i].type->icon == NULL)
 658                         {
 659                             cp = string2icon(str[icon]);
 660                             if (cp)
 661                                 exttypes[i].type->icon = (unsigned char *)cp;
 662                         }
 663                     }
 664                 }
 665 #else
 666                 ix=add_plugin(str[plugin]);
 667 #endif
 668                 if (exttypes[i].type == NULL)
 669                 {
 670                     exttypes[i].type = &filetypes[ix];
 671                 }
 672                 break;
 673             }
 674         }
 675         if (ix)
 676             continue;
 677
 678         /* add extension */
 679         if (str[extension])
 680         {
 681 #ifdef HAVE_LCD_BITMAP
 682             ix=add_plugin(str[plugin],str[icon]);
 683 #else
 684             ix=add_plugin(str[plugin]);
 685 #endif
 686             if (ix)
 687             {
 688                 cp=get_string(str[extension]);
 689                 if (cp)
 690                 {
 691                     exttypes[cnt_exttypes].extension = cp;
 692
 693                     exttypes[cnt_exttypes].type = &filetypes[ix];
 694                     cnt_exttypes++;
 695                     filetypes[i].no_extension=false;
 696                 }
 697                 else
 698                 {
 699                     break;
 700                 }
 701             }
 702             else
 703             {
 704                 break;
 705             }
 706         }
 707         else
 708         {
 709 #ifdef HAVE_LCD_BITMAP
 710             ix=add_plugin(str[plugin],str[icon]);
 711 #else
 712             ix=add_plugin(str[plugin]);
 713 #endif
 714             filetypes[ix].no_extension=true;
 715             if (!i)
 716                 break;
 717         }
 718     }
 719     close(fd);
 720
 721     return true;
 722 }
 723
 724 #ifdef HAVE_LCD_BITMAP
 725 /* convert an ascii hexadecimal icon to a binary icon */
 726 static char* string2icon(const char* str)
 727 {
 728     char tmp[ICON_LENGTH*2];
 729     char *cp;
 730     int i;
 731
 732     if (strlen(str)!=ICON_LENGTH*2)
 733         return NULL;
 734
 735     if ((sizeof(string_buffer) +
 736          (unsigned long) string_buffer -
 737          (unsigned long) next_free_string) < ICON_LENGTH)
 738     {
 739         gui_syncsplash(HZ, true, str(LANG_FILETYPES_STRING_BUFFER_EMPTY));
 740         return NULL;
 741     }
 742
 743     for (i=0; i<12; i++)
 744     {
 745         if (str[i] >= '0' && str[i] <= '9')
 746         {
 747             tmp[i]=str[i]-'0';
 748             continue;
 749         }
 750
 751         if (str[i] >= 'a' && str[i] <= 'f')
 752         {
 753             tmp[i]=str[i]-'a'+10;
 754             continue;
 755         }
 756
 757         if (str[i] >= 'A' && str[i] <= 'F')
 758         {
 759             tmp[i]=str[i]-'A'+10;
 760             continue;
 761         }
 762
 763         return NULL;
 764     }
 765
 766     cp=next_free_string;
 767     for (i = 0; i < ICON_LENGTH; i++)
 768         cp[i]=((tmp[i*2]<<4) | tmp[i*2+1]);
 769
 770     next_free_string=&next_free_string[ICON_LENGTH];
 771     return cp;
 772 }
 773 #endif
 774
 775 /* get string from buffer */
 776 static char* get_string(const char* str)
 777 {
 778     unsigned int l=strlen(str)+1;
 779     char* cp;
 780
 781     if (!str)
 782         return NULL;
 783
 784     if (l <= (sizeof(string_buffer) +
 785              (unsigned long) string_buffer -
 786              (unsigned long) next_free_string))
 787     {
 788         strcpy(next_free_string, str);
 789         cp=next_free_string;
 790         next_free_string=&next_free_string[l];
 791         return cp;
 792     }
 793     else
 794     {
 795         gui_syncsplash(HZ, true, str(LANG_FILETYPES_STRING_BUFFER_EMPTY));
 796         return NULL;
 797     }
 798 }
 799
 800 /* remove all white spaces from string */
 801 static void rm_whitespaces(char* str)
 802 {
 803     char *cp, *free;
 804
 805     cp=str;
 806     free=cp;
 807
 808     while (cp < &str[strlen(str)])
 809     {
 810         switch (*cp)
 811         {
 812             case ' '  :
 813             case '\t' :
 814             case '\r' :
 815                 break;
 816
 817             default:
 818                 *free=*cp;
 819                 free++;
 820                 break;
 821         }
 822         cp++;
 823     }
 824
 825     *free='\0';
 826 }