Home | History | Annotate | Download | only in icuinfo 
      1 //  2016 and later: Unicode, Inc. and others.
      2 // License & terms of use: http://www.unicode.org/copyright.html
      3 /*
      4 *******************************************************************************
      5 *
      6 *   Copyright (C) 1999-2016, International Business Machines
      7 *   Corporation and others.  All Rights Reserved.
      8 *
      9 *******************************************************************************
     10 *   file name:  icuinfo.cpp
     11 *   encoding:   UTF-8
     12 *   tab size:   8 (not used)
     13 *   indentation:4
     14 *
     15 *   created on: 2009-2010
     16 *   created by: Steven R. Loomis
     17 *
     18 *   This program shows some basic info about the current ICU.
     19 */
     20 
     21 #include <stdio.h>
     22 #include <stdlib.h>
     23 #include "unicode/utypes.h"
     24 #include "unicode/putil.h"
     25 #include "unicode/uclean.h"
     26 #include "udbgutil.h"
     27 #include "unewdata.h"
     28 #include "cmemory.h"
     29 #include "cstring.h"
     30 #include "uoptions.h"
     31 #include "toolutil.h"
     32 #include "icuplugimp.h"
     33 #include <unicode/uloc.h>
     34 #include <unicode/ucnv.h>
     35 #include "unicode/ucal.h"
     36 #include <unicode/ulocdata.h>
     37 #include "putilimp.h"
     38 #include "unicode/uchar.h"
     39 
     40 static UOption options[]={
     41   /*0*/ UOPTION_HELP_H,
     42   /*1*/ UOPTION_HELP_QUESTION_MARK,
     43   /*2*/ UOPTION_ICUDATADIR,
     44   /*3*/ UOPTION_VERBOSE,
     45   /*4*/ UOPTION_DEF("list-plugins", 'L', UOPT_NO_ARG), // may be a no-op if disabled
     46   /*5*/ UOPTION_DEF("milisecond-time", 'm', UOPT_NO_ARG),
     47   /*6*/ UOPTION_DEF("cleanup", 'K', UOPT_NO_ARG),
     48   /*7*/ UOPTION_DEF("xml", 'x', UOPT_REQUIRES_ARG),
     49 };
     50 
     51 static UErrorCode initStatus = U_ZERO_ERROR;
     52 static UBool icuInitted = FALSE;
     53 
     54 static void do_init() {
     55     if(!icuInitted) {
     56       u_init(&initStatus);
     57       icuInitted = TRUE;
     58     }
     59 }
     60 
     61 
     62 void cmd_millis()
     63 {
     64   printf("Milliseconds since Epoch: %.0f\n", uprv_getUTCtime());
     65 }
     66 
     67 void cmd_version(UBool /* noLoad */, UErrorCode &errorCode)
     68 {
     69 
     70     do_init();
     71 
     72     udbg_writeIcuInfo(stdout); /* print the XML format */
     73 
     74     union {
     75         uint8_t byte;
     76         uint16_t word;
     77     } u;
     78     u.word=0x0100;
     79     if(U_IS_BIG_ENDIAN==u.byte) {
     80       //printf("U_IS_BIG_ENDIAN: %d\n", U_IS_BIG_ENDIAN);
     81     } else {
     82         fprintf(stderr, "  error: U_IS_BIG_ENDIAN=%d != %d=actual 'is big endian'\n",
     83                 U_IS_BIG_ENDIAN, u.byte);
     84         errorCode=U_INTERNAL_PROGRAM_ERROR;
     85     }
     86 
     87     if(U_SIZEOF_WCHAR_T==sizeof(wchar_t)) {
     88       //printf("U_SIZEOF_WCHAR_T: %d\n", U_SIZEOF_WCHAR_T);
     89     } else {
     90         fprintf(stderr, "  error: U_SIZEOF_WCHAR_T=%d != %d=sizeof(wchar_t)\n",
     91                 U_SIZEOF_WCHAR_T, (int)sizeof(wchar_t));
     92         errorCode=U_INTERNAL_PROGRAM_ERROR;
     93     }
     94 
     95     int charsetFamily;
     96     if('A'==0x41) {
     97         charsetFamily=U_ASCII_FAMILY;
     98     } else if('A'==0xc1) {
     99         charsetFamily=U_EBCDIC_FAMILY;
    100     } else {
    101         charsetFamily=-1;  // unknown
    102     }
    103     if(U_CHARSET_FAMILY==charsetFamily) {
    104       //printf("U_CHARSET_FAMILY: %d\n", U_CHARSET_FAMILY);
    105     } else {
    106         fprintf(stderr, "  error: U_CHARSET_FAMILY=%d != %d=actual charset family\n",
    107                 U_CHARSET_FAMILY, charsetFamily);
    108         errorCode=U_INTERNAL_PROGRAM_ERROR;
    109     }
    110 
    111     printf("\n\nICU Initialization returned: %s\n", u_errorName(initStatus));
    112 
    113 
    114 #if UCONFIG_ENABLE_PLUGINS
    115 #if U_ENABLE_DYLOAD
    116     const char *pluginFile = uplug_getPluginFile();
    117     printf("Plugin file is: %s\n", (pluginFile&&*pluginFile)?pluginFile:"(not set. try setting ICU_PLUGINS to a directory.)");
    118 #else
    119     fprintf(stderr, "Dynamic Loading: is disabled. No plugins will be loaded at start-up.\n");
    120 #endif
    121 #else
    122     fprintf(stderr, "Plugins are disabled.\n");
    123 #endif
    124 }
    125 
    126 void cmd_cleanup()
    127 {
    128     u_cleanup();
    129     fprintf(stdout, "ICU u_cleanup() called.\n");
    130 }
    131 
    132 
    133 void cmd_listplugins() {
    134 #if UCONFIG_ENABLE_PLUGINS
    135     int32_t i;
    136     UPlugData *plug;
    137 
    138     do_init();
    139     printf("ICU Initialized: u_init() returned %s\n", u_errorName(initStatus));
    140 
    141     printf("Plugins: \n");
    142     printf(    "# %6s   %s \n",
    143                        "Level",
    144                        "Name" );
    145     printf(    "    %10s:%-10s\n",
    146                        "Library",
    147                        "Symbol"
    148             );
    149 
    150 
    151     printf(    "       config| (configuration string)\n");
    152     printf(    " >>>   Error          | Explanation \n");
    153     printf(    "-----------------------------------\n");
    154 
    155     for(i=0;(plug=uplug_getPlugInternal(i))!=NULL;i++) {
    156         UErrorCode libStatus = U_ZERO_ERROR;
    157         const char *name = uplug_getPlugName(plug);
    158         const char *sym = uplug_getSymbolName(plug);
    159         const char *lib = uplug_getLibraryName(plug, &libStatus);
    160         const char *config = uplug_getConfiguration(plug);
    161         UErrorCode loadStatus = uplug_getPlugLoadStatus(plug);
    162         const char *message = NULL;
    163 
    164         printf("\n#%d  %-6s %s \n",
    165             i+1,
    166             udbg_enumName(UDBG_UPlugLevel,(int32_t)uplug_getPlugLevel(plug)),
    167             name!=NULL?(*name?name:"this plugin did not call uplug_setPlugName()"):"(null)"
    168         );
    169         printf("    plugin| %10s:%-10s\n",
    170             (U_SUCCESS(libStatus)?(lib!=NULL?lib:"(null)"):u_errorName(libStatus)),
    171             sym!=NULL?sym:"(null)"
    172         );
    173 
    174         if(config!=NULL&&*config) {
    175             printf("    config| %s\n", config);
    176         }
    177 
    178         switch(loadStatus) {
    179             case U_PLUGIN_CHANGED_LEVEL_WARNING:
    180                 message = "Note: This plugin changed the system level (by allocating memory or calling something which does). Later plugins may not load.";
    181                 break;
    182 
    183             case U_PLUGIN_DIDNT_SET_LEVEL:
    184                 message = "Error: This plugin did not call uplug_setPlugLevel during QUERY.";
    185                 break;
    186 
    187             case U_PLUGIN_TOO_HIGH:
    188                 message = "Error: This plugin couldn't load because the system level was too high. Try loading this plugin earlier.";
    189                 break;
    190 
    191             case U_ZERO_ERROR:
    192                 message = NULL; /* no message */
    193                 break;
    194             default:
    195                 if(U_FAILURE(loadStatus)) {
    196                     message = "error loading:";
    197                 } else {
    198                     message = "warning during load:";
    199                 }
    200         }
    201 
    202         if(message!=NULL) {
    203             printf("\\\\\\ status| %s\n"
    204                    "/// %s\n", u_errorName(loadStatus), message);
    205         }
    206 
    207     }
    208 	if(i==0) {
    209 		printf("No plugins loaded.\n");
    210 	}
    211 #endif
    212 }
    213 
    214 
    215 
    216 extern int
    217 main(int argc, char* argv[]) {
    218     UErrorCode errorCode = U_ZERO_ERROR;
    219     UBool didSomething = FALSE;
    220 
    221     /* preset then read command line options */
    222     argc=u_parseArgs(argc, argv, UPRV_LENGTHOF(options), options);
    223 
    224     /* error handling, printing usage message */
    225     if(argc<0) {
    226         fprintf(stderr,
    227             "error in command line argument \"%s\"\n",
    228             argv[-argc]);
    229     }
    230     if( options[0].doesOccur || options[1].doesOccur) {
    231       fprintf(stderr, "%s: Output information about the current ICU\n", argv[0]);
    232       fprintf(stderr, "Options:\n"
    233               " -h     or  --help                 - Print this help message.\n"
    234               " -m     or  --millisecond-time     - Print the current UTC time in milliseconds.\n"
    235               " -d <dir>   or  --icudatadir <dir> - Set the ICU Data Directory\n"
    236               " -v                                - Print version and configuration information about ICU\n"
    237 #if UCONFIG_ENABLE_PLUGINS
    238               " -L         or  --list-plugins     - List and diagnose issues with ICU Plugins\n"
    239 #endif
    240               " -K         or  --cleanup          - Call u_cleanup() before exitting (will attempt to unload plugins)\n"
    241               "\n"
    242               "If no arguments are given, the tool will print ICU version and configuration information.\n"
    243               );
    244       fprintf(stderr, "International Components for Unicode %s\n%s\n", U_ICU_VERSION, U_COPYRIGHT_STRING );
    245       return argc<0 ? U_ILLEGAL_ARGUMENT_ERROR : U_ZERO_ERROR;
    246     }
    247 
    248     if(options[2].doesOccur) {
    249       u_setDataDirectory(options[2].value);
    250     }
    251 
    252     if(options[5].doesOccur) {
    253       cmd_millis();
    254       didSomething=TRUE;
    255     }
    256     if(options[4].doesOccur) {
    257       cmd_listplugins();
    258       didSomething = TRUE;
    259     }
    260 
    261     if(options[3].doesOccur) {
    262       cmd_version(FALSE, errorCode);
    263       didSomething = TRUE;
    264     }
    265 
    266     if(options[7].doesOccur) {  /* 2nd part of version: cleanup */
    267       FILE *out = fopen(options[7].value, "w");
    268       if(out==NULL) {
    269         fprintf(stderr,"ERR: can't write to XML file %s\n", options[7].value);
    270         return 1;
    271       }
    272       /* todo: API for writing DTD? */
    273       fprintf(out, "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n");
    274       udbg_writeIcuInfo(out);
    275       fclose(out);
    276       didSomething = TRUE;
    277     }
    278 
    279     if(options[6].doesOccur) {  /* 2nd part of version: cleanup */
    280       cmd_cleanup();
    281       didSomething = TRUE;
    282     }
    283 
    284     if(!didSomething) {
    285       cmd_version(FALSE, errorCode);  /* at least print the version # */
    286     }
    287 
    288     return U_FAILURE(errorCode);
    289 }
    290