scilab/modules/spreadsheet/src/c/csvDefault.c

   1 /*
   2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
   3  * Copyright (C) 2010-2011 - DIGITEO - Allan CORNET
   4  *
   5  * This file must be used under the terms of the CeCILL.
   6  * This source file is licensed as described in the file COPYING, which
   7  * you should have received as part of this distribution.  The terms
   8  * are also available at
   9  * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
  10  *
  11  */
  12 #include <string.h>
  13 #include "csvDefault.h"
  14 #include "MALLOC.h"
  15 #ifdef _MSC_VER
  16 #include "strdup_windows.h"
  17 #endif
  18 #include "checkCsvWriteFormat.h"
  19 // =============================================================================
  20 #define DEFAULT_CSV_SEPARATOR ","
  21 #define DEFAULT_CSV_DECIMAL "."
  22 #define DEFAULT_CSV_PRECISION "%.17lg"
  23 #define DEFAULT_CSV_COMMENTS_REGEXP ""
  24 #ifdef _MSC_VER
  25 #define DEFAULT_CSV_EOL "\r\n"
  26 #else
  27 #define DEFAULT_CSV_EOL "\n"
  28 #endif
  29 #define CSV_DECIMAL_MODE_1 DEFAULT_CSV_DECIMAL
  30 #define CSV_DECIMAL_MODE_2 ","
  31 #define DEFAULT_CSV_CONVERSION "double"
  32 #define CSV_CONVERSION_MODE_1 DEFAULT_CSV_CONVERSION
  33 #define CSV_CONVERSION_MODE_2 "string"
  34 #define DEFAULT_CSV_ENCODING "utf-8"
  35 #define DEFAULT_CSV_ENCODING_MODE1 "utf-8"
  36 #define DEFAULT_CSV_ENCODING_MODE2 "iso-latin"
  37 #define CSV_IGNORE_BLANK_LINE_MODE_1 "off"
  38 #define CSV_IGNORE_BLANK_LINE_MODE_2 "on"
  39 #define DEFAULT_IGNORE_BLANK_LINE CSV_IGNORE_BLANK_LINE_MODE_2
  40 // =============================================================================
  41 static char *defaultCsvSeparator = NULL;
  42 static char *defaultCsvDecimal = NULL;
  43 static char *defaultCsvConversion = NULL;
  44 static char *defaultCsvPrecision = NULL;
  45 static char *defaultCsvCommentsRegExp = NULL;
  46 static char *defaultCsvEOL = NULL;
  47 static char *defaultCsvEncoding = NULL;
  48 static char *defaultCsvIgnoreBlankLine = NULL;
  49 // =============================================================================
  50 static int initializeCsvDefaultValues(void);
  51 // =============================================================================
  52 const char *getCsvDefaultSeparator(void)
  53 {
  54     initializeCsvDefaultValues();
  55     return defaultCsvSeparator;
  56 }
  57 // =============================================================================
  58 const char *getCsvDefaultDecimal(void)
  59 {
  60     initializeCsvDefaultValues();
  61     return defaultCsvDecimal;
  62 }
  63 // =============================================================================
  64 const char *getCsvDefaultConversion(void)
  65 {
  66     initializeCsvDefaultValues();
  67     return defaultCsvConversion;
  68 }
  69 // =============================================================================
  70 const char *getCsvDefaultPrecision(void)
  71 {
  72     initializeCsvDefaultValues();
  73     return defaultCsvPrecision;
  74 }
  75 // =============================================================================
  76 const char *getCsvDefaultCommentsRegExp(void)
  77 {
  78     initializeCsvDefaultValues();
  79     return defaultCsvCommentsRegExp;
  80 }
  81 // =============================================================================
  82 const char *getCsvDefaultEOL(void)
  83 {
  84     initializeCsvDefaultValues();
  85     return defaultCsvEOL;
  86 }
  87 // =============================================================================
  88 const char *getCsvDefaultEncoding(void)
  89 {
  90     initializeCsvDefaultValues();
  91     return defaultCsvEncoding;
  92 }
  93 // =============================================================================
  94 const char *getCsvDefaultCsvIgnoreBlankLine(void)
  95 {
  96     initializeCsvDefaultValues();
  97     return defaultCsvIgnoreBlankLine;
  98 }
  99 // =============================================================================
 100 int setCsvDefaultSeparator(const char *separator)
 101 {
 102     if (initializeCsvDefaultValues())
 103     {
 104         return 1;
 105     }
 106     if (separator == NULL)
 107     {
 108         return 1;
 109     }
 110
 111     if (strcmp(separator, getCsvDefaultDecimal()) == 0)
 112     {
 113         return 1;
 114     }
 115
 116     if (defaultCsvSeparator)
 117     {
 118         FREE(defaultCsvSeparator);
 119     }
 120     defaultCsvSeparator = strdup(separator);
 121     if (defaultCsvSeparator == NULL)
 122     {
 123         return 1;
 124     }
 125
 126     return 0;
 127 }
 128 // =============================================================================
 129 int setCsvDefaultDecimal(const char *decimal)
 130 {
 131     if (initializeCsvDefaultValues())
 132     {
 133         return 1;
 134     }
 135     if (decimal == NULL)
 136     {
 137         return 1;
 138     }
 139
 140     /* decimal separator supported . and , */
 141     if ((strcmp(decimal, CSV_DECIMAL_MODE_1) == 0) ||
 142             (strcmp(decimal, CSV_DECIMAL_MODE_2) == 0))
 143     {
 144         if (strcmp(decimal, getCsvDefaultSeparator()) == 0)
 145         {
 146             return 1;
 147         }
 148         if (defaultCsvDecimal)
 149         {
 150             FREE(defaultCsvDecimal);
 151         }
 152         defaultCsvDecimal = strdup(decimal);
 153         if (defaultCsvDecimal == NULL)
 154         {
 155             return 1;
 156         }
 157         return 0;
 158     }
 159     return 1;
 160 }
 161 // =============================================================================
 162 int setCsvDefaultConversion(const char *conversion)
 163 {
 164     if (initializeCsvDefaultValues())
 165     {
 166         return 1;
 167     }
 168     if (conversion == NULL)
 169     {
 170         return 1;
 171     }
 172
 173     if ((strcmp(conversion, CSV_CONVERSION_MODE_1) == 0) ||
 174             (strcmp(conversion, CSV_CONVERSION_MODE_2) == 0))
 175     {
 176         if (defaultCsvConversion)
 177         {
 178             FREE(defaultCsvConversion);
 179         }
 180         defaultCsvConversion = strdup(conversion);
 181         if (defaultCsvConversion)
 182         {
 183             return 0;
 184         }
 185     }
 186
 187     return 1;
 188 }
 189 // =============================================================================
 190 int setCsvDefaultPrecision(const char *precision)
 191 {
 192     if (initializeCsvDefaultValues())
 193     {
 194         return 1;
 195     }
 196     if (precision == NULL)
 197     {
 198         return 1;
 199     }
 200     if (checkCsvWriteFormat(precision) == 0)
 201     {
 202         if (defaultCsvPrecision)
 203         {
 204             FREE(defaultCsvPrecision);
 205         }
 206         defaultCsvPrecision = strdup(precision);
 207         if (defaultCsvPrecision)
 208         {
 209             return 0;
 210         }
 211     }
 212     return 1;
 213 }
 214 // =============================================================================
 215 int setCsvDefaultCsvIgnoreBlankLine(const char *blankMode)
 216 {
 217     if (initializeCsvDefaultValues())
 218     {
 219         return 1;
 220     }
 221     if (blankMode == NULL)
 222     {
 223         return 1;
 224     }
 225     if ((strcmp(blankMode, CSV_IGNORE_BLANK_LINE_MODE_1) == 0) ||
 226             (strcmp(blankMode, CSV_IGNORE_BLANK_LINE_MODE_2) == 0))
 227     {
 228         if (defaultCsvIgnoreBlankLine)
 229         {
 230             FREE(defaultCsvIgnoreBlankLine);
 231         }
 232         defaultCsvIgnoreBlankLine = strdup(blankMode);
 233         if (defaultCsvIgnoreBlankLine)
 234         {
 235             return 0;
 236         }
 237     }
 238     return 1;
 239 }
 240 // =============================================================================
 241 static int initializeCsvDefaultValues(void)
 242 {
 243     if (defaultCsvSeparator == NULL)
 244     {
 245         defaultCsvSeparator = strdup(DEFAULT_CSV_SEPARATOR);
 246     }
 247
 248     if (defaultCsvDecimal == NULL)
 249     {
 250         defaultCsvDecimal = strdup(DEFAULT_CSV_DECIMAL);
 251     }
 252
 253     if (defaultCsvConversion == NULL)
 254     {
 255         defaultCsvConversion = strdup(DEFAULT_CSV_CONVERSION);
 256     }
 257
 258     if (defaultCsvPrecision == NULL)
 259     {
 260         defaultCsvPrecision = strdup(DEFAULT_CSV_PRECISION);
 261     }
 262
 263     if (defaultCsvCommentsRegExp == NULL)
 264     {
 265         defaultCsvCommentsRegExp = strdup(DEFAULT_CSV_COMMENTS_REGEXP);
 266     }
 267
 268     if (defaultCsvEOL == NULL)
 269     {
 270         defaultCsvEOL = strdup(DEFAULT_CSV_EOL);
 271     }
 272
 273     if (defaultCsvEncoding == NULL)
 274     {
 275         defaultCsvEncoding = strdup(DEFAULT_CSV_ENCODING);
 276     }
 277
 278     if (defaultCsvIgnoreBlankLine == NULL)
 279     {
 280         defaultCsvIgnoreBlankLine =  strdup(DEFAULT_IGNORE_BLANK_LINE);
 281     }
 282
 283     if ((defaultCsvSeparator == NULL) ||
 284             (defaultCsvDecimal == NULL) ||
 285             (defaultCsvConversion == NULL) ||
 286             (defaultCsvPrecision == NULL) ||
 287             (defaultCsvCommentsRegExp == NULL) ||
 288             (defaultCsvEOL == NULL) ||
 289             (defaultCsvEncoding == NULL) ||
 290             (defaultCsvIgnoreBlankLine == NULL))
 291     {
 292         return 1;
 293     }
 294
 295     return 0;
 296 }
 297 // =============================================================================
 298 int setCsvDefaultReset(void)
 299 {
 300     if (defaultCsvSeparator)
 301     {
 302         FREE(defaultCsvSeparator);
 303         defaultCsvSeparator = NULL;
 304     }
 305     if (defaultCsvDecimal)
 306     {
 307         FREE(defaultCsvDecimal);
 308         defaultCsvDecimal = NULL;
 309     }
 310     if (defaultCsvConversion)
 311     {
 312         FREE(defaultCsvConversion);
 313         defaultCsvConversion = NULL;
 314     }
 315     if (defaultCsvPrecision)
 316     {
 317         FREE(defaultCsvPrecision);
 318         defaultCsvPrecision = NULL;
 319     }
 320     if (defaultCsvCommentsRegExp)
 321     {
 322         FREE(defaultCsvCommentsRegExp);
 323         defaultCsvCommentsRegExp = NULL;
 324     }
 325     if (defaultCsvEOL)
 326     {
 327         FREE(defaultCsvEOL);
 328         defaultCsvEOL = NULL;
 329     }
 330     if (defaultCsvEncoding)
 331     {
 332         FREE(defaultCsvEncoding);
 333         defaultCsvEncoding = NULL;
 334     }
 335     if (defaultCsvIgnoreBlankLine)
 336     {
 337         FREE(defaultCsvIgnoreBlankLine);
 338         defaultCsvIgnoreBlankLine = NULL;
 339     }
 340     return initializeCsvDefaultValues();
 341 }
 342 // =============================================================================
 343 int setCsvDefaultCommentsRegExp(const char *commentsRegExp)
 344 {
 345     if (initializeCsvDefaultValues())
 346     {
 347         return 1;
 348     }
 349     if (commentsRegExp == NULL)
 350     {
 351         return 1;
 352     }
 353
 354     if (strcmp(commentsRegExp, getCsvDefaultCommentsRegExp()) == 0)
 355     {
 356         return 1;
 357     }
 358
 359     if (defaultCsvCommentsRegExp)
 360     {
 361         FREE(defaultCsvCommentsRegExp);
 362         defaultCsvCommentsRegExp = NULL;
 363     }
 364
 365     defaultCsvCommentsRegExp = strdup(commentsRegExp);
 366
 367     if (defaultCsvDecimal == NULL)
 368     {
 369         return 1;
 370     }
 371
 372     return 0;
 373 }
 374 // =============================================================================
 375 int setCsvDefaultEOL(const char *eol)
 376 {
 377     if (initializeCsvDefaultValues())
 378     {
 379         return 1;
 380     }
 381     if (eol == NULL)
 382     {
 383         return 1;
 384     }
 385
 386     if (strcmp(eol, getCsvDefaultEOL()) == 0)
 387     {
 388         return 0;
 389     }
 390
 391     if (defaultCsvEOL)
 392     {
 393         FREE(defaultCsvEOL);
 394         defaultCsvEOL = NULL;
 395     }
 396
 397     defaultCsvEOL = strdup(eol);
 398
 399     if (defaultCsvEOL == NULL)
 400     {
 401         return 1;
 402     }
 403
 404     return 0;
 405 }
 406 // =============================================================================
 407 int setCsvDefaultEncoding(const char *encoding)
 408 {
 409     if (initializeCsvDefaultValues())
 410     {
 411         return 1;
 412     }
 413     if (encoding == NULL)
 414     {
 415         return 1;
 416     }
 417
 418     if (strcmp(encoding, getCsvDefaultEncoding()) == 0)
 419     {
 420         return 1;
 421     }
 422
 423     if ((strcmp(encoding, DEFAULT_CSV_ENCODING_MODE1) != 0) &&
 424             (strcmp(encoding, DEFAULT_CSV_ENCODING_MODE2) != 0))
 425     {
 426         return 1;
 427     }
 428
 429     if (defaultCsvEncoding)
 430     {
 431         FREE(defaultCsvEncoding);
 432         defaultCsvEncoding = NULL;
 433     }
 434
 435     defaultCsvEncoding = strdup(encoding);
 436
 437     if (defaultCsvEncoding == NULL)
 438     {
 439         return 1;
 440     }
 441
 442     return 0;
 443 }
 444 // =============================================================================