Changes On Branch windows-i18n
Not logged in

Many hyperlinks are disabled.
Use anonymous login to enable hyperlinks.

Changes In Branch windows-i18n Excluding Merge-Ins

This is equivalent to a diff from 5267731a85 to a742d12e8f

2011-05-20
11:32
Merge the windows-i18n branch into the trunk. check-in: d8ec765fac user: drh tags: trunk
11:24
Merge all the latest trunk changes into the windows-i18n branch. Closed-Leaf check-in: a742d12e8f user: drh tags: windows-i18n
11:22
Convert some fopen() calls to fossil_fopen(). Missed them previously. check-in: f626fcaab6 user: drh tags: windows-i18n
2011-05-19
11:48
Change the small logo to 72x72 pixels. check-in: 5267731a85 user: drh tags: trunk
2011-05-18
15:01
Update the built-in SQLite to the latest 3.7.7 alpha version. This adds no new capabilities - it is merely a beta-test of the SQLite version 3.7.7. check-in: dcfa88bd46 user: drh tags: trunk

Changes to src/add.c.

   114    114       char *zFullname = mprintf("%s%s", g.zLocalRoot, zPath);
   115    115       db_multi_exec(
   116    116         "INSERT INTO vfile(vid,deleted,rid,mrid,pathname,isexe)"
   117    117         "VALUES(%d,0,0,0,%Q,%d)",
   118    118         vid, zPath, file_isexe(zFullname));
   119    119       fossil_free(zFullname);
   120    120     }
   121         -  printf("ADDED  %s\n", zPath);
          121  +  fossil_print("ADDED  %s\n", zPath);
   122    122     return 1;
   123    123   }
   124    124   
   125    125   /*
   126    126   ** Add all files in the sfile temp table.
   127    127   **
   128    128   ** Automatically exclude the repository file.
................................................................................
   213    213       file_canonical_name(g.argv[i], &fullName);
   214    214       zName = blob_str(&fullName);
   215    215       isDir = file_isdir(zName);
   216    216       if( isDir==1 ){
   217    217         vfile_scan(&fullName, nRoot-1, includeDotFiles, pIgnore);
   218    218       }else if( isDir==0 ){
   219    219         fossil_fatal("not found: %s", zName);
   220         -    }else if( access(zName, R_OK) ){
          220  +    }else if( file_access(zName, R_OK) ){
   221    221         fossil_fatal("cannot open %s", zName);
   222    222       }else{
   223    223         char *zTreeName = &zName[nRoot];
   224    224         db_multi_exec(
   225    225            "INSERT OR IGNORE INTO sfile(x)"
   226    226            "  SELECT %Q WHERE NOT EXISTS(SELECT 1 FROM vfile WHERE pathname=%Q)",
   227    227            zTreeName, zTreeName
................................................................................
   278    278          zTreeName, zTreeName, zTreeName
   279    279       );
   280    280       blob_reset(&treeName);
   281    281     }
   282    282     
   283    283     db_prepare(&loop, "SELECT x FROM sfile");
   284    284     while( db_step(&loop)==SQLITE_ROW ){
   285         -    printf("DELETED %s\n", db_column_text(&loop, 0));
          285  +    fossil_print("DELETED %s\n", db_column_text(&loop, 0));
   286    286     }
   287    287     db_finalize(&loop);
   288    288     db_multi_exec(
   289    289       "UPDATE vfile SET deleted=1 WHERE pathname IN sfile;"
   290    290       "DELETE FROM vfile WHERE rid=0 AND deleted;"
   291    291     );
   292    292     db_end_transaction(0);
................................................................................
   375    375   
   376    376       zFile = db_column_text(&q, 0);
   377    377       zPath = db_column_text(&q, 1);
   378    378       if( !file_isfile(zPath) ){
   379    379         if( !isTest ){
   380    380           db_multi_exec("UPDATE vfile SET deleted=1 WHERE pathname=%Q", zFile);
   381    381         }
   382         -      printf("DELETED  %s\n", zFile);
          382  +      fossil_print("DELETED  %s\n", zFile);
   383    383         nDelete++;
   384    384       }
   385    385     }
   386    386     db_finalize(&q);
   387    387     /* show cmmand summary */
   388         -  printf("added %d files, deleted %d files\n", nAdd, nDelete);
          388  +  fossil_print("added %d files, deleted %d files\n", nAdd, nDelete);
   389    389   
   390    390     db_end_transaction(isTest);
   391    391   }
   392    392   
   393    393   
   394    394   /*
   395    395   ** Rename a single file.
   396    396   **
   397    397   ** The original name of the file is zOrig.  The new filename is zNew.
   398    398   */
   399    399   static void mv_one_file(int vid, const char *zOrig, const char *zNew){
   400         -  printf("RENAME %s %s\n", zOrig, zNew);
          400  +  fossil_print("RENAME %s %s\n", zOrig, zNew);
   401    401     db_multi_exec(
   402    402       "UPDATE vfile SET pathname='%s' WHERE pathname='%s' AND vid=%d",
   403    403       zNew, zOrig, vid
   404    404     );
   405    405   }
   406    406   
   407    407   /*

Changes to src/allrepo.c.

   127    127     db_prepare(&q,
   128    128        "SELECT DISTINCT substr(name, 6) COLLATE nocase"
   129    129        "  FROM global_config"
   130    130        " WHERE substr(name, 1, 5)=='repo:' ORDER BY 1"
   131    131     );
   132    132     while( db_step(&q)==SQLITE_ROW ){
   133    133       const char *zFilename = db_column_text(&q, 0);
   134         -    if( access(zFilename, 0) ){
          134  +    if( file_access(zFilename, 0) ){
   135    135         nMissing++;
   136    136         continue;
   137    137       }
   138    138       if( !file_is_canonical(zFilename) ) nMissing++;
   139    139       if( zCmd[0]=='l' ){
   140         -      printf("%s\n", zFilename);
          140  +      fossil_print("%s\n", zFilename);
   141    141         continue;
   142    142       }
   143    143       zQFilename = quoteFilename(zFilename);
   144    144       zSyscmd = mprintf("%s %s %s", zFossil, zCmd, zQFilename);
   145         -    printf("%s\n", zSyscmd);
          145  +    fossil_print("%s\n", zSyscmd);
   146    146       fflush(stdout);
   147    147       rc = fossil_system(zSyscmd);
   148    148       free(zSyscmd);
   149    149       free(zQFilename);
   150    150       if( stopOnError && rc ){
   151    151         nMissing = 0;
   152    152         break;
................................................................................
   157    157     ** be found, remove those names from the ~/.fossil file.
   158    158     */
   159    159     if( nMissing ){
   160    160       db_begin_transaction();
   161    161       db_reset(&q);
   162    162       while( db_step(&q)==SQLITE_ROW ){
   163    163         const char *zFilename = db_column_text(&q, 0);
   164         -      if( access(zFilename, 0) ){
          164  +      if( file_access(zFilename, 0) ){
   165    165           char *zRepo = mprintf("repo:%s", zFilename);
   166    166           db_unset(zRepo, 1);
   167    167           free(zRepo);
   168    168         }else if( !file_is_canonical(zFilename) ){
   169    169           Blob cname;
   170    170           char *zRepo = mprintf("repo:%s", zFilename);
   171    171           db_unset(zRepo, 1);

Changes to src/bisect.c.

   182    182       g.fNoSync = 1;
   183    183       update_cmd();
   184    184     }else if( memcmp(zCmd, "options", n)==0 ){
   185    185       if( g.argc==3 ){
   186    186         unsigned int i;
   187    187         for(i=0; i<sizeof(aBisectOption)/sizeof(aBisectOption[0]); i++){
   188    188           char *z = mprintf("bisect-%s", aBisectOption[i].zName);
   189         -        printf("  %-15s  %-6s  ", aBisectOption[i].zName,
          189  +        fossil_print("  %-15s  %-6s  ", aBisectOption[i].zName,
   190    190                  db_lget(z, (char*)aBisectOption[i].zDefault));
   191    191           fossil_free(z);
   192    192           comment_print(aBisectOption[i].zDesc, 27, 79);
   193    193         }
   194    194       }else if( g.argc==4 || g.argc==5 ){
   195    195         unsigned int i;
   196    196         n = strlen(g.argv[3]);
   197    197         for(i=0; i<sizeof(aBisectOption)/sizeof(aBisectOption[0]); i++){
   198    198           if( memcmp(g.argv[3], aBisectOption[i].zName, n)==0 ){
   199    199             char *z = mprintf("bisect-%s", aBisectOption[i].zName);
   200    200             if( g.argc==5 ){
   201    201               db_lset(z, g.argv[4]);
   202    202             }
   203         -          printf("%s\n", db_lget(z, (char*)aBisectOption[i].zDefault));
          203  +          fossil_print("%s\n", db_lget(z, (char*)aBisectOption[i].zDefault));
   204    204             fossil_free(z);
   205    205             break;
   206    206           }
   207    207         }
   208    208         if( i>=sizeof(aBisectOption)/sizeof(aBisectOption[0]) ){
   209    209           fossil_fatal("no such bisect option: %s", g.argv[3]);
   210    210         }
................................................................................
   228    228                      "   AND event.type='ci'");
   229    229       nStep = path_length();
   230    230       for(p=path_last(), n=0; p; p=p->pFrom, n++){
   231    231         const char *z;
   232    232         db_bind_int(&s, ":rid", p->rid);
   233    233         if( db_step(&s)==SQLITE_ROW ){
   234    234           z = db_column_text(&s, 0);
   235         -        printf("%s", z);
   236         -        if( p->rid==bisect.good ) printf(" GOOD");
   237         -        if( p->rid==bisect.bad ) printf(" BAD");
   238         -        if( p->rid==vid ) printf(" CURRENT");
   239         -        if( nStep>1 && n==nStep/2 ) printf(" NEXT");
   240         -        printf("\n");
          235  +        fossil_print("%s", z);
          236  +        if( p->rid==bisect.good ) fossil_print(" GOOD");
          237  +        if( p->rid==bisect.bad ) fossil_print(" BAD");
          238  +        if( p->rid==vid ) fossil_print(" CURRENT");
          239  +        if( nStep>1 && n==nStep/2 ) fossil_print(" NEXT");
          240  +        fossil_print("\n");
   241    241         }
   242    242         db_reset(&s);
   243    243       }
   244    244       db_finalize(&s);
   245    245     }else{
   246    246       usage("bad|good|next|reset|vlist ...");
   247    247     }
   248    248   }

Changes to src/blob.c.

   109    109       if( i==' ' || i=='\n' || i=='\t' || i=='\v'
   110    110           || i=='\f' || i=='\r' ){
   111    111         assert( fossil_isspace((char)i) );
   112    112       }else{
   113    113         assert( !fossil_isspace((char)i) );
   114    114       }
   115    115     }
   116         -  printf("All 256 characters OK\n");
          116  +  fossil_print("All 256 characters OK\n");
   117    117   }
   118    118   
   119    119   /*
   120    120   ** This routine is called if a blob operation fails because we
   121    121   ** have run out of memory.
   122    122   */
   123    123   static void blob_panic(void){
................................................................................
   688    688     if( size<0 ){
   689    689       fossil_fatal("no such file: %s", zFilename);
   690    690     }
   691    691     if( size==0 ){
   692    692       return 0;
   693    693     }
   694    694     blob_resize(pBlob, size);
   695         -  in = fopen(zFilename, "rb");
          695  +  in = fossil_fopen(zFilename, "rb");
   696    696     if( in==0 ){
   697    697       fossil_panic("cannot open %s for reading", zFilename);
   698    698     }
   699    699     got = fread(blob_buffer(pBlob), 1, size, in);
   700    700     fclose(in);
   701    701     if( got<size ){
   702    702       blob_resize(pBlob, got);
................................................................................
   748    748             }
   749    749   #if defined(_WIN32)
   750    750           }
   751    751   #endif
   752    752           zName[i] = '/';
   753    753         }
   754    754       }
   755         -    out = fopen(zName, "wb");
          755  +    out = fossil_fopen(zName, "wb");
   756    756       if( out==0 ){
   757    757         fossil_fatal_recursive("unable to open file \"%s\" for writing", zName);
   758    758         return 0;
   759    759       }
   760    760       needToClose = 1;
   761    761       if( zName!=zBuf ) free(zName);
   762    762     }
   763    763     blob_is_init(pBlob);
   764    764     wrote = fwrite(blob_buffer(pBlob), 1, blob_size(pBlob), out);
   765    765     if( needToClose ) fclose(out);
   766         -  if( wrote!=blob_size(pBlob) ){
          766  +  if( wrote!=blob_size(pBlob) && out!=stdout ){
   767    767       fossil_fatal_recursive("short write: %d of %d bytes to %s", wrote,
   768    768          blob_size(pBlob), zFilename);
   769    769     }
   770    770     return wrote;
   771    771   }
   772    772   
   773    773   /*
................................................................................
   923    923       if( blob_compare(&b1, &b3) ){
   924    924         fossil_panic("compress/uncompress cycle failed for %s", g.argv[i]);
   925    925       }
   926    926       blob_reset(&b1);
   927    927       blob_reset(&b2);
   928    928       blob_reset(&b3);
   929    929     }
   930         -  printf("ok\n");
          930  +  fossil_print("ok\n");
   931    931   }
   932    932   
   933    933   #if defined(_WIN32)
   934    934   /*
   935    935   ** Convert every \n character in the given blob into \r\n.
   936    936   */
   937    937   void blob_add_cr(Blob *p){

Changes to src/branch.c.

   155    155     db_multi_exec("INSERT OR IGNORE INTO unsent VALUES(%d)", brid);
   156    156     if( manifest_crosslink(brid, &branch)==0 ){
   157    157       fossil_panic("unable to install new manifest");
   158    158     }
   159    159     assert( blob_is_reset(&branch) );
   160    160     content_deltify(rootid, brid, 0);
   161    161     zUuid = db_text(0, "SELECT uuid FROM blob WHERE rid=%d", brid);
   162         -  printf("New branch: %s\n", zUuid);
          162  +  fossil_print("New branch: %s\n", zUuid);
   163    163     if( g.argc==3 ){
   164         -    printf(
          164  +    fossil_print(
   165    165         "\n"
   166    166         "Note: the local check-out has not been updated to the new\n"
   167    167         "      branch.  To begin working on the new branch, do this:\n"
   168    168         "\n"
   169    169         "      %s update %s\n",
   170    170         fossil_nameofexe(), zBranch
   171    171       );
................................................................................
   227    227         "   AND NOT %z"
   228    228         " ORDER BY value /*sort*/",
   229    229         TAG_BRANCH, leaf_is_closed_sql("tagxref.rid")
   230    230       );
   231    231       while( db_step(&q)==SQLITE_ROW ){
   232    232         const char *zBr = db_column_text(&q, 0);
   233    233         int isCur = zCurrent!=0 && fossil_strcmp(zCurrent,zBr)==0;
   234         -      printf("%s%s\n", (isCur ? "* " : "  "), zBr);
          234  +      fossil_print("%s%s\n", (isCur ? "* " : "  "), zBr);
   235    235       }
   236    236       db_finalize(&q);
   237    237     }else{
   238    238       fossil_panic("branch subcommand should be one of: "
   239    239                    "new list ls");
   240    240     }
   241    241   }

Changes to src/captcha.c.

   390    390     char *z;
   391    391   
   392    392     for(i=2; i<g.argc; i++){
   393    393       char zHex[30];
   394    394       v = (unsigned int)atoi(g.argv[i]);
   395    395       sqlite3_snprintf(sizeof(zHex), zHex, "%x", v);
   396    396       z = captcha_render(zHex);
   397         -    printf("%s:\n%s", zHex, z);
          397  +    fossil_print("%s:\n%s", zHex, z);
   398    398       free(z);
   399    399     }
   400    400   }
   401    401   
   402    402   /*
   403    403   ** Compute a seed value for a captcha.  The seed is public and is sent
   404    404   ** as a hidden parameter with the page that contains the captcha.  Knowledge

Changes to src/cgi.c.

     1      1   /*
     2      2   ** Copyright (c) 2006 D. Richard Hipp
     3      3   **
     4      4   ** This program is free software; you can redistribute it and/or
     5      5   ** modify it under the terms of the Simplified BSD License (also
     6      6   ** known as the "2-Clause License" or "FreeBSD License".)
     7         -
            7  +**
     8      8   ** This program is distributed in the hope that it will be useful,
     9      9   ** but without any warranty; without even the implied warranty of
    10     10   ** merchantability or fitness for a particular purpose.
    11     11   **
    12     12   ** Author contact information:
    13     13   **   drh@hwaci.com
    14     14   **   http://www.hwaci.com/drh/
................................................................................
  1114   1114         fossil_fatal("unable to open listening socket on any"
  1115   1115                      " port in the range %d..%d", mnPort, mxPort);
  1116   1116       }
  1117   1117     }
  1118   1118     if( iPort>mxPort ) return 1;
  1119   1119     listen(listener,10);
  1120   1120     if( iPort>mnPort ){
  1121         -    printf("Listening for HTTP requests on TCP port %d\n", iPort);
         1121  +    fossil_print("Listening for HTTP requests on TCP port %d\n", iPort);
  1122   1122       fflush(stdout);
  1123   1123     }
  1124   1124     if( zBrowser ){
  1125   1125       zBrowser = mprintf(zBrowser, iPort);
  1126   1126       system(zBrowser);
  1127   1127     }
  1128   1128     while( 1 ){

Changes to src/checkin.c.

    52     52       int isNew = db_column_int(&q,3)==0;
    53     53       int isRenamed = db_column_int(&q,4);
    54     54       char *zFullName = mprintf("%s%s", g.zLocalRoot, zPathname);
    55     55       blob_append(report, zPrefix, nPrefix);
    56     56       if( isDeleted ){
    57     57         blob_appendf(report, "DELETED    %s\n", zPathname);
    58     58       }else if( !file_isfile(zFullName) ){
    59         -      if( access(zFullName, 0)==0 ){
           59  +      if( file_access(zFullName, 0)==0 ){
    60     60           blob_appendf(report, "NOT_A_FILE %s\n", zPathname);
    61     61           if( missingIsFatal ){
    62     62             fossil_warning("not a file: %s", zPathname);
    63     63             nErr++;
    64     64           }
    65     65         }else{
    66     66           blob_appendf(report, "MISSING    %s\n", zPathname);
................................................................................
   134    134   **    --sha1sum         Verify file status using SHA1 hashing rather
   135    135   **                      than relying on file mtimes.
   136    136   */
   137    137   void status_cmd(void){
   138    138     int vid;
   139    139     db_must_be_within_tree();
   140    140          /* 012345678901234 */
   141         -  printf("repository:   %s\n", db_lget("repository",""));
   142         -  printf("local-root:   %s\n", g.zLocalRoot);
   143         -  printf("server-code:  %s\n", db_get("server-code", ""));
          141  +  fossil_print("repository:   %s\n", db_lget("repository",""));
          142  +  fossil_print("local-root:   %s\n", g.zLocalRoot);
          143  +  fossil_print("server-code:  %s\n", db_get("server-code", ""));
   144    144     vid = db_lget_int("checkout", 0);
   145    145     if( vid ){
   146    146       show_common_info(vid, "checkout:", 1, 1);
   147    147     }
   148    148     changes_cmd();
   149    149   }
   150    150   
................................................................................
   174    174       const char *zPathname = db_column_text(&q,0);
   175    175       int isDeleted = db_column_int(&q, 1);
   176    176       int isNew = db_column_int(&q,2)==0;
   177    177       int chnged = db_column_int(&q,3);
   178    178       int renamed = db_column_int(&q,4);
   179    179       char *zFullName = mprintf("%s%s", g.zLocalRoot, zPathname);
   180    180       if( isBrief ){
   181         -      printf("%s\n", zPathname);
          181  +      fossil_print("%s\n", zPathname);
   182    182       }else if( isNew ){
   183         -      printf("ADDED      %s\n", zPathname);
          183  +      fossil_print("ADDED      %s\n", zPathname);
   184    184       }else if( isDeleted ){
   185         -      printf("DELETED    %s\n", zPathname);
          185  +      fossil_print("DELETED    %s\n", zPathname);
   186    186       }else if( !file_isfile(zFullName) ){
   187         -      if( access(zFullName, 0)==0 ){
   188         -        printf("NOT_A_FILE %s\n", zPathname);
          187  +      if( file_access(zFullName, 0)==0 ){
          188  +        fossil_print("NOT_A_FILE %s\n", zPathname);
   189    189         }else{
   190         -        printf("MISSING    %s\n", zPathname);
          190  +        fossil_print("MISSING    %s\n", zPathname);
   191    191         }
   192    192       }else if( chnged ){
   193         -      printf("EDITED     %s\n", zPathname);
          193  +      fossil_print("EDITED     %s\n", zPathname);
   194    194       }else if( renamed ){
   195         -      printf("RENAMED    %s\n", zPathname);
          195  +      fossil_print("RENAMED    %s\n", zPathname);
   196    196       }else{
   197         -      printf("UNCHANGED  %s\n", zPathname);
          197  +      fossil_print("UNCHANGED  %s\n", zPathname);
   198    198       }
   199    199       free(zFullName);
   200    200     }
   201    201     db_finalize(&q);
   202    202   }
   203    203   
   204    204   /*
................................................................................
   242    242         " ORDER BY 1",
   243    243         fossil_all_reserved_names()
   244    244     );
   245    245     if( file_tree_name(g.zRepositoryName, &repo, 0) ){
   246    246       db_multi_exec("DELETE FROM sfile WHERE x=%B", &repo);
   247    247     }
   248    248     while( db_step(&q)==SQLITE_ROW ){
   249         -    printf("%s\n", db_column_text(&q, 0));
          249  +    fossil_print("%s\n", db_column_text(&q, 0));
   250    250     }
   251    251     db_finalize(&q);
   252    252   }
   253    253   
   254    254   /*
   255    255   ** COMMAND: clean
   256    256   ** Usage: %fossil clean ?--force? ?--dotfiles? ?--ignore GLOBPATTERN?
................................................................................
   300    300         g.zLocalRoot, fossil_all_reserved_names()
   301    301     );
   302    302     if( file_tree_name(g.zRepositoryName, &repo, 0) ){
   303    303       db_multi_exec("DELETE FROM sfile WHERE x=%B", &repo);
   304    304     }
   305    305     while( db_step(&q)==SQLITE_ROW ){
   306    306       if( allFlag ){
   307         -      unlink(db_column_text(&q, 0));
          307  +      file_delete(db_column_text(&q, 0));
   308    308       }else{
   309    309         Blob ans;
   310    310         char *prompt = mprintf("remove unmanaged file \"%s\" (y/N)? ",
   311    311                                 db_column_text(&q, 0));
   312    312         blob_zero(&ans);
   313    313         prompt_user(prompt, &ans);
   314    314         if( blob_str(&ans)[0]=='y' ){
   315         -        unlink(db_column_text(&q, 0));
          315  +        file_delete(db_column_text(&q, 0));
   316    316         }
   317    317       }
   318    318     }
   319    319     db_finalize(&q);
   320    320   }
   321    321   
   322    322   /*
................................................................................
   393    393     }
   394    394   #if defined(_WIN32)
   395    395     blob_add_cr(&text);
   396    396   #endif
   397    397     blob_write_to_file(&text, zFile);
   398    398     if( zEditor ){
   399    399       zCmd = mprintf("%s \"%s\"", zEditor, zFile);
   400         -    printf("%s\n", zCmd);
          400  +    fossil_print("%s\n", zCmd);
   401    401       if( fossil_system(zCmd) ){
   402    402         fossil_panic("editor aborted");
   403    403       }
   404    404       blob_reset(&text);
   405    405       blob_read_from_file(&text, zFile);
   406    406     }else{
   407    407       char zIn[300];
   408    408       blob_reset(&text);
   409    409       while( fgets(zIn, sizeof(zIn), stdin)!=0 ){
   410         -      if( zIn[0]=='.' && (zIn[1]==0 || zIn[1]=='\r' || zIn[1]=='\n') ) break;
          410  +      char *zUtf8 = fossil_mbcs_to_utf8(zIn);
          411  +      if( zUtf8[0]=='.' && (zUtf8[1]==0 || zUtf8[1]=='\r' || zUtf8[1]=='\n') ){
          412  +        fossil_mbcs_free(zUtf8);
          413  +        break;
          414  +      }
   411    415         blob_append(&text, zIn, -1);
          416  +      fossil_mbcs_free(zUtf8);
   412    417       }
   413    418     }
   414    419     blob_remove_cr(&text);
   415         -  unlink(zFile);
          420  +  file_delete(zFile);
   416    421     free(zFile);
   417    422     blob_zero(pComment);
   418    423     while( blob_line(&text, &line) ){
   419    424       int i, n;
   420    425       char *z;
   421    426       n = blob_size(&line);
   422    427       z = blob_buffer(&line);
................................................................................
  1082   1087       fossil_panic("trouble committing manifest: %s", g.zErrMsg);
  1083   1088     }
  1084   1089     db_multi_exec("INSERT OR IGNORE INTO unsent VALUES(%d)", nvid);
  1085   1090     manifest_crosslink(nvid, &manifest);
  1086   1091     assert( blob_is_reset(&manifest) );
  1087   1092     content_deltify(vid, nvid, 0);
  1088   1093     zUuid = db_text(0, "SELECT uuid FROM blob WHERE rid=%d", nvid);
  1089         -  printf("New_Version: %s\n", zUuid);
         1094  +  fossil_print("New_Version: %s\n", zUuid);
  1090   1095     if( outputManifest ){
  1091   1096       zManifestFile = mprintf("%smanifest.uuid", g.zLocalRoot);
  1092   1097       blob_zero(&muuid);
  1093   1098       blob_appendf(&muuid, "%s\n", zUuid);
  1094   1099       blob_write_to_file(&muuid, zManifestFile);
  1095   1100       free(zManifestFile);
  1096   1101       blob_reset(&muuid);
................................................................................
  1151   1156     }
  1152   1157     db_end_transaction(0);
  1153   1158   
  1154   1159     if( !g.markPrivate ){
  1155   1160       autosync(AUTOSYNC_PUSH);  
  1156   1161     }
  1157   1162     if( count_nonbranch_children(vid)>1 ){
  1158         -    printf("**** warning: a fork has occurred *****\n");
         1163  +    fossil_print("**** warning: a fork has occurred *****\n");
  1159   1164     }
  1160   1165   }

Changes to src/checkout.c.

   155    155       blob_append(&hash, "\n", 1);
   156    156       blob_write_to_file(&hash, zManFile);
   157    157       free(zManFile);
   158    158       blob_reset(&hash);
   159    159     }else{
   160    160       if( !db_exists("SELECT 1 FROM vfile WHERE pathname='manifest'") ){
   161    161         zManFile = mprintf("%smanifest", g.zLocalRoot);
   162         -      unlink(zManFile);
          162  +      file_delete(zManFile);
   163    163         free(zManFile);
   164    164       }
   165    165       if( !db_exists("SELECT 1 FROM vfile WHERE pathname='manifest.uuid'") ){
   166    166         zManFile = mprintf("%smanifest.uuid", g.zLocalRoot);
   167         -      unlink(zManFile);
          167  +      file_delete(zManFile);
   168    168         free(zManFile);
   169    169       }
   170    170     }
   171    171       
   172    172   }
   173    173   
   174    174   /*
................................................................................
   247    247     db_lset_int("checkout", vid);
   248    248     undo_reset();
   249    249     db_multi_exec("DELETE FROM vmerge");
   250    250     if( !keepFlag && db_get_boolean("repo-cksum",1) ){
   251    251       vfile_aggregate_checksum_manifest(vid, &cksum1, &cksum1b);
   252    252       vfile_aggregate_checksum_disk(vid, &cksum2);
   253    253       if( blob_compare(&cksum1, &cksum2) ){
   254         -      printf("WARNING: manifest checksum does not agree with disk\n");
          254  +      fossil_print("WARNING: manifest checksum does not agree with disk\n");
   255    255       }
   256    256       if( blob_size(&cksum1b) && blob_compare(&cksum1, &cksum1b) ){
   257         -      printf("WARNING: manifest checksum does not agree with manifest\n");
          257  +      fossil_print("WARNING: manifest checksum does not agree with manifest\n");
   258    258       }
   259    259     }
   260    260     db_end_transaction(0);
   261    261   }
   262    262   
   263    263   /*
   264    264   ** Unlink the local database file
................................................................................
   266    266   static void unlink_local_database(int manifestOnly){
   267    267     const char *zReserved;
   268    268     int i;
   269    269     for(i=0; (zReserved = fossil_reserved_name(i))!=0; i++){
   270    270       if( manifestOnly==0 || zReserved[0]=='m' ){
   271    271         char *z;
   272    272         z = mprintf("%s%s", g.zLocalRoot, zReserved);
   273         -      unlink(z);
          273  +      file_delete(z);
   274    274         free(z);
   275    275       }
   276    276     }
   277    277   }
   278    278   
   279    279   /*
   280    280   ** COMMAND: close

Changes to src/clearsign.c.

    50     50       blob_zero(pOut);
    51     51       blob_read_from_file(pOut, zIn);
    52     52     }else{
    53     53       if( pOut!=pIn ){
    54     54         blob_copy(pOut, pIn);
    55     55       }
    56     56     }
    57         -  unlink(zOut);
    58         -  unlink(zIn);
           57  +  file_delete(zOut);
           58  +  file_delete(zIn);
    59     59     free(zOut);
    60     60     free(zIn);
    61     61     return rc;
    62     62   }

Changes to src/clone.c.

    78     78          "DELETE FROM private;"
    79     79       );
    80     80       shun_artifacts();
    81     81       g.zLogin = db_text(0, "SELECT login FROM user WHERE cap LIKE '%%s%%'");
    82     82       if( g.zLogin==0 ){
    83     83         db_create_default_users(1,zDefaultUser);
    84     84       }
    85         -    printf("Repository cloned into %s\n", g.argv[3]);
           85  +    fossil_print("Repository cloned into %s\n", g.argv[3]);
    86     86     }else{
    87     87       db_create_repository(g.argv[3]);
    88     88       db_open_repository(g.argv[3]);
    89     89       db_begin_transaction();
    90     90       db_record_repository_filename(g.argv[3]);
    91     91       db_initial_setup(0, zDefaultUser, 0);
    92     92       user_select();
................................................................................
   102    102       g.xlinkClusterOnly = 1;
   103    103       nErr = client_sync(0,0,1,bPrivate,CONFIGSET_ALL,0);
   104    104       g.xlinkClusterOnly = 0;
   105    105       verify_cancel();
   106    106       db_end_transaction(0);
   107    107       db_close(1);
   108    108       if( nErr ){
   109         -      unlink(g.argv[3]);
          109  +      file_delete(g.argv[3]);
   110    110         fossil_fatal("server returned an error - clone aborted");
   111    111       }
   112    112       db_open_repository(g.argv[3]);
   113    113     }
   114    114     db_begin_transaction();
   115         -  printf("Rebuilding repository meta-data...\n");
          115  +  fossil_print("Rebuilding repository meta-data...\n");
   116    116     rebuild_db(0, 1, 0);
   117         -  printf("project-id: %s\n", db_get("project-code", 0));
   118         -  printf("server-id:  %s\n", db_get("server-code", 0));
          117  +  fossil_print("project-id: %s\n", db_get("project-code", 0));
          118  +  fossil_print("server-id:  %s\n", db_get("server-code", 0));
   119    119     zPassword = db_text(0, "SELECT pw FROM user WHERE login=%Q", g.zLogin);
   120         -  printf("admin-user: %s (password is \"%s\")\n", g.zLogin, zPassword);
          120  +  fossil_print("admin-user: %s (password is \"%s\")\n", g.zLogin, zPassword);
   121    121     db_end_transaction(0);
   122    122   }

Changes to src/comformat.c.

    39     39     char zBuf[400];
    40     40     int lineCnt = 0; 
    41     41   
    42     42     for(;;){
    43     43       while( fossil_isspace(zText[0]) ){ zText++; }
    44     44       if( zText[0]==0 ){
    45     45         if( doIndent==0 ){
    46         -        printf("\n");
           46  +        fossil_print("\n");
    47     47           lineCnt = 1;
    48     48         }
    49     49         return lineCnt;
    50     50       }
    51     51       for(sk=si=i=k=0; zText[i] && k<tlen; i++){
    52     52         char c = zText[i];
    53     53         if( fossil_isspace(c) ){
................................................................................
    62     62             si = i+1;
    63     63             sk = k+1;
    64     64           }
    65     65           k++;
    66     66         }
    67     67       }
    68     68       if( doIndent ){
    69         -      printf("%*s", indent, "");
           69  +      fossil_print("%*s", indent, "");
    70     70       }
    71     71       doIndent = 1;
    72     72       if( sk>0 && zText[i] ){
    73     73         zText += si;
    74     74         zBuf[sk++] =  '\n';
    75     75         zBuf[sk] = 0;
    76         -      printf("%s", zBuf);
           76  +      fossil_print("%s", zBuf);
    77     77       }else{
    78     78         zText += i;
    79     79         zBuf[k++] =  '\n';
    80     80         zBuf[k] = 0;
    81         -      printf("%s", zBuf);
           81  +      fossil_print("%s", zBuf);
    82     82       }
    83     83       lineCnt++;
    84     84     }
    85     85   }
    86     86   
    87     87   /*
    88     88   ** Test the comment printing
................................................................................
    91     91   */
    92     92   void test_comment_format(void){
    93     93     int indent;
    94     94     if( g.argc!=4 ){
    95     95       usage("PREFIX TEXT");
    96     96     }
    97     97     indent = strlen(g.argv[2]) + 1;
    98         -  printf("%s ", g.argv[2]);
    99         -  printf("(%d lines output)\n", comment_print(g.argv[3], indent, 79));
           98  +  fossil_print("%s ", g.argv[2]);
           99  +  fossil_print("(%d lines output)\n", comment_print(g.argv[3], indent, 79));
   100    100   }

Changes to src/configure.c.

   686    686     int n = strlen(z);
   687    687     for(i=0; i<count(aGroupName); i++){
   688    688       if( strncmp(z, &aGroupName[i].zName[1], n)==0 ){
   689    689         return aGroupName[i].groupMask;
   690    690       }
   691    691     }
   692    692     if( notFoundIsFatal ){
   693         -    printf("Available configuration areas:\n");
          693  +    fossil_print("Available configuration areas:\n");
   694    694       for(i=0; i<count(aGroupName); i++){
   695         -      printf("  %-10s %s\n", &aGroupName[i].zName[1], aGroupName[i].zHelp);
          695  +      fossil_print("  %-10s %s\n", &aGroupName[i].zName[1], aGroupName[i].zHelp);
   696    696       }
   697    697       fossil_fatal("no such configuration area: \"%s\"", z);
   698    698     }
   699    699     return 0;
   700    700   }
   701    701   
   702    702   /*
................................................................................
   881    881         }else if( fossil_strcmp(zName,"@shun")==0 ){
   882    882           db_multi_exec("DELETE FROM shun");
   883    883         }else if( fossil_strcmp(zName,"@reportfmt")==0 ){
   884    884           db_multi_exec("DELETE FROM reportfmt");
   885    885         }
   886    886       }
   887    887       db_end_transaction(0);
   888         -    printf("Configuration reset to factory defaults.\n");
   889         -    printf("To recover, use:  %s %s import %s\n", 
          888  +    fossil_print("Configuration reset to factory defaults.\n");
          889  +    fossil_print("To recover, use:  %s %s import %s\n", 
   890    890               fossil_nameofexe(), g.argv[1], zBackup);
   891    891     }else
   892    892     {
   893    893       fossil_fatal("METHOD should be one of:"
   894    894                    " export import merge pull push reset");
   895    895     }
   896    896   }

Changes to src/content.c.

   668    668     int rid;
   669    669     Blob content;
   670    670     if( g.argc!=3 ) usage("FILENAME");
   671    671     db_must_be_within_tree();
   672    672     user_select();
   673    673     blob_read_from_file(&content, g.argv[2]);
   674    674     rid = content_put(&content);
   675         -  printf("inserted as record %d\n", rid);
          675  +  fossil_print("inserted as record %d\n", rid);
   676    676   }
   677    677   
   678    678   /*
   679    679   ** Make sure the content at rid is the original content and is not a
   680    680   ** delta.
   681    681   */
   682    682   void content_undelta(int rid){
................................................................................
   836    836     db_prepare(&q, "SELECT rid, uuid, size FROM blob ORDER BY rid");
   837    837     total = db_int(0, "SELECT max(rid) FROM blob");
   838    838     while( db_step(&q)==SQLITE_ROW ){
   839    839       int rid = db_column_int(&q, 0);
   840    840       const char *zUuid = db_column_text(&q, 1);
   841    841       int size = db_column_int(&q, 2);
   842    842       n1++;
   843         -    printf("  %d/%d\r", n1, total);
          843  +    fossil_print("  %d/%d\r", n1, total);
   844    844       fflush(stdout);
   845    845       if( size<0 ){
   846         -      printf("skip phantom %d %s\n", rid, zUuid);
          846  +      fossil_print("skip phantom %d %s\n", rid, zUuid);
   847    847         continue;  /* Ignore phantoms */
   848    848       }
   849    849       content_get(rid, &content);
   850    850       if( blob_size(&content)!=size ){
   851    851         fossil_warning("size mismatch on blob rid=%d:  %d vs %d",
   852    852                        rid, blob_size(&content), size);
   853    853       }
................................................................................
   857    857                      rid, blob_str(&cksum), zUuid);
   858    858       }
   859    859       blob_reset(&cksum);
   860    860       blob_reset(&content);
   861    861       n2++;
   862    862     }
   863    863     db_finalize(&q);
   864         -  printf("%d non-phantom blobs (out of %d total) verified\n", n2, n1);
          864  +  fossil_print("%d non-phantom blobs (out of %d total) verified\n", n2, n1);
   865    865   }

Changes to src/db.c.

   164    164     if( nBegin ){
   165    165       sqlite3_exec(g.db, "ROLLBACK", 0, 0, 0);
   166    166       nBegin = 0;
   167    167     }
   168    168     busy = 0;
   169    169     db_close(0);
   170    170     for(i=0; i<nDeleteOnFail; i++){
   171         -    unlink(azDeleteOnFail[i]);
          171  +    file_delete(azDeleteOnFail[i]);
   172    172     }
   173    173   }
   174    174   
   175    175   /*
   176    176   ** Install a commit hook.  Hooks are installed in sequence order.
   177    177   ** It is an error to install the same commit hook more than once.
   178    178   **
................................................................................
   693    693       }
   694    694     }
   695    695     if( zHome==0 ){
   696    696       fossil_fatal("cannot locate home directory - "
   697    697                   "please set the LOCALAPPDATA or APPDATA or HOMEPATH "
   698    698                   "environment variables");
   699    699     }
          700  +  zHome = fossil_mbcs_to_utf8(zHome);
   700    701   #else
   701    702     zHome = getenv("HOME");
   702    703     if( zHome==0 ){
   703    704       fossil_fatal("cannot locate home directory - "
   704    705                    "please set the HOME environment variable");
   705    706     }
   706    707   #endif
................................................................................
   738    739   ** true.  If it is not a valid local database file, return 0.
   739    740   */
   740    741   static int isValidLocalDb(const char *zDbName){
   741    742     i64 lsize;
   742    743     int rc;
   743    744     sqlite3_stmt *pStmt;
   744    745   
   745         -  if( access(zDbName, F_OK) ) return 0;
          746  +  if( file_access(zDbName, F_OK) ) return 0;
   746    747     lsize = file_size(zDbName);
   747    748     if( lsize%1024!=0 || lsize<4096 ) return 0;
   748    749     db_open_or_attach(zDbName, "localdb");
   749    750     g.localOpen = 1;
   750    751     db_open_config(0);
   751    752     db_open_repository(0);
   752    753   
................................................................................
   813    814       db_err("pwd too big: max %d", sizeof(zPwd)-20);
   814    815     }
   815    816     n = strlen(zPwd);
   816    817     zPwdConv = mprintf("%/", zPwd);
   817    818     strncpy(zPwd, zPwdConv, 2000-20);
   818    819     free(zPwdConv);
   819    820     while( n>0 ){
   820         -    if( access(zPwd, W_OK) ) break;
          821  +    if( file_access(zPwd, W_OK) ) break;
   821    822       for(i=0; i<sizeof(aDbName)/sizeof(aDbName[0]); i++){
   822    823         sqlite3_snprintf(sizeof(zPwd)-n, &zPwd[n], "%s", aDbName[i]);
   823    824         if( isValidLocalDb(zPwd) ){
   824    825           /* Found a valid checkout database file */
   825    826           zPwd[n] = 0;
   826    827           while( n>1 && zPwd[n-1]=='/' ){
   827    828             n--;
................................................................................
   851    852       if( g.localOpen ){
   852    853         zDbName = db_lget("repository", 0);
   853    854       }
   854    855       if( zDbName==0 ){
   855    856         db_err("unable to find the name of a repository database");
   856    857       }
   857    858     }
   858         -  if( access(zDbName, R_OK) || file_size(zDbName)<1024 ){
   859         -    if( access(zDbName, 0) ){
          859  +  if( file_access(zDbName, R_OK) || file_size(zDbName)<1024 ){
          860  +    if( file_access(zDbName, 0) ){
   860    861         fossil_panic("repository does not exist or"
   861    862                      " is in an unreadable directory: %s", zDbName);
   862         -    }else if( access(zDbName, R_OK) ){
          863  +    }else if( file_access(zDbName, R_OK) ){
   863    864         fossil_panic("read permission denied for repository %s", zDbName);
   864    865       }else{
   865    866         fossil_panic("not a valid repository: %s", zDbName);
   866    867       }
   867    868     }
   868    869     db_open_or_attach(zDbName, "repository");
   869    870     g.repositoryOpen = 1;
................................................................................
   962    963     }
   963    964     if( db_open_local()==0 ){
   964    965       fossil_fatal("not in a local checkout");
   965    966       return;
   966    967     }
   967    968     file_canonical_name(g.argv[2], &repo);
   968    969     zRepo = blob_str(&repo);
   969         -  if( access(zRepo, 0) ){
          970  +  if( file_access(zRepo, 0) ){
   970    971       fossil_fatal("no such file: %s", zRepo);
   971    972     }
   972    973     db_open_or_attach(zRepo, "test_repo");
   973    974     db_lset("repository", blob_str(&repo));
   974    975     db_close(1);
   975    976   }
   976    977   

Changes to src/deltacmd.c.

    50     50   */
    51     51   void delta_create_cmd(void){
    52     52     Blob orig, target, delta;
    53     53     if( g.argc!=5 ){
    54     54       usage("ORIGIN TARGET DELTA");
    55     55     }
    56     56     if( blob_read_from_file(&orig, g.argv[2])<0 ){
    57         -    fprintf(stderr,"cannot read %s\n", g.argv[2]);
    58         -    fossil_exit(1);
           57  +    fossil_fatal("cannot read %s\n", g.argv[2]);
    59     58     }
    60     59     if( blob_read_from_file(&target, g.argv[3])<0 ){
    61         -    fprintf(stderr,"cannot read %s\n", g.argv[3]);
    62         -    fossil_exit(1);
           60  +    fossil_fatal("cannot read %s\n", g.argv[3]);
    63     61     }
    64     62     blob_delta_create(&orig, &target, &delta);
    65     63     if( blob_write_to_file(&delta, g.argv[4])<blob_size(&delta) ){
    66         -    fprintf(stderr,"cannot write %s\n", g.argv[4]);
    67         -    fossil_exit(1);
           64  +    fossil_fatal("cannot write %s\n", g.argv[4]);
    68     65     }
    69     66     blob_reset(&orig);
    70     67     blob_reset(&target);
    71     68     blob_reset(&delta);
    72     69   }
    73     70   
    74     71   /*
................................................................................
   112    109   */
   113    110   void delta_apply_cmd(void){
   114    111     Blob orig, target, delta;
   115    112     if( g.argc!=5 ){
   116    113       usage("ORIGIN DELTA TARGET");
   117    114     }
   118    115     if( blob_read_from_file(&orig, g.argv[2])<0 ){
   119         -    fprintf(stderr,"cannot read %s\n", g.argv[2]);
   120         -    fossil_exit(1);
          116  +    fossil_fatal("cannot read %s\n", g.argv[2]);
   121    117     }
   122    118     if( blob_read_from_file(&delta, g.argv[3])<0 ){
   123         -    fprintf(stderr,"cannot read %s\n", g.argv[3]);
   124         -    fossil_exit(1);
          119  +    fossil_fatal("cannot read %s\n", g.argv[3]);
   125    120     }
   126    121     blob_delta_apply(&orig, &delta, &target);
   127    122     if( blob_write_to_file(&target, g.argv[4])<blob_size(&target) ){
   128         -    fprintf(stderr,"cannot write %s\n", g.argv[4]);
   129         -    fossil_exit(1);
          123  +    fossil_fatal("cannot write %s\n", g.argv[4]);
   130    124     }
   131    125     blob_reset(&orig);
   132    126     blob_reset(&target);
   133    127     blob_reset(&delta);
   134    128   }
   135    129   
   136    130   /*
................................................................................
   150    144     blob_delta_create(&f1, &f2, &d12);
   151    145     blob_delta_create(&f2, &f1, &d21);
   152    146     blob_delta_apply(&f1, &d12, &a2);
   153    147     blob_delta_apply(&f2, &d21, &a1);
   154    148     if( blob_compare(&f1,&a1) || blob_compare(&f2, &a2) ){
   155    149       fossil_panic("delta test failed");
   156    150     }
   157         -  printf("ok\n");
          151  +  fossil_print("ok\n");
   158    152   }

Changes to src/diff.c.

   588    588     Blob a, b;
   589    589     int r;
   590    590     int i;
   591    591     int *R;
   592    592     if( g.argc<4 ) usage("FILE1 FILE2 ...");
   593    593     blob_read_from_file(&a, g.argv[2]);
   594    594     for(i=3; i<g.argc; i++){
   595         -    if( i>3 ) printf("-------------------------------\n");
          595  +    if( i>3 ) fossil_print("-------------------------------\n");
   596    596       blob_read_from_file(&b, g.argv[i]);
   597    597       R = text_diff(&a, &b, 0, 0, 0);
   598    598       for(r=0; R[r] || R[r+1] || R[r+2]; r += 3){
   599         -      printf(" copy %4d  delete %4d  insert %4d\n", R[r], R[r+1], R[r+2]);
          599  +      fossil_print(" copy %4d  delete %4d  insert %4d\n", R[r], R[r+1], R[r+2]);
   600    600       }
   601    601       /* free(R); */
   602    602       blob_reset(&b);
   603    603     }
   604    604   }
   605    605   
   606    606   /*
................................................................................
   741    741       if( annotation_step(&x, &b, g.argv[i-1]) ){
   742    742         fossil_fatal("binary file");
   743    743       }
   744    744     }
   745    745     for(i=0; i<x.nOrig; i++){
   746    746       const char *zSrc = x.aOrig[i].zSrc;
   747    747       if( zSrc==0 ) zSrc = g.argv[g.argc-1];
   748         -    printf("%10s: %.*s\n", zSrc, x.aOrig[i].n, x.aOrig[i].z);
          748  +    fossil_print("%10s: %.*s\n", zSrc, x.aOrig[i].n, x.aOrig[i].z);
   749    749     }
   750    750   }
   751    751   
   752    752   /* Annotation flags */
   753    753   #define ANN_FILE_VERS  0x001  /* Show file version rather than commit version */
   754    754   
   755    755   /*
................................................................................
   924    924     if( showLog ){
   925    925       for(i=0; i<ann.nVers; i++){
   926    926         printf("version %3d: %s\n", i+1, ann.azVers[i]);
   927    927       }
   928    928       printf("---------------------------------------------------\n");
   929    929     }
   930    930     for(i=0; i<ann.nOrig; i++){
   931         -    printf("%s: %.*s\n", ann.aOrig[i].zSrc, ann.aOrig[i].n, ann.aOrig[i].z);
          931  +    fossil_print("%s: %.*s\n", 
          932  +                 ann.aOrig[i].zSrc, ann.aOrig[i].n, ann.aOrig[i].z);
   932    933     }
   933    934   }

Changes to src/diffcmd.c.

    98     98   
    99     99       /* Construct a temporary file to hold pFile1 based on the name of
   100    100       ** zFile2 */
   101    101       blob_zero(&nameFile1);
   102    102       do{
   103    103         blob_reset(&nameFile1);
   104    104         blob_appendf(&nameFile1, "%s~%d", zFile2, cnt++);
   105         -    }while( access(blob_str(&nameFile1),0)==0 );
          105  +    }while( file_access(blob_str(&nameFile1),0)==0 );
   106    106       blob_write_to_file(pFile1, blob_str(&nameFile1));
   107    107   
   108    108       /* Construct the external diff command */
   109    109       blob_zero(&cmd);
   110    110       blob_appendf(&cmd, "%s ", zDiffCmd);
   111    111       shell_escape(&cmd, blob_str(&nameFile1));
   112    112       blob_append(&cmd, " ", 1);
   113    113       shell_escape(&cmd, zFile2);
   114    114   
   115    115       /* Run the external diff command */
   116    116       fossil_system(blob_str(&cmd));
   117    117   
   118    118       /* Delete the temporary file and clean up memory used */
   119         -    unlink(blob_str(&nameFile1));
          119  +    file_delete(blob_str(&nameFile1));
   120    120       blob_reset(&nameFile1);
   121    121       blob_reset(&cmd);
   122    122     }
   123    123   }
   124    124   
   125    125   /*
   126    126   ** Show the difference between two files, both in memory.
................................................................................
   166    166       blob_append(&cmd, " ", 1);
   167    167       shell_escape(&cmd, zTemp2);
   168    168   
   169    169       /* Run the external diff command */
   170    170       fossil_system(blob_str(&cmd));
   171    171   
   172    172       /* Delete the temporary file and clean up memory used */
   173         -    unlink(zTemp1);
   174         -    unlink(zTemp2);
          173  +    file_delete(zTemp1);
          174  +    file_delete(zTemp2);
   175    175       blob_reset(&cmd);
   176    176     }
   177    177   }
   178    178   
   179    179   /*
   180    180   ** Do a diff against a single file named in g.argv[2] from version zFrom
   181    181   ** against the same file on disk.
................................................................................
   261    261       int srcid = db_column_int(&q, 4);
   262    262       char *zFullName = mprintf("%s%s", g.zLocalRoot, zPathname);
   263    263       char *zToFree = zFullName;
   264    264       int showDiff = 1;
   265    265       if( isDeleted ){
   266    266         diff_printf("DELETED  %s\n", zPathname);
   267    267         if( !asNewFile ){ showDiff = 0; zFullName = "/dev/null"; }
   268         -    }else if( access(zFullName, 0) ){
          268  +    }else if( file_access(zFullName, 0) ){
   269    269         diff_printf("MISSING  %s\n", zPathname);
   270    270         if( !asNewFile ){ showDiff = 0; }
   271    271       }else if( isNew ){
   272    272         diff_printf("ADDED    %s\n", zPathname);
   273    273         srcid = 0;
   274    274         if( !asNewFile ){ showDiff = 0; }
   275    275       }else if( isChnged==3 ){

Changes to src/encode.c.

   338    338   ** Usage: %fossil test-encode64 STRING
   339    339   */
   340    340   void test_encode64_cmd(void){
   341    341     char *z;
   342    342     int i;
   343    343     for(i=2; i<g.argc; i++){
   344    344       z = encode64(g.argv[i], -1);
   345         -    printf("%s\n", z);
          345  +    fossil_print("%s\n", z);
   346    346       free(z);
   347    347     }
   348    348   }
   349    349   
   350    350   
   351    351   /*
   352    352   ** This function treats its input as a base-64 string and returns the
................................................................................
   403    403   ** Usage: %fossil test-decode64 STRING
   404    404   */
   405    405   void test_decode64_cmd(void){
   406    406     char *z;
   407    407     int i, n;
   408    408     for(i=2; i<g.argc; i++){
   409    409       z = decode64(g.argv[i], &n);
   410         -    printf("%d: %s\n", n, z);
          410  +    fossil_print("%d: %s\n", n, z);
   411    411       free(z);
   412    412     }
   413    413   }
   414    414   
   415    415   /*
   416    416   ** The base-16 encoding using the following characters:
   417    417   **
................................................................................
   577    577   */
   578    578   void test_obscure_cmd(void){
   579    579     int i;
   580    580     char *z, *z2;
   581    581     for(i=2; i<g.argc; i++){
   582    582       z = obscure(g.argv[i]);
   583    583       z2 = unobscure(z);
   584         -    printf("OBSCURE:    %s -> %s (%s)\n", g.argv[i], z, z2);
          584  +    fossil_print("OBSCURE:    %s -> %s (%s)\n", g.argv[i], z, z2);
   585    585       free(z);
   586    586       free(z2);
   587    587       z = unobscure(g.argv[i]);
   588         -    printf("UNOBSCURE:  %s -> %s\n", g.argv[i], z);
          588  +    fossil_print("UNOBSCURE:  %s -> %s\n", g.argv[i], z);
   589    589       free(z);
   590    590     }
   591    591   }

Changes to src/file.c.

    45     45   ** Return the number of errors.  No error messages are generated.
    46     46   */
    47     47   static int getStat(const char *zFilename){
    48     48     int rc = 0;
    49     49     if( zFilename==0 ){
    50     50       if( fileStatValid==0 ) rc = 1;
    51     51     }else{
    52         -    if( stat(zFilename, &fileStat)!=0 ){
           52  +    char *zMbcs = fossil_utf8_to_mbcs(zFilename);
           53  +    if( stat(zMbcs, &fileStat)!=0 ){
    53     54         fileStatValid = 0;
    54     55         rc = 1;
    55     56       }else{
    56     57         fileStatValid = 1;
    57     58         rc = 0;
    58     59       }
           60  +    fossil_mbcs_free(zMbcs);
    59     61     }
    60     62     return rc;
    61     63   }
    62     64   
    63     65   
    64     66   /*
    65     67   ** Return the size of a file in bytes.  Return -1 if the file does not
................................................................................
   118    120       rc = getStat(zFN);
   119    121       free(zFN);
   120    122     }else{
   121    123       rc = getStat(0);
   122    124     }
   123    125     return rc ? 0 : (S_ISDIR(fileStat.st_mode) ? 1 : 2);
   124    126   }
          127  +
          128  +/*
          129  +** Wrapper around the access() system call.
          130  +*/
          131  +int file_access(const char *zFilename, int flags){
          132  +  char *zMbcs = fossil_utf8_to_mbcs(zFilename);
          133  +  int rc = access(zMbcs, flags);
          134  +  fossil_mbcs_free(zMbcs);
          135  +  return rc;
          136  +}
   125    137   
   126    138   /*
   127    139   ** Find an unused filename similar to zBase with zSuffix appended.
   128    140   **
   129    141   ** Make the name relative to the working directory if relFlag is true.
   130    142   **
   131    143   ** Space to hold the new filename is obtained form mprintf() and should
................................................................................
   164    176   /*
   165    177   ** Copy the content of a file from one place to another.
   166    178   */
   167    179   void file_copy(const char *zFrom, const char *zTo){
   168    180     FILE *in, *out;
   169    181     int got;
   170    182     char zBuf[8192];
   171         -  in = fopen(zFrom, "rb");
          183  +  in = fossil_fopen(zFrom, "rb");
   172    184     if( in==0 ) fossil_fatal("cannot open \"%s\" for reading", zFrom);
   173         -  out = fopen(zTo, "wb");
          185  +  out = fossil_fopen(zTo, "wb");
   174    186     if( out==0 ) fossil_fatal("cannot open \"%s\" for writing", zTo);
   175    187     while( (got=fread(zBuf, 1, sizeof(zBuf), in))>0 ){
   176    188       fwrite(zBuf, 1, got, out);
   177    189     }
   178    190     fclose(in);
   179    191     fclose(out);
   180    192   }
................................................................................
   198    210         chmod(zFilename, buf.st_mode & ~0111);
   199    211         rc = 1;
   200    212       }
   201    213     }
   202    214   #endif /* _WIN32 */
   203    215     return rc;
   204    216   }
          217  +
          218  +/*
          219  +** Delete a file.
          220  +*/
          221  +void file_delete(const char *zFilename){
          222  +  char *z = fossil_utf8_to_mbcs(zFilename);
          223  +  unlink(z);
          224  +  fossil_mbcs_free(z);
          225  +}
   205    226   
   206    227   /*
   207    228   ** Create the directory named in the argument, if it does not already
   208    229   ** exist.  If forceFlag is 1, delete any prior non-directory object 
   209    230   ** with the same name.
   210    231   **
   211    232   ** Return the number of errors.
   212    233   */
   213    234   int file_mkdir(const char *zName, int forceFlag){
   214    235     int rc = file_isdir(zName);
   215    236     if( rc==2 ){
   216    237       if( !forceFlag ) return 1;
   217         -    unlink(zName);
          238  +    file_delete(zName);
   218    239     }
   219    240     if( rc!=1 ){
   220    241   #if defined(_WIN32)
   221         -    return mkdir(zName);
          242  +    int rc;
          243  +    char *zMbcs = fossil_utf8_to_mbcs(zName);
          244  +    rc = mkdir(zMbcs);
          245  +    fossil_mbcs_free(zMbcs);
          246  +    return rc;
   222    247   #else
   223    248       return mkdir(zName, 0755);
   224    249   #endif
   225    250     }
   226    251     return 0;
   227    252   }
   228    253   
................................................................................
   348    373   ** Print the simplified versions of each FILENAME.
   349    374   */
   350    375   void cmd_test_simplify_name(void){
   351    376     int i;
   352    377     char *z;
   353    378     for(i=2; i<g.argc; i++){
   354    379       z = mprintf("%s", g.argv[i]);
   355         -    printf("[%s] -> ", z);
          380  +    fossil_print("[%s] -> ", z);
   356    381       file_simplify_name(z, -1);
   357         -    printf("[%s]\n", z);
          382  +    fossil_print("[%s]\n", z);
   358    383       fossil_free(z);
   359    384     }
   360    385   }
   361    386   
   362    387   /*
   363    388   ** Compute a canonical pathname for a file or directory.
   364    389   ** Make the name absolute if it is relative.
................................................................................
   375    400   #endif
   376    401     ){
   377    402       blob_set(pOut, zOrigName);
   378    403       blob_materialize(pOut);
   379    404     }else{
   380    405       char zPwd[2000];
   381    406       if( getcwd(zPwd, sizeof(zPwd)-20)==0 ){
   382         -      fprintf(stderr, "pwd too big: max %d\n", (int)sizeof(zPwd)-20);
   383         -      fossil_exit(1);
          407  +      fossil_fatal("pwd too big: max %d\n", (int)sizeof(zPwd)-20);
   384    408       }
   385    409       blob_zero(pOut);
   386    410       blob_appendf(pOut, "%//%/", zPwd, zOrigName);
   387    411     }
   388    412     blob_resize(pOut, file_simplify_name(blob_buffer(pOut), blob_size(pOut)));
   389    413   }
   390    414   
................................................................................
   399    423     int i;
   400    424     Blob x;
   401    425     blob_zero(&x);
   402    426     for(i=2; i<g.argc; i++){
   403    427       char zBuf[100];
   404    428       const char *zName = g.argv[i];
   405    429       file_canonical_name(zName, &x);
   406         -    printf("[%s] -> [%s]\n", zName, blob_buffer(&x));
          430  +    fossil_print("[%s] -> [%s]\n", zName, blob_buffer(&x));
   407    431       blob_reset(&x);
   408    432       sqlite3_snprintf(sizeof(zBuf), zBuf, "%lld", file_size(zName));
   409         -    printf("  file_size   = %s\n", zBuf);
          433  +    fossil_print("  file_size   = %s\n", zBuf);
   410    434       sqlite3_snprintf(sizeof(zBuf), zBuf, "%lld", file_mtime(zName));
   411         -    printf("  file_mtime  = %s\n", zBuf);
   412         -    printf("  file_isfile = %d\n", file_isfile(zName));
   413         -    printf("  file_isexe  = %d\n", file_isexe(zName));
   414         -    printf("  file_isdir  = %d\n", file_isdir(zName));
          435  +    fossil_print("  file_mtime  = %s\n", zBuf);
          436  +    fossil_print("  file_isfile = %d\n", file_isfile(zName));
          437  +    fossil_print("  file_isexe  = %d\n", file_isexe(zName));
          438  +    fossil_print("  file_isdir  = %d\n", file_isdir(zName));
   415    439     }
   416    440   }
   417    441   
   418    442   /*
   419    443   ** Return TRUE if the given filename is canonical.
   420    444   **
   421    445   ** Canonical names are full pathnames using "/" not "\" and which
................................................................................
   451    475     blob_resize(pOut, file_simplify_name(blob_buffer(pOut), blob_size(pOut))); 
   452    476     zPath = blob_buffer(pOut);
   453    477     if( zPath[0]=='/' ){
   454    478       int i, j;
   455    479       Blob tmp;
   456    480       char zPwd[2000];
   457    481       if( getcwd(zPwd, sizeof(zPwd)-20)==0 ){
   458         -      fprintf(stderr, "pwd too big: max %d\n", (int)sizeof(zPwd)-20);
   459         -      fossil_exit(1);
          482  +      fossil_fatal("pwd too big: max %d\n", (int)sizeof(zPwd)-20);
   460    483       }
   461    484       for(i=1; zPath[i] && zPwd[i]==zPath[i]; i++){}
   462    485       if( zPath[i]==0 ){
   463    486         blob_reset(pOut);
   464    487         if( zPwd[i]==0 ){
   465    488           blob_append(pOut, ".", 1);
   466    489         }else{
................................................................................
   500    523   */
   501    524   void cmd_test_relative_name(void){
   502    525     int i;
   503    526     Blob x;
   504    527     blob_zero(&x);
   505    528     for(i=2; i<g.argc; i++){
   506    529       file_relative_name(g.argv[i], &x);
   507         -    printf("%s\n", blob_buffer(&x));
          530  +    fossil_print("%s\n", blob_buffer(&x));
   508    531       blob_reset(&x);
   509    532     }
   510    533   }
   511    534   
   512    535   /*
   513    536   ** Compute a pathname for a file relative to the root of the local
   514    537   ** tree.  Return TRUE on success.  On failure, print and error
................................................................................
   555    578   */
   556    579   void cmd_test_tree_name(void){
   557    580     int i;
   558    581     Blob x;
   559    582     blob_zero(&x);
   560    583     for(i=2; i<g.argc; i++){
   561    584       if( file_tree_name(g.argv[i], &x, 1) ){
   562         -      printf("%s\n", blob_buffer(&x));
          585  +      fossil_print("%s\n", blob_buffer(&x));
   563    586         blob_reset(&x);
   564    587       }
   565    588     }
   566    589   }
   567    590   
   568    591   /*
   569    592   ** Parse a URI into scheme, host, port, and path.
................................................................................
   618    641        ".",
   619    642     };
   620    643     static const unsigned char zChars[] =
   621    644       "abcdefghijklmnopqrstuvwxyz"
   622    645       "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
   623    646       "0123456789";
   624    647     unsigned int i, j;
   625         -  struct stat buf;
   626    648     const char *zDir = ".";
   627    649     
   628    650     for(i=0; i<sizeof(azDirs)/sizeof(azDirs[0]); i++){
   629         -    if( stat(azDirs[i], &buf) ) continue;
   630         -    if( !S_ISDIR(buf.st_mode) ) continue;
   631         -    if( access(azDirs[i], 07) ) continue;
          651  +    if( !file_isdir(azDirs[i]) ) continue;
   632    652       zDir = azDirs[i];
   633    653       break;
   634    654     }
   635    655   
   636    656     /* Check that the output buffer is large enough for the temporary file 
   637    657     ** name. If it is not, return SQLITE_ERROR.
   638    658     */
................................................................................
   644    664       sqlite3_snprintf(nBuf-17, zBuf, "%s/", zDir);
   645    665       j = (int)strlen(zBuf);
   646    666       sqlite3_randomness(15, &zBuf[j]);
   647    667       for(i=0; i<15; i++, j++){
   648    668         zBuf[j] = (char)zChars[ ((unsigned char)zBuf[j])%(sizeof(zChars)-1) ];
   649    669       }
   650    670       zBuf[j] = 0;
   651         -  }while( access(zBuf,0)==0 );
          671  +  }while( file_size(zBuf)<0 );
   652    672   }
   653    673   
   654    674   
   655    675   /*
   656    676   ** Return true if a file named zName exists and has identical content
   657    677   ** to the blob pContent.  If zName does not exist or if the content is
   658    678   ** different in any way, then return false.
................................................................................
   666    686     if( iSize<0 ) return 0;
   667    687     if( iSize!=blob_size(pContent) ) return 0;
   668    688     blob_read_from_file(&onDisk, zName);
   669    689     rc = blob_compare(&onDisk, pContent);
   670    690     blob_reset(&onDisk);
   671    691     return rc==0;
   672    692   }
          693  +
          694  +
          695  +/**************************************************************************
          696  +** The following routines translate between MBCS and UTF8 on windows.
          697  +** Since everything is always UTF8 on unix, these routines are no-ops
          698  +** there.
          699  +*/
          700  +#ifdef _WIN32
          701  +# include <windows.h>
          702  +#endif
          703  +
          704  +/*
          705  +** Translate MBCS to UTF8.  Return a pointer to the translated text.  
          706  +** Call fossil_mbcs_free() to deallocate any memory used to store the
          707  +** returned pointer when done.
          708  +*/
          709  +char *fossil_mbcs_to_utf8(const char *zMbcs){
          710  +#ifdef _WIN32
          711  +  extern char *sqlite3_win32_mbcs_to_utf8(const char*);
          712  +  return sqlite3_win32_mbcs_to_utf8(zMbcs);
          713  +#else
          714  +  return (char*)zMbcs;  /* No-op on unix */
          715  +#endif  
          716  +}
          717  +
          718  +/*
          719  +** Translate UTF8 to MBCS for use in system calls.  Return a pointer to the
          720  +** translated text..  Call fossil_mbcs_free() to deallocate any memory
          721  +** used to store the returned pointer when done.
          722  +*/
          723  +char *fossil_utf8_to_mbcs(const char *zUtf8){
          724  +#ifdef _WIN32
          725  +  extern char *sqlite3_win32_utf8_to_mbcs(const char*);
          726  +  return sqlite3_win32_utf8_to_mbcs(zUtf8);
          727  +#else
          728  +  return (char*)zUtf8;  /* No-op on unix */
          729  +#endif  
          730  +}
          731  +
          732  +/*
          733  +** Translate UTF8 to MBCS for display on the console.  Return a pointer to the
          734  +** translated text..  Call fossil_mbcs_free() to deallocate any memory
          735  +** used to store the returned pointer when done.
          736  +*/
          737  +char *fossil_utf8_to_console(const char *zUtf8){
          738  +#ifdef _WIN32
          739  +  int nChar, nByte;
          740  +  WCHAR *zUnicode;   /* Unicode version of zUtf8 */
          741  +  char *zConsole;    /* Console version of zUtf8 */
          742  +  int codepage;      /* Console code page */
          743  +
          744  +  nChar = MultiByteToWideChar(CP_UTF8, 0, zUtf8, -1, NULL, 0);
          745  +  zUnicode = malloc( nChar*sizeof(zUnicode[0]) );
          746  +  if( zUnicode==0 ){
          747  +    return 0;
          748  +  }
          749  +  nChar = MultiByteToWideChar(CP_UTF8, 0, zUtf8, -1, zUnicode, nChar);
          750  +  if( nChar==0 ){
          751  +    free(zUnicode);
          752  +    return 0;
          753  +  }
          754  +  codepage = GetConsoleCP();
          755  +  nByte = WideCharToMultiByte(codepage, 0, zUnicode, -1, 0, 0, 0, 0);
          756  +  zConsole = malloc( nByte );
          757  +  if( zConsole==0 ){
          758  +    free(zUnicode);
          759  +    return 0;
          760  +  }
          761  +  nByte = WideCharToMultiByte(codepage, 0, zUnicode, -1, zConsole, nByte, 0, 0);
          762  +  free(zUnicode);
          763  +  if( nByte == 0 ){
          764  +    free(zConsole);
          765  +    zConsole = 0;
          766  +  }
          767  +  return zConsole;
          768  +#else
          769  +  return (char*)zUtf8;  /* No-op on unix */
          770  +#endif  
          771  +}
          772  +
          773  +/*
          774  +** Translate MBCS to UTF8.  Return a pointer.  Call fossil_mbcs_free()
          775  +** to deallocate any memory used to store the returned pointer when done.
          776  +*/
          777  +void fossil_mbcs_free(char *zOld){
          778  +#ifdef _WIN32
          779  +  free(zOld);
          780  +#else
          781  +  /* No-op on unix */
          782  +#endif  
          783  +}
          784  +
          785  +/*
          786  +** Like fopen() but always takes a UTF8 argument.
          787  +*/
          788  +FILE *fossil_fopen(const char *zName, const char *zMode){
          789  +  char *zMbcs = fossil_utf8_to_mbcs(zName);
          790  +  FILE *f = fopen(zMbcs, zMode);
          791  +  fossil_mbcs_free(zMbcs);
          792  +  return f;
          793  +}

Changes to src/finfo.c.

    87     87         blob_appendf(&line, " ");
    88     88         blob_appendf(&line, " %10.10s", blob_str(&uuid));
    89     89         blob_reset(&uuid);
    90     90       }else{
    91     91         blob_appendf(&line, "unknown 0000000000");
    92     92       }
    93     93       db_finalize(&q);
    94         -    printf("%s\n", blob_str(&line));
           94  +    fossil_print("%s\n", blob_str(&line));
    95     95       blob_reset(&fname);
    96     96       blob_reset(&line);
    97     97     }else if( find_option("print","p",0) ){
    98     98       Blob record;
    99     99       Blob fname;
   100    100       const char *zRevision = find_option("revision", "r", 1);
   101    101   
................................................................................
   150    150           "   AND event.objid=mlink.mid"
   151    151           "   AND event.objid=ci.rid"
   152    152           " ORDER BY event.mtime DESC LIMIT %d OFFSET %d",
   153    153           zFilename, iLimit, iOffset
   154    154       );
   155    155       blob_zero(&line);
   156    156       if( iBrief ){
   157         -      printf("History of %s\n", blob_str(&fname));
          157  +      fossil_print("History of %s\n", blob_str(&fname));
   158    158       }
   159    159       while( db_step(&q)==SQLITE_ROW ){
   160    160         const char *zFileUuid = db_column_text(&q, 0);
   161    161         const char *zCiUuid = db_column_text(&q,1);
   162    162         const char *zDate = db_column_text(&q, 2);
   163    163         const char *zCom = db_column_text(&q, 3);
   164    164         const char *zUser = db_column_text(&q, 4);
   165    165         char *zOut;
   166    166         if( iBrief ){
   167         -        printf("%s ", zDate);
          167  +        fossil_print("%s ", zDate);
   168    168           zOut = sqlite3_mprintf("[%.10s] %s (user: %s, artifact: [%.10s])",
   169    169                                  zCiUuid, zCom, zUser, zFileUuid);
   170    170           comment_print(zOut, 11, 79);
   171    171           sqlite3_free(zOut);
   172    172         }else{
   173    173           blob_reset(&line);
   174    174           blob_appendf(&line, "%.10s ", zCiUuid);

Changes to src/glob.c.

   248    248   ** PATTERN is a comma-separated list of glob patterns.  Show which of
   249    249   ** the STRINGs that follow match the PATTERN.
   250    250   */
   251    251   void glob_test_cmd(void){
   252    252     Glob *pGlob;
   253    253     int i;
   254    254     if( g.argc<4 ) usage("PATTERN STRING ...");
   255         -  printf("SQL expression: %s\n", glob_expr("x", g.argv[2]));
          255  +  fossil_print("SQL expression: %s\n", glob_expr("x", g.argv[2]));
   256    256     pGlob = glob_create(g.argv[2]);
   257    257     for(i=0; i<pGlob->nPattern; i++){
   258         -    printf("pattern[%d] = [%s]\n", i, pGlob->azPattern[i]);
          258  +    fossil_print("pattern[%d] = [%s]\n", i, pGlob->azPattern[i]);
   259    259     }
   260    260     for(i=3; i<g.argc; i++){
   261         -    printf("%d %s\n", glob_match(pGlob, g.argv[i]), g.argv[i]);
          261  +    fossil_print("%d %s\n", glob_match(pGlob, g.argv[i]), g.argv[i]);
   262    262     }
   263    263     glob_free(pGlob);
   264    264   }

Changes to src/http_transport.c.

   118    118       if( g.urlPort!=g.urlDfltPort ){
   119    119   #ifdef __MINGW32__
   120    120         blob_appendf(&zCmd, " -P %d", g.urlPort);
   121    121   #else
   122    122         blob_appendf(&zCmd, " -p %d", g.urlPort);
   123    123   #endif
   124    124       }
   125         -    printf("%s", blob_str(&zCmd));  /* Show the base of the SSH command */
          125  +    fossil_print("%s", blob_str(&zCmd));  /* Show the base of the SSH command */
   126    126       if( g.urlUser && g.urlUser[0] ){
   127    127         zHost = mprintf("%s@%s", g.urlUser, g.urlName);
   128    128   #ifdef __MINGW32__
   129    129         /* Only win32 (and specifically PLINK.EXE) support the -pw option */
   130    130         if( g.urlPasswd && g.urlPasswd[0] ){
   131    131           Blob pw;
   132    132           blob_zero(&pw);
................................................................................
   137    137             free(zPrompt);
   138    138           }else{
   139    139             blob_init(&pw, g.urlPasswd, -1);
   140    140           }
   141    141           blob_append(&zCmd, " -pw ", -1);
   142    142           shell_escape(&zCmd, blob_str(&pw));
   143    143           blob_reset(&pw);
   144         -        printf(" -pw ********");  /* Do not show the password text */
          144  +        fossil_print(" -pw ********");  /* Do not show the password text */
   145    145         }
   146    146   #endif
   147    147       }else{
   148    148         zHost = mprintf("%s", g.urlName);
   149    149       }
   150    150       blob_append(&zCmd, " ", 1);
   151    151       shell_escape(&zCmd, zHost);
   152         -    printf(" %s\n", zHost);  /* Show the conclusion of the SSH command */
          152  +    fossil_print(" %s\n", zHost);  /* Show the conclusion of the SSH command */
   153    153       free(zHost);
   154    154       popen2(blob_str(&zCmd), &sshIn, &sshOut, &sshPid);
   155    155       if( sshPid==0 ){
   156    156         fossil_fatal("cannot start ssh tunnel using [%b]", &zCmd);
   157    157       }
   158    158       blob_reset(&zCmd);
   159    159   
................................................................................
   244    244         ssl_close();
   245    245         #endif
   246    246       }else if( g.urlIsFile ){
   247    247         if( transport.pFile ){ 
   248    248           fclose(transport.pFile);
   249    249           transport.pFile = 0;
   250    250         }
   251         -      unlink(transport.zInFile);
   252         -      unlink(transport.zOutFile);
          251  +      file_delete(transport.zInFile);
          252  +      file_delete(transport.zOutFile);
   253    253         free(transport.zInFile);
   254    254         free(transport.zOutFile);
   255    255       }else{
   256    256         socket_close();
   257    257       }
   258    258       transport.isOpen = 0;
   259    259     }

Changes to src/import.c.

   495    495       }else
   496    496       if( memcmp(zLine, "option", 6)==0 ){
   497    497         gg.xFinish();
   498    498       }else
   499    499       if( memcmp(zLine, "progress ", 9)==0 ){
   500    500         gg.xFinish();
   501    501         trim_newline(&zLine[9]);
   502         -      printf("%s\n", &zLine[9]);
          502  +      fossil_print("%s\n", &zLine[9]);
   503    503         fflush(stdout);
   504    504       }else
   505    505       if( memcmp(zLine, "data ", 5)==0 ){
   506    506         fossil_free(gg.aData); gg.aData = 0;
   507    507         gg.nData = atoi(&zLine[5]);
   508    508         if( gg.nData ){
   509    509           int got;
................................................................................
   695    695     if( g.argc==4 ){
   696    696       pIn = fopen(g.argv[3], "rb");
   697    697     }else{
   698    698       pIn = stdin;
   699    699       fossil_binary_mode(pIn);
   700    700     }
   701    701     if( !incrFlag ){
   702         -    if( forceFlag ) unlink(g.argv[2]);
          702  +    if( forceFlag ) file_delete(g.argv[2]);
   703    703       db_create_repository(g.argv[2]);
   704    704     }
   705    705     db_open_repository(g.argv[2]);
   706    706     db_open_config(0);
   707    707   
   708    708     /* The following temp-tables are used to hold information needed for
   709    709     ** the import.
................................................................................
   740    740       db_ephemeral_blob(&q, 0, &record);
   741    741       fast_insert_content(&record, 0, 0);
   742    742       import_reset(0);
   743    743     }
   744    744     db_finalize(&q);
   745    745     db_end_transaction(0);
   746    746     db_begin_transaction();
   747         -  printf("Rebuilding repository meta-data...\n");
          747  +  fossil_print("Rebuilding repository meta-data...\n");
   748    748     rebuild_db(0, 1, !incrFlag);
   749    749     verify_cancel();
   750    750     db_end_transaction(0);
   751         -  printf("Vacuuming..."); fflush(stdout);
          751  +  fossil_print("Vacuuming..."); fflush(stdout);
   752    752     db_multi_exec("VACUUM");
   753         -  printf(" ok\n");
          753  +  fossil_print(" ok\n");
   754    754     if( !incrFlag ){
   755         -    printf("project-id: %s\n", db_get("project-code", 0));
   756         -    printf("server-id:  %s\n", db_get("server-code", 0));
          755  +    fossil_print("project-id: %s\n", db_get("project-code", 0));
          756  +    fossil_print("server-id:  %s\n", db_get("server-code", 0));
   757    757       zPassword = db_text(0, "SELECT pw FROM user WHERE login=%Q", g.zLogin);
   758         -    printf("admin-user: %s (password is \"%s\")\n", g.zLogin, zPassword);
          758  +    fossil_print("admin-user: %s (password is \"%s\")\n", g.zLogin, zPassword);
   759    759     }
   760    760   }

Changes to src/info.c.

    65     65     zUuid = db_text(0, "SELECT uuid FROM blob WHERE rid=%d", rid);
    66     66     if( zUuid ){
    67     67       zDate = db_text(0, 
    68     68         "SELECT datetime(mtime) || ' UTC' FROM event WHERE objid=%d",
    69     69         rid
    70     70       );
    71     71            /* 01234567890123 */
    72         -    printf("%-13s %s %s\n", zUuidName, zUuid, zDate ? zDate : "");
           72  +    fossil_print("%-13s %s %s\n", zUuidName, zUuid, zDate ? zDate : "");
    73     73       free(zUuid);
    74     74       free(zDate);
    75     75     }
    76     76     if( zUuid && showComment ){
    77     77       zComment = db_text(0, 
    78     78         "SELECT coalesce(ecomment,comment) || "
    79     79         "       ' (user: ' || coalesce(euser,user,'?') || ')' "
................................................................................
    86     86                      " WHERE cid=%d", rid);
    87     87       while( db_step(&q)==SQLITE_ROW ){
    88     88         const char *zUuid = db_column_text(&q, 0);
    89     89         zDate = db_text("", 
    90     90           "SELECT datetime(mtime) || ' UTC' FROM event WHERE objid=%d",
    91     91           db_column_int(&q, 1)
    92     92         );
    93         -      printf("parent:       %s %s\n", zUuid, zDate);
           93  +      fossil_print("parent:       %s %s\n", zUuid, zDate);
    94     94         free(zDate);
    95     95       }
    96     96       db_finalize(&q);
    97     97       db_prepare(&q, "SELECT uuid, cid FROM plink JOIN blob ON cid=rid "
    98     98                      " WHERE pid=%d", rid);
    99     99       while( db_step(&q)==SQLITE_ROW ){
   100    100         const char *zUuid = db_column_text(&q, 0);
   101    101         zDate = db_text("", 
   102    102           "SELECT datetime(mtime) || ' UTC' FROM event WHERE objid=%d",
   103    103           db_column_int(&q, 1)
   104    104         );
   105         -      printf("child:        %s %s\n", zUuid, zDate);
          105  +      fossil_print("child:        %s %s\n", zUuid, zDate);
   106    106         free(zDate);
   107    107       }
   108    108       db_finalize(&q);
   109    109     }
   110    110     zTags = info_tags_of_checkin(rid, 0);
   111    111     if( zTags && zTags[0] ){
   112         -    printf("tags:         %s\n", zTags);
          112  +    fossil_print("tags:         %s\n", zTags);
   113    113     }
   114    114     free(zTags);
   115    115     if( zComment ){
   116         -    printf("comment:      ");
          116  +    fossil_print("comment:      ");
   117    117       comment_print(zComment, 14, 79);
   118    118       free(zComment);
   119    119     }
   120    120   }
   121    121   
   122    122   
   123    123   /*
................................................................................
   139    139     if( g.argc!=2 && g.argc!=3 ){
   140    140       usage("?FILENAME|ARTIFACT-ID?");
   141    141     }
   142    142     if( g.argc==3 && (fsize = file_size(g.argv[2]))>0 && (fsize&0x1ff)==0 ){
   143    143       db_open_config(0);
   144    144       db_record_repository_filename(g.argv[2]);
   145    145       db_open_repository(g.argv[2]);
   146         -    printf("project-name: %s\n", db_get("project-name", "<unnamed>"));
   147         -    printf("project-code: %s\n", db_get("project-code", "<none>"));
   148         -    printf("server-code:  %s\n", db_get("server-code", "<none>"));
          146  +    fossil_print("project-name: %s\n", db_get("project-name", "<unnamed>"));
          147  +    fossil_print("project-code: %s\n", db_get("project-code", "<none>"));
          148  +    fossil_print("server-code:  %s\n", db_get("server-code", "<none>"));
   149    149       return;
   150    150     }
   151    151     db_must_be_within_tree();
   152    152     if( g.argc==2 ){
   153    153       int vid;
   154    154            /* 012345678901234 */
   155    155       db_record_repository_filename(0);
   156         -    printf("project-name: %s\n", db_get("project-name", "<unnamed>"));
   157         -    printf("repository:   %s\n", db_lget("repository", ""));
   158         -    printf("local-root:   %s\n", g.zLocalRoot);
          156  +    fossil_print("project-name: %s\n", db_get("project-name", "<unnamed>"));
          157  +    fossil_print("repository:   %s\n", db_lget("repository", ""));
          158  +    fossil_print("local-root:   %s\n", g.zLocalRoot);
   159    159   #if defined(_WIN32)
   160    160       if( g.zHome ){
   161         -      printf("user-home:    %s\n", g.zHome);
          161  +      fossil_print("user-home:    %s\n", g.zHome);
   162    162       }
   163    163   #endif
   164         -    printf("project-code: %s\n", db_get("project-code", ""));
   165         -    printf("server-code:  %s\n", db_get("server-code", ""));
          164  +    fossil_print("project-code: %s\n", db_get("project-code", ""));
          165  +    fossil_print("server-code:  %s\n", db_get("server-code", ""));
   166    166       vid = db_lget_int("checkout", 0);
   167    167       if( vid==0 ){
   168         -      printf("checkout:     nil\n");
          168  +      fossil_print("checkout:     nil\n");
   169    169       }else{
   170    170         show_common_info(vid, "checkout:", 1, 1);
   171    171       }
   172    172     }else{
   173    173       int rid;
   174    174       rid = name_to_rid(g.argv[2]);
   175    175       if( rid==0 ){

Changes to src/main.c.

   225    225   /*
   226    226   ** This procedure runs first.
   227    227   */
   228    228   int main(int argc, char **argv){
   229    229     const char *zCmdName = "unknown";
   230    230     int idx;
   231    231     int rc;
          232  +  int i;
   232    233   
   233    234     sqlite3_config(SQLITE_CONFIG_LOG, fossil_sqlite_log, 0);
   234    235     g.now = time(0);
   235    236     g.argc = argc;
   236    237     g.argv = argv;
          238  +  for(i=0; i<argc; i++) g.argv[i] = fossil_mbcs_to_utf8(argv[i]);
   237    239     if( getenv("GATEWAY_INTERFACE")!=0 && !find_option("nocgi", 0, 0)){
   238    240       zCmdName = "cgi";
   239    241     }else if( argc<2 ){
   240         -    fprintf(stderr, "Usage: %s COMMAND ...\n"
   241         -                    "\"%s help\" for a list of available commands\n"
   242         -                    "\"%s help COMMAND\" for specific details\n",
   243         -                    argv[0], argv[0], argv[0]);
   244         -    fossil_exit(1);
          242  +    fossil_fatal("Usage: %s COMMAND ...\n"
          243  +                 "\"%s help\" for a list of available commands\n"
          244  +                 "\"%s help COMMAND\" for specific details\n",
          245  +                 argv[0], argv[0], argv[0]);
   245    246     }else{
   246    247       g.fQuiet = find_option("quiet", 0, 0)!=0;
   247    248       g.fSqlTrace = find_option("sqltrace", 0, 0)!=0;
   248    249       g.fSqlStats = find_option("sqlstats", 0, 0)!=0;
   249    250       if( g.fSqlTrace ) g.fSqlStats = 1;
   250    251       g.fSqlPrint = find_option("sqlprint", 0, 0)!=0;
   251    252       g.fHttpTrace = find_option("httptrace", 0, 0)!=0;
................................................................................
   262    263         g.argc++;
   263    264         g.argv = zNewArgv;
   264    265       }
   265    266       zCmdName = g.argv[1];
   266    267     }
   267    268     rc = name_search(zCmdName, aCommand, count(aCommand), &idx);
   268    269     if( rc==1 ){
   269         -    fprintf(stderr,"%s: unknown command: %s\n"
   270         -                   "%s: use \"help\" for more information\n",
          270  +    fossil_fatal("%s: unknown command: %s\n"
          271  +                 "%s: use \"help\" for more information\n",
   271    272                      argv[0], zCmdName, argv[0]);
   272         -    fossil_exit(1);
   273    273     }else if( rc==2 ){
   274    274       int i, n;
   275    275       Blob couldbe;
   276    276       blob_zero(&couldbe);
   277    277       n = strlen(zCmdName);
   278    278       for(i=0; i<count(aCommand); i++){
   279    279         if( memcmp(zCmdName, aCommand[i].zName, n)==0 ){
   280    280           blob_appendf(&couldbe, " %s", aCommand[i].zName);
   281    281         }
   282    282       }
   283         -    fprintf(stderr,"%s: ambiguous command prefix: %s\n"
   284         -                   "%s: could be any of:%s\n"
   285         -                   "%s: use \"help\" for more information\n",
   286         -                   argv[0], zCmdName, argv[0], blob_str(&couldbe), argv[0]);
   287         -    fossil_exit(1);
          283  +    fossil_fatal("%s: ambiguous command prefix: %s\n"
          284  +                 "%s: could be any of:%s\n"
          285  +                 "%s: use \"help\" for more information\n",
          286  +                 argv[0], zCmdName, argv[0], blob_str(&couldbe), argv[0]);
   288    287     }
   289    288     aCommand[idx].xFunc();
   290    289     fossil_exit(0);
   291    290     /*NOT_REACHED*/
   292    291     return 0;
   293    292   }
   294    293   
................................................................................
   331    330     z = vmprintf(zFormat, ap);
   332    331     va_end(ap);
   333    332     if( g.cgiOutput && once ){
   334    333       once = 0;
   335    334       cgi_printf("<p class=\"generalError\">%h</p>", z);
   336    335       cgi_reply();
   337    336     }else{
   338         -    fprintf(stderr, "%s: %s\n", fossil_nameofexe(), z);
          337  +    char *zOut = mprintf("%s: %s\n", fossil_nameofexe(), z);
          338  +    fossil_puts(zOut, 1);
   339    339     }
   340    340     db_force_rollback();
   341    341     fossil_exit(1);
   342    342   }
   343    343   void fossil_fatal(const char *zFormat, ...){
   344    344     char *z;
   345    345     va_list ap;
................................................................................
   348    348     z = vmprintf(zFormat, ap);
   349    349     va_end(ap);
   350    350     if( g.cgiOutput ){
   351    351       g.cgiOutput = 0;
   352    352       cgi_printf("<p class=\"generalError\">%h</p>", z);
   353    353       cgi_reply();
   354    354     }else{
   355         -    fprintf(stderr, "\r%s: %s\n", fossil_nameofexe(), z);
          355  +    char *zOut = mprintf("\r%s: %s\n", fossil_nameofexe(), z);
          356  +    fossil_puts(zOut, 1);
   356    357     }
   357    358     db_force_rollback();
   358    359     fossil_exit(1);
   359    360   }
   360    361   
   361    362   /* This routine works like fossil_fatal() except that if called
   362    363   ** recursively, the recursive call is a no-op.
................................................................................
   376    377     z = vmprintf(zFormat, ap);
   377    378     va_end(ap);
   378    379     if( g.cgiOutput ){
   379    380       g.cgiOutput = 0;
   380    381       cgi_printf("<p class=\"generalError\">%h</p>", z);
   381    382       cgi_reply();
   382    383     }else{
   383         -    fprintf(stderr, "\r%s: %s\n", fossil_nameofexe(), z);
          384  +    char *zOut = mprintf("\r%s: %s\n", fossil_nameofexe(), z);
          385  +    fossil_puts(zOut, 1);
   384    386     }
   385    387     db_force_rollback();
   386    388     fossil_exit(1);
   387    389   }
   388    390   
   389    391   
   390    392   /* Print a warning message */
................................................................................
   393    395     va_list ap;
   394    396     va_start(ap, zFormat);
   395    397     z = vmprintf(zFormat, ap);
   396    398     va_end(ap);
   397    399     if( g.cgiOutput ){
   398    400       cgi_printf("<p class=\"generalError\">%h</p>", z);
   399    401     }else{
   400         -    fprintf(stderr, "\r%s: %s\n", fossil_nameofexe(), z);
          402  +    char *zOut = mprintf("\r%s: %s\n", fossil_nameofexe(), z);
          403  +    fossil_puts(zOut, 1);
          404  +    free(zOut);
   401    405     }
   402    406   }
   403    407   
   404    408   /*
   405    409   ** Malloc and free routines that cannot fail
   406    410   */
   407    411   void *fossil_malloc(size_t n){
................................................................................
   424    428   int fossil_system(const char *zOrigCmd){
   425    429     int rc;
   426    430   #if defined(_WIN32)
   427    431     /* On windows, we have to put double-quotes around the entire command.
   428    432     ** Who knows why - this is just the way windows works.
   429    433     */
   430    434     char *zNewCmd = mprintf("\"%s\"", zOrigCmd);
   431         -  rc = system(zNewCmd);
          435  +  char *zMbcs = fossil_utf8_to_mbcs(zNewCmd);
          436  +  rc = system(zMbcs);
          437  +  fossil_mbcs_free(zMbcs);
   432    438     free(zNewCmd);
   433    439   #else
   434    440     /* On unix, evaluate the command directly.
   435    441     */
   436    442     rc = system(zOrigCmd);
   437    443   #endif 
   438    444     return rc; 
................................................................................
   505    511     fossil_warning("%s: %s", sqlite_error_code_name(iCode), zErrmsg);
   506    512   }
   507    513   
   508    514   /*
   509    515   ** Print a usage comment and quit
   510    516   */
   511    517   void usage(const char *zFormat){
   512         -  fprintf(stderr, "Usage: %s %s %s\n", fossil_nameofexe(), g.argv[1], zFormat);
   513         -  fossil_exit(1);
          518  +  fossil_fatal("Usage: %s %s %s\n", fossil_nameofexe(), g.argv[1], zFormat);
   514    519   }
   515    520   
   516    521   /*
   517    522   ** Remove n elements from g.argv beginning with the i-th element.
   518    523   */
   519    524   void remove_from_argv(int i, int n){
   520    525     int j;
................................................................................
   599    604     }
   600    605     nCol = 80/(mxLen+2);
   601    606     if( nCol==0 ) nCol = 1;
   602    607     nRow = (nWord + nCol - 1)/nCol;
   603    608     for(i=0; i<nRow; i++){
   604    609       const char *zSpacer = "";
   605    610       for(j=i; j<nWord; j+=nRow){
   606         -      printf("%s%-*s", zSpacer, mxLen, azWord[j]);
          611  +      fossil_print("%s%-*s", zSpacer, mxLen, azWord[j]);
   607    612         zSpacer = "  ";
   608    613       }
   609         -    printf("\n");
          614  +    fossil_print("\n");
   610    615     }
   611    616   }
   612    617   
   613    618   /*
   614    619   ** List of commands starting with zPrefix, or all commands if zPrefix is NULL.
   615    620   */
   616    621   static void cmd_cmd_list(const char *zPrefix){
................................................................................
   648    653   ** COMMAND: version
   649    654   **
   650    655   ** Usage: %fossil version
   651    656   **
   652    657   ** Print the source code version number for the fossil executable.
   653    658   */
   654    659   void version_cmd(void){
   655         -  printf("This is fossil version " MANIFEST_VERSION " " MANIFEST_DATE " UTC\n");
          660  +  fossil_print("This is fossil version "
          661  +                MANIFEST_VERSION " " MANIFEST_DATE " UTC\n");
   656    662   }
   657    663   
   658    664   
   659    665   /*
   660    666   ** COMMAND: help
   661    667   **
   662    668   ** Usage: %fossil help COMMAND
................................................................................
   663    669   **
   664    670   ** Display information on how to use COMMAND
   665    671   */
   666    672   void help_cmd(void){
   667    673     int rc, idx;
   668    674     const char *z;
   669    675     if( g.argc<3 ){
   670         -    printf("Usage: %s help COMMAND.\nAvailable COMMANDs:\n",
   671         -           fossil_nameofexe());
          676  +    fossil_print("Usage: %s help COMMAND.\nAvailable COMMANDs:\n",
          677  +                 fossil_nameofexe());
   672    678       cmd_cmd_list(0);
   673    679       version_cmd();
   674    680       return;
   675    681     }
   676    682     rc = name_search(g.argv[2], aCommand, count(aCommand), &idx);
   677    683     if( rc==1 ){
   678    684       fossil_print("unknown command: %s\nAvailable commands:\n", g.argv[2]);
................................................................................
   687    693     z = aCmdHelp[idx];
   688    694     if( z==0 ){
   689    695       fossil_fatal("no help available for the %s command",
   690    696          aCommand[idx].zName);
   691    697     }
   692    698     while( *z ){
   693    699       if( *z=='%' && strncmp(z, "%fossil", 7)==0 ){
   694         -      printf("%s", fossil_nameofexe());
          700  +      fossil_print("%s", fossil_nameofexe());
   695    701         z += 7;
   696    702       }else{
   697    703         putchar(*z);
   698    704         z++;
   699    705       }
   700    706     }
   701    707     putchar('\n');
................................................................................
  1279   1285     if( zHost ) cgi_replace_parameter("HTTP_HOST",zHost);
  1280   1286     g.cgiOutput = 1;
  1281   1287     if( g.argc!=2 && g.argc!=3 && g.argc!=6 ){
  1282   1288       fossil_fatal("no repository specified");
  1283   1289     }
  1284   1290     g.fullHttpReply = 1;
  1285   1291     if( g.argc==6 ){
  1286         -    g.httpIn = fopen(g.argv[3], "rb");
  1287         -    g.httpOut = fopen(g.argv[4], "wb");
         1292  +    g.httpIn = fossil_fopen(g.argv[3], "rb");
         1293  +    g.httpOut = fossil_fopen(g.argv[4], "wb");
  1288   1294       zIpAddr = g.argv[5];
  1289   1295     }else{
  1290   1296       g.httpIn = stdin;
  1291   1297       g.httpOut = stdout;
  1292   1298       zIpAddr = 0;
  1293   1299     }
  1294   1300     find_server_repository(0);
................................................................................
  1325   1331     char *zFull;
  1326   1332     int i;
  1327   1333     int bExists;
  1328   1334     while( zPath && zPath[0] ){
  1329   1335       while( zPath[0]==':' ) zPath++;
  1330   1336       for(i=0; zPath[i] && zPath[i]!=':'; i++){}
  1331   1337       zFull = mprintf("%.*s/%s", i, zPath, zBinary);
  1332         -    bExists = access(zFull, X_OK);
         1338  +    bExists = file_access(zFull, X_OK);
  1333   1339       free(zFull);
  1334   1340       if( bExists==0 ) return 1;
  1335   1341       zPath += i;
  1336   1342     }
  1337   1343     return 0;
  1338   1344   }
  1339   1345   #endif
................................................................................
  1453   1459   **
  1454   1460   ** Echo all command-line arguments (enclosed in [...]) to the screen so that
  1455   1461   ** wildcard expansion behavior of the host shell can be investigated.
  1456   1462   */
  1457   1463   void test_echo_cmd(void){
  1458   1464     int i;
  1459   1465     for(i=0; i<g.argc; i++){
  1460         -    printf("argv[%d] = [%s]\n", i, g.argv[i]);
         1466  +    fossil_print("argv[%d] = [%s]\n", i, g.argv[i]);
  1461   1467     }
  1462   1468   }

Changes to src/main.mk.

   890    890   	$(XTCC) -o $(OBJDIR)/zip.o -c $(OBJDIR)/zip_.c
   891    891   
   892    892   $(OBJDIR)/zip.h:	$(OBJDIR)/headers
   893    893   $(OBJDIR)/sqlite3.o:	$(SRCDIR)/sqlite3.c
   894    894   	$(XTCC) -DSQLITE_OMIT_LOAD_EXTENSION=1 -DSQLITE_THREADSAFE=0 -DSQLITE_DEFAULT_FILE_FORMAT=4 -DSQLITE_ENABLE_STAT2 -Dlocaltime=fossil_localtime -DSQLITE_ENABLE_LOCKING_STYLE=0 -c $(SRCDIR)/sqlite3.c -o $(OBJDIR)/sqlite3.o
   895    895   
   896    896   $(OBJDIR)/shell.o:	$(SRCDIR)/shell.c
   897         -	$(XTCC) -Dmain=sqlite3_shell -DSQLITE_OMIT_LOAD_EXTENSION=1 -c $(SRCDIR)/shell.c -o $(OBJDIR)/shell.o
          897  +	$(XTCC) -Dmain=sqlite3_shell -DSQLITE_OMIT_LOAD_EXTENSION=1 -Dfopen=fossil_fopen -c $(SRCDIR)/shell.c -o $(OBJDIR)/shell.o
   898    898   
   899    899   $(OBJDIR)/th.o:	$(SRCDIR)/th.c
   900    900   	$(XTCC) -I$(SRCDIR) -c $(SRCDIR)/th.c -o $(OBJDIR)/th.o
   901    901   
   902    902   $(OBJDIR)/th_lang.o:	$(SRCDIR)/th_lang.c
   903    903   	$(XTCC) -I$(SRCDIR) -c $(SRCDIR)/th_lang.c -o $(OBJDIR)/th_lang.o
   904    904   

Changes to src/makemake.tcl.

   248    248   append opt " -DSQLITE_ENABLE_LOCKING_STYLE=0"
   249    249   set SQLITE_OPTIONS $opt
   250    250   writeln "\t\$(XTCC) $opt -c \$(SRCDIR)/sqlite3.c -o \$(OBJDIR)/sqlite3.o\n"
   251    251   
   252    252   writeln "\$(OBJDIR)/shell.o:\t\$(SRCDIR)/shell.c"
   253    253   set opt {-Dmain=sqlite3_shell}
   254    254   append opt " -DSQLITE_OMIT_LOAD_EXTENSION=1"
          255  +append opt " -Dfopen=fossil_fopen"
   255    256   writeln "\t\$(XTCC) $opt -c \$(SRCDIR)/shell.c -o \$(OBJDIR)/shell.o\n"
   256    257   
   257    258   writeln "\$(OBJDIR)/th.o:\t\$(SRCDIR)/th.c"
   258    259   writeln "\t\$(XTCC) -I\$(SRCDIR) -c \$(SRCDIR)/th.c -o \$(OBJDIR)/th.o\n"
   259    260   
   260    261   writeln "\$(OBJDIR)/th_lang.o:\t\$(SRCDIR)/th_lang.c"
   261    262   writeln "\t\$(XTCC) -I\$(SRCDIR) -c \$(SRCDIR)/th_lang.c -o \$(OBJDIR)/th_lang.o\n"

Changes to src/md5.c.

   374    374   */
   375    375   int md5sum_file(const char *zFilename, Blob *pCksum){
   376    376     FILE *in;
   377    377     MD5Context ctx;
   378    378     unsigned char zResult[16];
   379    379     char zBuf[10240];
   380    380   
   381         -  in = fopen(zFilename,"rb");
          381  +  in = fossil_fopen(zFilename,"rb");
   382    382     if( in==0 ){
   383    383       return 1;
   384    384     }
   385    385     MD5Init(&ctx);
   386    386     for(;;){
   387    387       int n;
   388    388       n = fread(zBuf, 1, sizeof(zBuf), in);
................................................................................
   436    436     for(i=2; i<g.argc; i++){
   437    437       if( g.argv[i][0]=='-' && g.argv[i][1]==0 ){
   438    438         blob_read_from_channel(&in, stdin, -1);
   439    439         md5sum_blob(&in, &cksum);
   440    440       }else{
   441    441         md5sum_file(g.argv[i], &cksum);
   442    442       }
   443         -    printf("%s  %s\n", blob_str(&cksum), g.argv[i]);
          443  +    fossil_print("%s  %s\n", blob_str(&cksum), g.argv[i]);
   444    444       blob_reset(&cksum);
   445    445     }
   446    446   }

Changes to src/merge.c.

   247    247     );
   248    248   
   249    249     if( debugFlag ){
   250    250       db_prepare(&q,
   251    251          "SELECT rowid, fn, fnp, fnm, chnged, ridv, ridp, ridm, isexe FROM fv"
   252    252       );
   253    253       while( db_step(&q)==SQLITE_ROW ){
   254         -       printf("%3d: ridv=%-4d ridp=%-4d ridm=%-4d chnged=%d isexe=%d\n",
          254  +       fossil_print("%3d: ridv=%-4d ridp=%-4d ridm=%-4d chnged=%d isexe=%d\n",
   255    255             db_column_int(&q, 0),
   256    256             db_column_int(&q, 5),
   257    257             db_column_int(&q, 6),
   258    258             db_column_int(&q, 7),
   259    259             db_column_int(&q, 4),
   260    260             db_column_int(&q, 8));
   261         -       printf("     fn  = [%s]\n", db_column_text(&q, 1));
   262         -       printf("     fnp = [%s]\n", db_column_text(&q, 2));
   263         -       printf("     fnm = [%s]\n", db_column_text(&q, 3));
          261  +       fossil_print("     fn  = [%s]\n", db_column_text(&q, 1));
          262  +       fossil_print("     fnp = [%s]\n", db_column_text(&q, 2));
          263  +       fossil_print("     fnm = [%s]\n", db_column_text(&q, 3));
   264    264       }
   265    265       db_finalize(&q);
   266    266     }
   267    267   
   268    268     /*
   269    269     ** Find files in M and V but not in P and report conflicts.
   270    270     ** The file in M will be ignored.  It will be treated as if it
................................................................................
   272    272     */
   273    273     db_prepare(&q,
   274    274       "SELECT idm FROM fv WHERE idp=0 AND idv>0 AND idm>0"
   275    275     );
   276    276     while( db_step(&q)==SQLITE_ROW ){
   277    277       int idm = db_column_int(&q, 0);
   278    278       char *zName = db_text(0, "SELECT pathname FROM vfile WHERE id=%d", idm);
   279         -    printf("WARNING - no common ancestor: %s\n", zName);
          279  +    fossil_warning("WARNING - no common ancestor: %s\n", zName);
   280    280       free(zName);
   281    281       db_multi_exec("UPDATE fv SET idm=0 WHERE idm=%d", idm);
   282    282     }
   283    283     db_finalize(&q);
   284    284   
   285    285     /*
   286    286     ** Add to V files that are not in V or P but are in M
................................................................................
   298    298         "INSERT INTO vfile(vid,chnged,deleted,rid,mrid,isexe,pathname)"
   299    299         "  SELECT %d,3,0,rid,mrid,isexe,pathname FROM vfile WHERE id=%d",
   300    300         vid, idm
   301    301       );
   302    302       idv = db_last_insert_rowid();
   303    303       db_multi_exec("UPDATE fv SET idv=%d WHERE rowid=%d", idv, rowid);
   304    304       zName = db_column_text(&q, 2);
   305         -    printf("ADDED %s\n", zName);
          305  +    fossil_print("ADDED %s\n", zName);
   306    306       if( !nochangeFlag ){
   307    307         undo_save(zName);
   308    308         vfile_to_disk(0, idm, 0, 0);
   309    309       }
   310    310     }
   311    311     db_finalize(&q);
   312    312   
................................................................................
   320    320       "   AND ridm!=ridp AND ridv=ridp AND NOT chnged"
   321    321     );
   322    322     while( db_step(&q)==SQLITE_ROW ){
   323    323       int idv = db_column_int(&q, 0);
   324    324       int ridm = db_column_int(&q, 1);
   325    325       const char *zName = db_column_text(&q, 2);
   326    326       /* Copy content from idm over into idv.  Overwrite idv. */
   327         -    printf("UPDATE %s\n", zName);
          327  +    fossil_print("UPDATE %s\n", zName);
   328    328       if( !nochangeFlag ){
   329    329         undo_save(zName);
   330    330         db_multi_exec(
   331    331           "UPDATE vfile SET mtime=0, mrid=%d, chnged=2 WHERE id=%d", ridm, idv
   332    332         );
   333    333         vfile_to_disk(0, idv, 0, 0);
   334    334       }
................................................................................
   353    353       const char *zName = db_column_text(&q, 5);
   354    354       int isExe = db_column_int(&q, 6);
   355    355       int rc;
   356    356       char *zFullPath;
   357    357       Blob m, p, r;
   358    358       /* Do a 3-way merge of idp->idm into idp->idv.  The results go into idv. */
   359    359       if( detailFlag ){
   360         -      printf("MERGE %s  (pivot=%d v1=%d v2=%d)\n", zName, ridp, ridm, ridv);
          360  +      fossil_print("MERGE %s  (pivot=%d v1=%d v2=%d)\n", 
          361  +                   zName, ridp, ridm, ridv);
   361    362       }else{
   362         -      printf("MERGE %s\n", zName);
          363  +      fossil_print("MERGE %s\n", zName);
   363    364       }
   364    365       undo_save(zName);
   365    366       zFullPath = mprintf("%s/%s", g.zLocalRoot, zName);
   366    367       content_get(ridp, &p);
   367    368       content_get(ridm, &m);
   368    369       if( isBinary ){
   369    370         rc = -1;
................................................................................
   374    375       if( rc>=0 ){
   375    376         if( !nochangeFlag ){
   376    377           blob_write_to_file(&r, zFullPath);
   377    378           file_setexe(zFullPath, isExe);
   378    379         }
   379    380         db_multi_exec("UPDATE vfile SET mtime=0 WHERE id=%d", idv);
   380    381         if( rc>0 ){
   381         -        printf("***** %d merge conflicts in %s\n", rc, zName);
          382  +        fossil_print("***** %d merge conflicts in %s\n", rc, zName);
   382    383           nConflict++;
   383    384         }
   384    385       }else{
   385         -      printf("***** Cannot merge binary file %s\n", zName);
          386  +      fossil_print("***** Cannot merge binary file %s\n", zName);
   386    387         nConflict++;
   387    388       }
   388    389       blob_reset(&p);
   389    390       blob_reset(&m);
   390    391       blob_reset(&r);
   391    392       db_multi_exec("INSERT OR IGNORE INTO vmerge(id,merge) VALUES(%d,%d)",
   392    393                     idv,ridm);
................................................................................
   401    402       " WHERE idp>0 AND idv>0 AND idm=0"
   402    403     );
   403    404     while( db_step(&q)==SQLITE_ROW ){
   404    405       int idv = db_column_int(&q, 0);
   405    406       const char *zName = db_column_text(&q, 1);
   406    407       int chnged = db_column_int(&q, 2);
   407    408       /* Delete the file idv */
   408         -    printf("DELETE %s\n", zName);
          409  +    fossil_print("DELETE %s\n", zName);
   409    410       if( chnged ){
   410         -      printf("WARNING: local edits lost for %s\n", zName);
          411  +      fossil_warning("WARNING: local edits lost for %s\n", zName);
   411    412         nConflict++;
   412    413       }
   413    414       undo_save(zName);
   414    415       db_multi_exec(
   415    416         "UPDATE vfile SET deleted=1 WHERE id=%d", idv
   416    417       );
   417    418       if( !nochangeFlag ){
   418    419         char *zFullPath = mprintf("%s%s", g.zLocalRoot, zName);
   419         -      unlink(zFullPath);
          420  +      file_delete(zFullPath);
   420    421         free(zFullPath);
   421    422       }
   422    423     }
   423    424     db_finalize(&q);
   424    425   
   425    426     /*
   426    427     ** Rename files that have taken a rename on P->M but which keep the same
................................................................................
   431    432       "SELECT idv, fnp, fnm FROM fv"
   432    433       " WHERE idv>0 AND idp>0 AND idm>0 AND fnp=fn AND fnm!=fnp"
   433    434     );
   434    435     while( db_step(&q)==SQLITE_ROW ){
   435    436       int idv = db_column_int(&q, 0);
   436    437       const char *zOldName = db_column_text(&q, 1);
   437    438       const char *zNewName = db_column_text(&q, 2);
   438         -    printf("RENAME %s -> %s\n", zOldName, zNewName);
          439  +    fossil_print("RENAME %s -> %s\n", zOldName, zNewName);
   439    440       undo_save(zOldName);
   440    441       undo_save(zNewName);
   441    442       db_multi_exec(
   442    443         "UPDATE vfile SET pathname=%Q, origname=coalesce(origname,pathname)"
   443    444         " WHERE id=%d AND vid=%d", zNewName, idv, vid
   444    445       );
   445    446       if( !nochangeFlag ){
   446    447         char *zFullOldPath = mprintf("%s%s", g.zLocalRoot, zOldName);
   447    448         char *zFullNewPath = mprintf("%s%s", g.zLocalRoot, zNewName);
   448    449         file_copy(zFullOldPath, zFullNewPath);
   449         -      unlink(zFullOldPath);
          450  +      file_delete(zFullOldPath);
   450    451         free(zFullNewPath);
   451    452         free(zFullOldPath);
   452    453       }
   453    454     }
   454    455     db_finalize(&q);
   455    456   
   456    457   
   457    458     /* Report on conflicts
   458    459     */
   459    460     if( nConflict && !nochangeFlag ){
   460         -    printf("WARNING: merge conflicts - see messages above for details.\n");
          461  +    fossil_warning(
          462  +       "WARNING: merge conflicts - see messages above for details.\n");
   461    463     }
   462    464   
   463    465     /*
   464    466     ** Clean up the mid and pid VFILE entries.  Then commit the changes.
   465    467     */
   466    468     db_multi_exec("DELETE FROM vfile WHERE vid!=%d", vid);
   467    469     if( !pickFlag ){
   468    470       db_multi_exec("INSERT OR IGNORE INTO vmerge(id,merge) VALUES(0,%d)", mid);
   469    471     }
   470    472     undo_finish();
   471    473     db_end_transaction(nochangeFlag);
   472    474   }

Changes to src/merge3.c.

   312    312   */
   313    313   void delta_3waymerge_cmd(void){
   314    314     Blob pivot, v1, v2, merged;
   315    315     if( g.argc!=6 ){
   316    316       usage("PIVOT V1 V2 MERGED");
   317    317     }
   318    318     if( blob_read_from_file(&pivot, g.argv[2])<0 ){
   319         -    fprintf(stderr,"cannot read %s\n", g.argv[2]);
   320         -    fossil_exit(1);
          319  +    fossil_fatal("cannot read %s\n", g.argv[2]);
   321    320     }
   322    321     if( blob_read_from_file(&v1, g.argv[3])<0 ){
   323         -    fprintf(stderr,"cannot read %s\n", g.argv[3]);
   324         -    fossil_exit(1);
          322  +    fossil_fatal("cannot read %s\n", g.argv[3]);
   325    323     }
   326    324     if( blob_read_from_file(&v2, g.argv[4])<0 ){
   327         -    fprintf(stderr,"cannot read %s\n", g.argv[4]);
   328         -    fossil_exit(1);
          325  +    fossil_fatal("cannot read %s\n", g.argv[4]);
   329    326     }
   330    327     blob_merge(&pivot, &v1, &v2, &merged);
   331    328     if( blob_write_to_file(&merged, g.argv[5])<blob_size(&merged) ){
   332         -    fprintf(stderr,"cannot write %s\n", g.argv[4]);
   333         -    fossil_exit(1);
          329  +    fossil_fatal("cannot write %s\n", g.argv[4]);
   334    330     }
   335    331     blob_reset(&pivot);
   336    332     blob_reset(&v1);
   337    333     blob_reset(&v2);
   338    334     blob_reset(&merged);
   339    335   }
   340    336   
................................................................................
   426    422         azSubst[4] = "%merge";     azSubst[5] = zOther;
   427    423         azSubst[6] = "%output";    azSubst[7] = zOut;
   428    424         zCmd = string_subst(zGMerge, 8, azSubst);
   429    425         printf("%s\n", zCmd); fflush(stdout);
   430    426         fossil_system(zCmd);
   431    427         if( file_size(zOut)>=0 ){
   432    428           blob_read_from_file(pOut, zOut);
   433         -        unlink(zPivot);
   434         -        unlink(zOrig);
   435         -        unlink(zOther);
   436         -        unlink(zOut);
          429  +        file_delete(zPivot);
          430  +        file_delete(zOrig);
          431  +        file_delete(zOther);
          432  +        file_delete(zOut);
   437    433         }
   438    434         fossil_free(zCmd);
   439    435         fossil_free(zOut);
   440    436       }
   441    437       fossil_free(zPivot);
   442    438       fossil_free(zOrig);
   443    439       fossil_free(zOther);
   444    440     }
   445    441     blob_reset(&v1);
   446    442     return rc;
   447    443   }

Changes to src/name.c.

   265    265   */
   266    266   void test_name_to_id(void){
   267    267     int i;
   268    268     Blob name;
   269    269     db_must_be_within_tree();
   270    270     for(i=2; i<g.argc; i++){
   271    271       blob_init(&name, g.argv[i], -1);
   272         -    printf("%s -> ", g.argv[i]);
          272  +    fossil_print("%s -> ", g.argv[i]);
   273    273       if( name_to_uuid(&name, 1) ){
   274         -      printf("ERROR: %s\n", g.zErrMsg);
          274  +      fossil_print("ERROR: %s\n", g.zErrMsg);
   275    275         fossil_error_reset();
   276    276       }else{
   277         -      printf("%s\n", blob_buffer(&name));
          277  +      fossil_print("%s\n", blob_buffer(&name));
   278    278       }
   279    279       blob_reset(&name);
   280    280     }
   281    281   }
   282    282   
   283    283   /*
   284    284   ** Convert a name to a rid.  If the name is a small integer value then

Changes to src/path.c.

   211    211     for(n=1, p=path.pStart; p; p=p->u.pTo, n++){
   212    212       char *z;
   213    213       z = db_text(0,
   214    214         "SELECT substr(uuid,1,12) || ' ' || datetime(mtime)"
   215    215         "  FROM blob, event"
   216    216         " WHERE blob.rid=%d AND event.objid=%d AND event.type='ci'",
   217    217         p->rid, p->rid);
   218         -    printf("%4d: %s", n, z);
          218  +    fossil_print("%4d: %s", n, z);
   219    219       fossil_free(z);
   220    220       if( p->u.pTo ){
   221         -      printf(" is a %s of\n", p->u.pTo->fromIsParent ? "parent" : "child");
          221  +      fossil_print(" is a %s of\n", 
          222  +                   p->u.pTo->fromIsParent ? "parent" : "child");
   222    223       }else{
   223         -      printf("\n");
          224  +      fossil_print("\n");
   224    225       }
   225    226     }
   226    227   }
   227    228   
   228    229   /*
   229    230   ** Find the closest common ancestor of two nodes.  "Closest" means the
   230    231   ** fewest number of arcs.
................................................................................
   310    311     for(n=1, p=path.pStart; p; p=p->u.pTo, n++){
   311    312       char *z;
   312    313       z = db_text(0,
   313    314         "SELECT substr(uuid,1,12) || ' ' || datetime(mtime)"
   314    315         "  FROM blob, event"
   315    316         " WHERE blob.rid=%d AND event.objid=%d AND event.type='ci'",
   316    317         p->rid, p->rid);
   317         -    printf("%4d: %s", n, z);
          318  +    fossil_print("%4d: %s", n, z);
   318    319       fossil_free(z);
   319         -    if( p->rid==iFrom ) printf(" VERSION1");
   320         -    if( p->rid==iTo ) printf(" VERSION2");
   321         -    if( p->rid==iPivot ) printf(" PIVOT");
   322         -    printf("\n");
          320  +    if( p->rid==iFrom ) fossil_print(" VERSION1");
          321  +    if( p->rid==iTo ) fossil_print(" VERSION2");
          322  +    if( p->rid==iPivot ) fossil_print(" PIVOT");
          323  +    fossil_print("\n");
   323    324     }
   324    325   }
   325    326   
   326    327   
   327    328   /*
   328    329   ** A record of a file rename operation.
   329    330   */
................................................................................
   443    444     iTo = name_to_rid(g.argv[3]);
   444    445     find_filename_changes(iFrom, iTo, &nChng, &aChng);
   445    446     for(i=0; i<nChng; i++){
   446    447       char *zFrom, *zTo;
   447    448   
   448    449       zFrom = db_text(0, "SELECT name FROM filename WHERE fnid=%d", aChng[i*2]);
   449    450       zTo = db_text(0, "SELECT name FROM filename WHERE fnid=%d", aChng[i*2+1]);
   450         -    printf("[%s] -> [%s]\n", zFrom, zTo);
          451  +    fossil_print("[%s] -> [%s]\n", zFrom, zTo);
   451    452       fossil_free(zFrom);
   452    453       fossil_free(zTo);
   453    454     }
   454    455     fossil_free(aChng);
   455    456   }

Changes to src/printf.c.

   795    795     g.iErrPriority = iPriority;
   796    796   }
   797    797   void fossil_error_reset(void){
   798    798     free(g.zErrMsg);
   799    799     g.zErrMsg = 0;
   800    800     g.iErrPriority = 0;
   801    801   }
          802  +
          803  +/*
          804  +** Write to standard output or standard error.
          805  +**
          806  +** On windows, transform the output into the current terminal encoding
          807  +** if the output is going to the screen.  If output is redirected into
          808  +** a file, no translation occurs.  No translation ever occurs on unix.
          809  +*/
          810  +void fossil_puts(const char *z, int toStdErr){
          811  +#if defined(_WIN32)
          812  +  static int once = 1;
          813  +  static int istty[2];
          814  +  char *zToFree = 0;
          815  +  if( once ){
          816  +    istty[0] = _isatty(fileno(stdout));
          817  +    istty[1] = _isatty(fileno(stderr));
          818  +    once = 0;
          819  +  }
          820  +  assert( toStdErr==0 || toStdErr==1 );
          821  +  if( istty[toStdErr] ) z = zToFree = fossil_utf8_to_console(z);
          822  +  fwrite(z, 1, strlen(z), toStdErr ? stderr : stdout);
          823  +  free(zToFree);
          824  +#else
          825  +  fwrite(z, 1, strlen(z), toStdErr ? stderr : stdout);
          826  +#endif
          827  +}
   802    828   
   803    829   /*
   804    830   ** Write output for user consumption.  If g.cgiOutput is enabled, then
   805    831   ** send the output as part of the CGI reply.  If g.cgiOutput is false,
   806    832   ** then write on standard output.
   807    833   */
   808    834   void fossil_print(const char *zFormat, ...){
................................................................................
   809    835     va_list ap;
   810    836     va_start(ap, zFormat);
   811    837     if( g.cgiOutput ){
   812    838       cgi_vprintf(zFormat, ap);
   813    839     }else{
   814    840       Blob b = empty_blob;
   815    841       vxprintf(&b, zFormat, ap);
   816         -    fwrite(blob_buffer(&b), 1, blob_size(&b), stdout);
          842  +    fossil_puts(blob_str(&b), 0);
   817    843       blob_reset(&b);
   818    844     }
   819    845   }
   820    846   
   821    847   /*
   822    848   ** Case insensitive string comparison.
   823    849   */

Changes to src/rebuild.c.

   174    174   /*
   175    175   ** Draw the percent-complete message.
   176    176   ** The input is actually the permill complete.
   177    177   */
   178    178   static void percent_complete(int permill){
   179    179     static int lastOutput = -1;
   180    180     if( permill>lastOutput ){
   181         -    printf("  %d.%d%% complete...\r", permill/10, permill%10);
          181  +    fossil_print("  %d.%d%% complete...\r", permill/10, permill%10);
   182    182       fflush(stdout);
   183    183       lastOutput = permill;
   184    184     }
   185    185   }
   186    186   
   187    187   
   188    188   /*
................................................................................
   418    418     }
   419    419     if( doClustering ) create_cluster();
   420    420     if( !g.fQuiet && totalSize>0 ){
   421    421       processCnt += incrSize;
   422    422       percent_complete((processCnt*1000)/totalSize);
   423    423     }
   424    424     if(!g.fQuiet && ttyOutput ){
   425         -    printf("\n");
          425  +    fossil_print("\n");
   426    426     }
   427    427     return errCnt;
   428    428   }
   429    429   
   430    430   /*
   431    431   ** Attempt to convert more full-text blobs into delta-blobs for
   432    432   ** storage efficiency.
................................................................................
   547    547     errCnt = rebuild_db(randomizeFlag, 1, doClustering);
   548    548     db_multi_exec(
   549    549       "REPLACE INTO config(name,value,mtime) VALUES('content-schema','%s',now());"
   550    550       "REPLACE INTO config(name,value,mtime) VALUES('aux-schema','%s',now());",
   551    551       CONTENT_SCHEMA, AUX_SCHEMA
   552    552     );
   553    553     if( errCnt && !forceFlag ){
   554         -    printf("%d errors. Rolling back changes. Use --force to force a commit.\n",
   555         -            errCnt);
          554  +    fossil_print(
          555  +      "%d errors. Rolling back changes. Use --force to force a commit.\n",
          556  +      errCnt
          557  +    );
   556    558       db_end_transaction(1);
   557    559     }else{
   558    560       if( runCompress ){
   559         -      printf("Extra delta compression... "); fflush(stdout);
          561  +      fossil_print("Extra delta compression... "); fflush(stdout);
   560    562         extra_deltification();
   561    563         runVacuum = 1;
   562    564       }
   563    565       if( omitVerify ) verify_cancel();
   564    566       db_end_transaction(0);
   565         -    if( runCompress ) printf("done\n");
          567  +    if( runCompress ) fossil_print("done\n");
   566    568       db_close(0);
   567    569       db_open_repository(g.zRepositoryName);
   568    570       if( newPagesize ){
   569    571         db_multi_exec("PRAGMA page_size=%d", newPagesize);
   570    572         runVacuum = 1;
   571    573       }
   572    574       if( runVacuum ){
   573         -      printf("Vacuuming the database... "); fflush(stdout);
          575  +      fossil_print("Vacuuming the database... "); fflush(stdout);
   574    576         db_multi_exec("VACUUM");
   575         -      printf("done\n");
          577  +      fossil_print("done\n");
   576    578       }
   577    579       if( activateWal ){
   578    580         db_multi_exec("PRAGMA journal_mode=WAL;");
   579    581       }
   580    582     }
   581    583   }
   582    584   
................................................................................
   676    678         }
   677    679       }
   678    680       manifest_destroy(p);
   679    681     }
   680    682     n = db_int(0, "SELECT count(*) FROM /*scan*/"
   681    683                   "  (SELECT rid FROM blob EXCEPT SELECT x FROM xdone)");
   682    684     if( n==0 ){
   683         -    printf("all artifacts reachable through clusters\n");
          685  +    fossil_print("all artifacts reachable through clusters\n");
   684    686     }else{
   685         -    printf("%d unreachable artifacts:\n", n);
          687  +    fossil_print("%d unreachable artifacts:\n", n);
   686    688       db_prepare(&q, "SELECT rid, uuid FROM blob WHERE rid NOT IN xdone");
   687    689       while( db_step(&q)==SQLITE_ROW ){
   688         -      printf("  %3d %s\n", db_column_int(&q,0), db_column_text(&q,1));
          690  +      fossil_print("  %3d %s\n", db_column_int(&q,0), db_column_text(&q,1));
   689    691       }
   690    692       db_finalize(&q);
   691    693     }
   692    694   }
   693    695   
   694    696   /*
   695    697   ** COMMAND: scrub
................................................................................
   795    797           fossil_panic("some unknown error occurred while reading \"%s\"", 
   796    798                        blob_str(&path));
   797    799         }
   798    800         content_put(&aContent);
   799    801         blob_reset(&path);
   800    802         blob_reset(&aContent);
   801    803         free(zSubpath);
   802         -      printf("\r%d", ++nFileRead);
          804  +      fossil_print("\r%d", ++nFileRead);
   803    805         fflush(stdout);
   804    806       }
   805    807       closedir(d);
   806    808     }else {
   807    809       fossil_panic("encountered error %d while trying to open \"%s\".",
   808    810                     errno, g.argv[3]);
   809    811     }
................................................................................
   822    824   */
   823    825   void reconstruct_cmd(void) {
   824    826     char *zPassword;
   825    827     if( g.argc!=4 ){
   826    828       usage("FILENAME DIRECTORY");
   827    829     }
   828    830     if( file_isdir(g.argv[3])!=1 ){
   829         -    printf("\"%s\" is not a directory\n\n", g.argv[3]);
          831  +    fossil_print("\"%s\" is not a directory\n\n", g.argv[3]);
   830    832       usage("FILENAME DIRECTORY");
   831    833     }
   832    834     db_create_repository(g.argv[2]);
   833    835     db_open_repository(g.argv[2]);
   834    836     db_open_config(0);
   835    837     db_begin_transaction();
   836    838     db_initial_setup(0, 0, 1);
   837    839   
   838         -  printf("Reading files from directory \"%s\"...\n", g.argv[3]);
          840  +  fossil_print("Reading files from directory \"%s\"...\n", g.argv[3]);
   839    841     recon_read_dir(g.argv[3]);
   840         -  printf("\nBuilding the Fossil repository...\n");
          842  +  fossil_print("\nBuilding the Fossil repository...\n");
   841    843   
   842    844     rebuild_db(0, 1, 1);
   843    845   
   844    846     /* Reconstruct the private table.  The private table contains the rid
   845    847     ** of every manifest that is tagged with "private" and every file that
   846    848     ** is not used by a manifest that is not private.
   847    849     */
................................................................................
   859    861     /* Skip the verify_before_commit() step on a reconstruct.  Most artifacts
   860    862     ** will have been changed and verification therefore takes a really, really
   861    863     ** long time.
   862    864     */
   863    865     verify_cancel();
   864    866     
   865    867     db_end_transaction(0);
   866         -  printf("project-id: %s\n", db_get("project-code", 0));
   867         -  printf("server-id: %s\n", db_get("server-code", 0));
          868  +  fossil_print("project-id: %s\n", db_get("project-code", 0));
          869  +  fossil_print("server-id: %s\n", db_get("server-code", 0));
   868    870     zPassword = db_text(0, "SELECT pw FROM user WHERE login=%Q", g.zLogin);
   869         -  printf("admin-user: %s (initial password is \"%s\")\n", g.zLogin, zPassword);
          871  +  fossil_print("admin-user: %s (initial password is \"%s\")\n", g.zLogin, zPassword);
   870    872   }
   871    873   
   872    874   /*
   873    875   ** COMMAND: deconstruct
   874    876   **
   875    877   ** Usage %fossil deconstruct ?OPTIONS? DESTIONATION
   876    878   **
................................................................................
   907    909       if( zPrefixOpt[0]>='0' && zPrefixOpt[0]<='9' && !zPrefixOpt[1] ){
   908    910         prefixLength = (int)(*zPrefixOpt-'0');
   909    911       }else{
   910    912         fossil_fatal("N(%s) is not a a valid prefix length!",zPrefixOpt);
   911    913       }
   912    914     }
   913    915   #ifndef _WIN32
   914         -  if( access(zDestDir, W_OK) ){
          916  +  if( file_access(zDestDir, W_OK) ){
   915    917       fossil_fatal("DESTINATION(%s) is not writeable!",zDestDir);
   916    918     }
   917    919   #else
   918    920     /* write access on windows is not checked, errors will be
   919    921     ** dected on blob_write_to_file
   920    922     */
   921    923   #endif
................................................................................
   926    928     }
   927    929     /* open repository and open query for all artifacts */
   928    930     db_find_and_open_repository(OPEN_ANY_SCHEMA, 0);
   929    931     bag_init(&bagDone);
   930    932     ttyOutput = 1;
   931    933     processCnt = 0;
   932    934     if (!g.fQuiet) {
   933         -    printf("0 (0%%)...\r");
          935  +    fossil_print("0 (0%%)...\r");
   934    936       fflush(stdout);
   935    937     }
   936    938     totalSize = db_int(0, "SELECT count(*) FROM blob");
   937    939     db_prepare(&s,
   938    940        "SELECT rid, size FROM blob /*scan*/"
   939    941        " WHERE NOT EXISTS(SELECT 1 FROM shun WHERE uuid=blob.uuid)"
   940    942        "   AND NOT EXISTS(SELECT 1 FROM delta WHERE rid=blob.rid)"
................................................................................
   962    964           content_get(rid, &content);
   963    965           rebuild_step(rid, size, &content);
   964    966         }
   965    967       }
   966    968     }
   967    969     db_finalize(&s);
   968    970     if(!g.fQuiet && ttyOutput ){
   969         -    printf("\n");
          971  +    fossil_print("\n");
   970    972     }
   971    973   
   972    974     /* free filename format string */
   973    975     free(zFNameFormat);
   974    976     zFNameFormat = 0;
   975    977   }

Changes to src/report.c.

   998    998   ** show all reports, which can be used for ticket show.
   999    999   ** Output is written to stdout as tab delimited table
  1000   1000   */
  1001   1001   void rpt_list_reports(void){
  1002   1002     Stmt q;
  1003   1003     char const aRptOutFrmt[] = "%s\t%s\n";
  1004   1004   
  1005         -  printf("Available reports:\n");
  1006         -  printf(aRptOutFrmt,"report number","report title");
  1007         -  printf(aRptOutFrmt,zFullTicketRptRn,zFullTicketRptTitle);
         1005  +  fossil_print("Available reports:\n");
         1006  +  fossil_print(aRptOutFrmt,"report number","report title");
         1007  +  fossil_print(aRptOutFrmt,zFullTicketRptRn,zFullTicketRptTitle);
  1008   1008     db_prepare(&q,"SELECT rn,title FROM reportfmt ORDER BY rn");
  1009   1009     while( db_step(&q)==SQLITE_ROW ){
  1010   1010       const char *zRn = db_column_text(&q, 0);
  1011   1011       const char *zTitle = db_column_text(&q, 1);
  1012   1012   
  1013         -    printf(aRptOutFrmt,zRn,zTitle);
         1013  +    fossil_print(aRptOutFrmt,zRn,zTitle);
  1014   1014     }
  1015   1015     db_finalize(&q);
  1016   1016   }
  1017   1017   
  1018   1018   /*
  1019   1019   ** user defined separator used by ticket show command
  1020   1020   */
................................................................................
  1035   1035   static void output_no_tabs_file(const char *z){
  1036   1036     switch( tktEncode ){
  1037   1037       case tktFossilize:
  1038   1038         { char *zFosZ;
  1039   1039   
  1040   1040           if( z && *z ){
  1041   1041             zFosZ = fossilize(z,-1);
  1042         -          printf("%s",zFosZ);
         1042  +          fossil_print("%s",zFosZ);
  1043   1043             free(zFosZ);
  1044   1044           }
  1045   1045           break;
  1046   1046         }
  1047   1047       default:
  1048   1048         while( z && z[0] ){
  1049   1049           int i, j;
  1050   1050           for(i=0; z[i] && (!fossil_isspace(z[i]) || z[i]==' '); i++){}
  1051   1051           if( i>0 ){
  1052         -          printf("%.*s", i, z);
         1052  +          fossil_print("%.*s", i, z);
  1053   1053           }
  1054   1054           for(j=i; fossil_isspace(z[j]); j++){}
  1055   1055           if( j>i ){
  1056         -          printf("%*s", j-i, "");
         1056  +          fossil_print("%*s", j-i, "");
  1057   1057           }
  1058   1058           z += j;
  1059   1059         }
  1060   1060         break; 
  1061   1061     }
  1062   1062   }
  1063   1063   
................................................................................
  1072   1072   ){
  1073   1073     int *pCount = (int*)pUser;
  1074   1074     int i;
  1075   1075   
  1076   1076     if( *pCount==0 ){
  1077   1077       for(i=0; i<nArg; i++){
  1078   1078         output_no_tabs_file(azName[i]);
  1079         -      printf("%s", i<nArg-1 ? (zSep?zSep:"\t") : "\n");
         1079  +      fossil_print("%s", i<nArg-1 ? (zSep?zSep:"\t") : "\n");
  1080   1080       }
  1081   1081     }
  1082   1082     ++*pCount;
  1083   1083     for(i=0; i<nArg; i++){
  1084   1084       output_no_tabs_file(azArg[i]);
  1085         -    printf("%s", i<nArg-1 ? (zSep?zSep:"\t") : "\n");
         1085  +    fossil_print("%s", i<nArg-1 ? (zSep?zSep:"\t") : "\n");
  1086   1086     }
  1087   1087     return 0;
  1088   1088   }
  1089   1089   
  1090   1090   /*
  1091   1091   ** Generate a report.  The rn query parameter is the report number.
  1092   1092   ** The output is written to stdout as flat file. The zFilter paramater

Changes to src/sha1.c.

   264    264   */
   265    265   int sha1sum_file(const char *zFilename, Blob *pCksum){
   266    266     FILE *in;
   267    267     SHA1Context ctx;
   268    268     unsigned char zResult[20];
   269    269     char zBuf[10240];
   270    270   
   271         -  in = fopen(zFilename,"rb");
          271  +  in = fossil_fopen(zFilename,"rb");
   272    272     if( in==0 ){
   273    273       return 1;
   274    274     }
   275    275     SHA1Init(&ctx);
   276    276     for(;;){
   277    277       int n;
   278    278       n = fread(zBuf, 1, sizeof(zBuf), in);
................................................................................
   428    428       blob_init(&cksum, "************** not found ***************", -1);
   429    429       if( g.argv[i][0]=='-' && g.argv[i][1]==0 ){
   430    430         blob_read_from_channel(&in, stdin, -1);
   431    431         sha1sum_blob(&in, &cksum);
   432    432       }else{
   433    433         sha1sum_file(g.argv[i], &cksum);
   434    434       }
   435         -    printf("%s  %s\n", blob_str(&cksum), g.argv[i]);
          435  +    fossil_print("%s  %s\n", blob_str(&cksum), g.argv[i]);
   436    436       blob_reset(&cksum);
   437    437     }
   438    438   }

Changes to src/stash.c.

   183    183       Blob delta;
   184    184       undo_save(zNew);
   185    185       blob_zero(&delta);
   186    186       if( rid==0 ){
   187    187         db_ephemeral_blob(&q, 5, &delta);
   188    188         blob_write_to_file(&delta, zNPath);
   189    189         file_setexe(zNPath, isExec);
   190         -      printf("ADD %s\n", zNew);
          190  +      fossil_print("ADD %s\n", zNew);
   191    191       }else if( isRemoved ){
   192         -      printf("DELETE %s\n", zOrig);
   193         -      unlink(zOPath);
          192  +      fossil_print("DELETE %s\n", zOrig);
          193  +      file_delete(zOPath);
   194    194       }else{
   195    195         Blob a, b, out, disk;
   196    196         db_ephemeral_blob(&q, 5, &delta);
   197    197         blob_read_from_file(&disk, zOPath);     
   198    198         content_get(rid, &a);
   199    199         blob_delta_apply(&a, &delta, &b);
   200    200         if( blob_compare(&disk, &a)==0 ){
   201    201           blob_write_to_file(&b, zNPath);
   202    202           file_setexe(zNPath, isExec);
   203         -        printf("UPDATE %s\n", zNew);
          203  +        fossil_print("UPDATE %s\n", zNew);
   204    204         }else{
   205    205           int rc = merge_3way(&a, zOPath, &b, &out);
   206    206           blob_write_to_file(&out, zNPath);
   207    207           file_setexe(zNPath, isExec);
   208    208           if( rc ){
   209         -          printf("CONFLICT %s\n", zNew);
          209  +          fossil_print("CONFLICT %s\n", zNew);
   210    210             nConflict++;
   211    211           }else{
   212         -          printf("MERGE %s\n", zNew);
          212  +          fossil_print("MERGE %s\n", zNew);
   213    213           }
   214    214           blob_reset(&out);
   215    215         }
   216    216         blob_reset(&a);
   217    217         blob_reset(&b);
   218    218         blob_reset(&disk);
   219    219       }
   220    220       blob_reset(&delta);
   221    221       if( fossil_strcmp(zOrig,zNew)!=0 ){
   222    222         undo_save(zOrig);
   223         -      unlink(zOPath);
          223  +      file_delete(zOPath);
   224    224       }
   225    225     }
   226    226     db_finalize(&q);
   227    227     if( nConflict ){
   228         -    printf("WARNING: merge conflicts - see messages above for details.\n");
          228  +    fossil_print("WARNING: merge conflicts - see messages above for details.\n");
   229    229     }
   230    230   }
   231    231   
   232    232   /*
   233    233   ** Show the diffs associate with a single stash.
   234    234   */
   235    235   static void stash_diff(int stashid, const char *zDiffCmd){
................................................................................
   246    246       int isRemoved = db_column_int(&q, 1);
   247    247       const char *zOrig = db_column_text(&q, 3);
   248    248       const char *zNew = db_column_text(&q, 4);
   249    249       char *zOPath = mprintf("%s%s", g.zLocalRoot, zOrig);
   250    250       Blob delta;
   251    251       if( rid==0 ){
   252    252         db_ephemeral_blob(&q, 5, &delta);
   253         -      printf("ADDED %s\n", zNew);
          253  +      fossil_print("ADDED %s\n", zNew);
   254    254         diff_print_index(zNew);
   255    255         diff_file_mem(&empty, &delta, zNew, zDiffCmd, 0);
   256    256       }else if( isRemoved ){
   257         -      printf("DELETE %s\n", zOrig);
          257  +      fossil_print("DELETE %s\n", zOrig);
   258    258         blob_read_from_file(&delta, zOPath);
   259    259         diff_print_index(zNew);
   260    260         diff_file_mem(&delta, &empty, zOrig, zDiffCmd, 0);
   261    261       }else{
   262    262         Blob a, b, disk;
   263    263         db_ephemeral_blob(&q, 5, &delta);
   264    264         blob_read_from_file(&disk, zOPath);     
   265    265         content_get(rid, &a);
   266    266         blob_delta_apply(&a, &delta, &b);
   267         -      printf("CHANGED %s\n", zNew);
          267  +      fossil_print("CHANGED %s\n", zNew);
   268    268         diff_file_mem(&disk, &b, zNew, zDiffCmd, 0);
   269    269         blob_reset(&a);
   270    270         blob_reset(&b);
   271    271         blob_reset(&disk);
   272    272       }
   273    273       blob_reset(&delta);
   274    274    }
................................................................................
   411    411          "SELECT stashid, (SELECT uuid FROM blob WHERE rid=vid),"
   412    412          "       comment, datetime(ctime) FROM stash"
   413    413          " ORDER BY ctime DESC"
   414    414       );
   415    415       while( db_step(&q)==SQLITE_ROW ){
   416    416         const char *zCom;
   417    417         n++;
   418         -      printf("%5d: [%.14s] on %s\n",
          418  +      fossil_print("%5d: [%.14s] on %s\n",
   419    419           db_column_int(&q, 0),
   420    420           db_column_text(&q, 1),
   421    421           db_column_text(&q, 3)
   422    422         );
   423    423         zCom = db_column_text(&q, 2);
   424    424         if( zCom && zCom[0] ){
   425         -        printf("       ");
          425  +        fossil_print("       ");
   426    426           comment_print(zCom, 7, 79);
   427    427         }
   428    428       }
   429    429       db_finalize(&q);
   430         -    if( n==0 ) printf("empty stash\n");
          430  +    if( n==0 ) fossil_print("empty stash\n");
   431    431     }else
   432    432     if( memcmp(zCmd, "drop", nCmd)==0 ){
   433    433       int allFlag = find_option("all", 0, 0)!=0;
   434    434       if( g.argc>4 ) usage("stash apply STASHID");
   435    435       if( allFlag ){
   436    436         db_multi_exec("DELETE FROM stash; DELETE FROM stashfile;");
   437    437       }else{

Changes to src/sync.c.

    74     74       ** TODO:  What happens if the shun list gets really big? 
    75     75       ** Maybe the shunning list should only be pulled on every 10th
    76     76       ** autosync, or something?
    77     77       */
    78     78       configSync = CONFIGSET_SHUN;
    79     79     }
    80     80   #endif
    81         -  printf("Autosync:  %s\n", g.urlCanonical);
           81  +  fossil_print("Autosync:  %s\n", g.urlCanonical);
    82     82     url_enable_proxy("via proxy: ");
    83     83     rc = client_sync((flags & AUTOSYNC_PUSH)!=0, 1, 0, 0, configSync, 0);
    84     84     if( rc ) fossil_warning("Autosync failed");
    85     85     return rc;
    86     86   }
    87     87   
    88     88   /*
................................................................................
   122    122     }
   123    123     if( !g.dontKeepUrl ){
   124    124       db_set("last-sync-url", g.urlCanonical, 0);
   125    125       if( g.urlPasswd ) db_set("last-sync-pw", obscure(g.urlPasswd), 0);
   126    126     }
   127    127     user_select();
   128    128     if( g.argc==2 ){
   129         -    printf("Server:    %s\n", g.urlCanonical);
          129  +    fossil_print("Server:    %s\n", g.urlCanonical);
   130    130     }
   131    131     url_enable_proxy("via proxy: ");
   132    132     *pConfigSync = configSync;
   133    133   }
   134    134   
   135    135   /*
   136    136   ** COMMAND: pull
................................................................................
   261    261         }else{
   262    262           db_unset("last-sync-pw", 0);
   263    263         }
   264    264       }
   265    265     }
   266    266     zUrl = db_get("last-sync-url", 0);
   267    267     if( zUrl==0 ){
   268         -    printf("off\n");
          268  +    fossil_print("off\n");
   269    269       return;
   270    270     }else{
   271    271       url_parse(zUrl);
   272         -    printf("%s\n", g.urlCanonical);
          272  +    fossil_print("%s\n", g.urlCanonical);
   273    273     }
   274    274   }

Changes to src/tag.c.

   436    436           "SELECT blob.uuid FROM tagxref, blob"
   437    437           " WHERE tagid=(SELECT tagid FROM tag WHERE tagname=%Q)"
   438    438           "   AND tagxref.tagtype>0"
   439    439           "   AND blob.rid=tagxref.rid",
   440    440           g.argv[3]
   441    441         );
   442    442         while( db_step(&q)==SQLITE_ROW ){
   443         -        printf("%s\n", db_column_text(&q, 0));
          443  +        fossil_print("%s\n", db_column_text(&q, 0));
   444    444         }
   445    445         db_finalize(&q);
   446    446       }else{
   447    447         int tagid = db_int(0, "SELECT tagid FROM tag WHERE tagname='sym-%q'",
   448    448                            g.argv[3]);
   449    449         if( tagid>0 ){
   450    450           db_prepare(&q,
................................................................................
   471    471           "               WHERE tagid=tag.tagid"
   472    472           "                 AND tagtype>0)"
   473    473           " ORDER BY tagname"
   474    474         );
   475    475         while( db_step(&q)==SQLITE_ROW ){
   476    476           const char *zName = db_column_text(&q, 0);
   477    477           if( fRaw ){
   478         -          printf("%s\n", zName);
          478  +          fossil_print("%s\n", zName);
   479    479           }else if( strncmp(zName, "sym-", 4)==0 ){
   480         -          printf("%s\n", &zName[4]);
          480  +          fossil_print("%s\n", &zName[4]);
   481    481           }
   482    482         }
   483    483         db_finalize(&q);
   484    484       }else if( g.argc==4 ){
   485    485         int rid = name_to_rid(g.argv[3]);
   486    486         db_prepare(&q,
   487    487           "SELECT tagname, value FROM tagxref, tag"
................................................................................
   495    495           const char *zName = db_column_text(&q, 0);
   496    496           const char *zValue = db_column_text(&q, 1);
   497    497           if( fRaw==0 ){
   498    498             if( strncmp(zName, "sym-", 4)!=0 ) continue;
   499    499             zName += 4;
   500    500           }
   501    501           if( zValue && zValue[0] ){
   502         -          printf("%s=%s\n", zName, zValue);
          502  +          fossil_print("%s=%s\n", zName, zValue);
   503    503           }else{
   504         -          printf("%s\n", zName);
          504  +          fossil_print("%s\n", zName);
   505    505           }
   506    506         }
   507    507         db_finalize(&q);
   508    508       }else{
   509    509         usage("tag list ?CHECK-IN?");
   510    510       }
   511    511     }else

Changes to src/timeline.c.

  1201   1201       char *zFree = 0;
  1202   1202       int n = 0;
  1203   1203       char zPrefix[80];
  1204   1204       char zUuid[UUID_SIZE+1];
  1205   1205       
  1206   1206       sqlite3_snprintf(sizeof(zUuid), zUuid, "%.10s", zId);
  1207   1207       if( memcmp(zDate, zPrevDate, 10) ){
  1208         -      printf("=== %.10s ===\n", zDate);
         1208  +      fossil_print("=== %.10s ===\n", zDate);
  1209   1209         memcpy(zPrevDate, zDate, 10);
  1210   1210         nLine++;
  1211   1211       }
  1212   1212       if( zCom==0 ) zCom = "";
  1213         -    printf("%.8s ", &zDate[11]);
         1213  +    fossil_print("%.8s ", &zDate[11]);
  1214   1214       zPrefix[0] = 0;
  1215   1215       if( nParent>1 ){
  1216   1216         sqlite3_snprintf(sizeof(zPrefix), zPrefix, "*MERGE* ");
  1217   1217         n = strlen(zPrefix);
  1218   1218       }
  1219   1219       if( nChild>1 ){
  1220   1220         const char *zBrType;
................................................................................
  1451   1451        "       (SELECT uuid FROM blob WHERE rid=c.cid),"
  1452   1452        "       datetime(p.mtime), datetime(c.mtime)"
  1453   1453        "  FROM plink p, plink c"
  1454   1454        " WHERE p.cid=c.pid  AND p.mtime>c.mtime"
  1455   1455     );
  1456   1456     while( db_step(&q)==SQLITE_ROW ){
  1457   1457       if( !showDetail ){
  1458         -      printf("%s\n", db_column_text(&q, 1));
         1458  +      fossil_print("%s\n", db_column_text(&q, 1));
  1459   1459       }else{
  1460         -      printf("%.14s -> %.14s   %s -> %s\n",
         1460  +      fossil_print("%.14s -> %.14s   %s -> %s\n",
  1461   1461            db_column_text(&q, 0),
  1462   1462            db_column_text(&q, 1),
  1463   1463            db_column_text(&q, 2),
  1464   1464            db_column_text(&q, 3));
  1465   1465       }
  1466   1466     }
  1467   1467     db_finalize(&q);

Changes to src/tkt.c.

   214    214   */
   215    215   void ticket_rebuild_entry(const char *zTktUuid){
   216    216     char *zTag = mprintf("tkt-%s", zTktUuid);
   217    217     int tagid = tag_findid(zTag, 1);
   218    218     Stmt q;
   219    219     Manifest *pTicket;
   220    220     int createFlag = 1;
   221         -  
          221  +
          222  +  fossil_free(zTag);  
   222    223     db_multi_exec(
   223    224        "DELETE FROM ticket WHERE tkt_uuid=%Q", zTktUuid
   224    225     );
   225    226     db_prepare(&q, "SELECT rid FROM tagxref WHERE tagid=%d ORDER BY mtime",tagid);
   226    227     while( db_step(&q)==SQLITE_ROW ){
   227    228       int rid = db_column_int(&q, 0);
   228    229       pTicket = manifest_get(rid, CFTYPE_TICKET);

Changes to src/undo.c.

    56     56       old_exists = db_column_int(&q, 1);
    57     57       old_exe = db_column_int(&q, 2);
    58     58       if( old_exists ){
    59     59         db_ephemeral_blob(&q, 0, &new);
    60     60       }
    61     61       if( old_exists ){
    62     62         if( new_exists ){
    63         -        printf("%s %s\n", redoFlag ? "REDO" : "UNDO", zPathname);
           63  +        fossil_print("%s %s\n", redoFlag ? "REDO" : "UNDO", zPathname);
    64     64         }else{
    65         -        printf("NEW %s\n", zPathname);
           65  +        fossil_print("NEW %s\n", zPathname);
    66     66         }
    67     67         blob_write_to_file(&new, zFullname);
    68     68         file_setexe(zFullname, old_exe);
    69     69       }else{
    70         -      printf("DELETE %s\n", zPathname);
    71         -      unlink(zFullname);
           70  +      fossil_print("DELETE %s\n", zPathname);
           71  +      file_delete(zFullname);
    72     72       }
    73     73       blob_reset(&new);
    74     74       free(zFullname);
    75     75       db_finalize(&q);
    76     76       db_prepare(&q, 
    77     77          "UPDATE undo SET content=:c, existsflag=%d, isExe=%d,"
    78     78                " redoflag=NOT redoflag"
................................................................................
   295    295   
   296    296   /*
   297    297   ** Complete the undo process is one is currently in process.
   298    298   */
   299    299   void undo_finish(void){
   300    300     if( undoActive ){
   301    301       if( undoNeedRollback ){
   302         -      printf("\"fossil undo\" is available to undo changes"
          302  +      fossil_print("\"fossil undo\" is available to undo changes"
   303    303                " to the working checkout.\n");
   304    304       }
   305    305       undoActive = 0;
   306    306       undoNeedRollback = 0;
   307    307     }
   308    308   }
   309    309   
................................................................................
   317    317   ** was locked or had permissions turned off.
   318    318   */
   319    319   void undo_rollback(void){
   320    320     if( !undoNeedRollback ) return;
   321    321     assert( undoActive );
   322    322     undoNeedRollback = 0;
   323    323     undoActive = 0;
   324         -  printf("Rolling back prior filesystem changes...\n");
          324  +  fossil_print("Rolling back prior filesystem changes...\n");
   325    325     undo_all_filesystem(0);
   326    326   }
   327    327   
   328    328   /*
   329    329   ** COMMAND: undo
   330    330   ** COMMAND: redo
   331    331   **
................................................................................
   358    358     const char *zCmd = isRedo ? "redo" : "undo";
   359    359     db_must_be_within_tree();
   360    360     verify_all_options();
   361    361     db_begin_transaction();
   362    362     undo_available = db_lget_int("undo_available", 0);
   363    363     if( explainFlag ){
   364    364       if( undo_available==0 ){
   365         -      printf("No undo or redo is available\n");
          365  +      fossil_print("No undo or redo is available\n");
   366    366       }else{
   367    367         Stmt q;
   368    368         int nChng = 0;
   369    369         zCmd = undo_available==1 ? "undo" : "redo";
   370         -      printf("A %s is available for the following command:\n\n   %s %s\n\n",
   371         -              zCmd, g.argv[0], db_lget("undo_cmdline", "???"));
          370  +      fossil_print("A %s is available for the following command:\n\n"
          371  +                   "   %s %s\n\n",
          372  +                   zCmd, g.argv[0], db_lget("undo_cmdline", "???"));
   372    373         db_prepare(&q,
   373    374           "SELECT existsflag, pathname FROM undo ORDER BY pathname"
   374    375         );
   375    376         while( db_step(&q)==SQLITE_ROW ){
   376    377           if( nChng==0 ){
   377         -          printf("The following file changes would occur if the "
   378         -                 "command above is %sne:\n\n", zCmd);
          378  +          fossil_print("The following file changes would occur if the "
          379  +                       "command above is %sne:\n\n", zCmd);
   379    380           }
   380    381           nChng++;
   381         -        printf("%s %s\n", 
          382  +        fossil_print("%s %s\n", 
   382    383              db_column_int(&q,0) ? "UPDATE" : "DELETE",
   383    384              db_column_text(&q, 1)
   384    385           );
   385    386         }
   386    387         db_finalize(&q);
   387    388         if( nChng==0 ){
   388         -        printf("No file changes would occur with this undo/redo.\n");
          389  +        fossil_print("No file changes would occur with this undo/redo.\n");
   389    390         }
   390    391       }
   391    392     }else{
   392    393       int vid1 = db_lget_int("checkout", 0);
   393    394       int vid2;
   394    395       if( g.argc==2 ){
   395    396         if( undo_available!=(1+isRedo) ){
................................................................................
   408    409           file_tree_name(zFile, &path, 1);
   409    410           undo_one(blob_str(&path), isRedo);
   410    411           blob_reset(&path);
   411    412         }
   412    413       }
   413    414       vid2 = db_lget_int("checkout", 0);
   414    415       if( vid1!=vid2 ){
   415         -      printf("--------------------\n");
          416  +      fossil_print("--------------------\n");
   416    417         show_common_info(vid2, "updated-to:", 1, 0);
   417    418       }
   418    419     }
   419    420     db_end_transaction(0);
   420    421   }

Changes to src/update.c.

   251    251     );
   252    252   
   253    253     if( debugFlag ){
   254    254       db_prepare(&q,
   255    255          "SELECT rowid, fn, fnt, chnged, ridv, ridt, isexe FROM fv"
   256    256       );
   257    257       while( db_step(&q)==SQLITE_ROW ){
   258         -       printf("%3d: ridv=%-4d ridt=%-4d chnged=%d isexe=%d\n",
          258  +       fossil_print("%3d: ridv=%-4d ridt=%-4d chnged=%d isexe=%d\n",
   259    259             db_column_int(&q, 0),
   260    260             db_column_int(&q, 4),
   261    261             db_column_int(&q, 5),
   262    262             db_column_int(&q, 3),
   263    263             db_column_int(&q, 6));
   264         -       printf("     fnv = [%s]\n", db_column_text(&q, 1));
   265         -       printf("     fnt = [%s]\n", db_column_text(&q, 2));
          264  +       fossil_print("     fnv = [%s]\n", db_column_text(&q, 1));
          265  +       fossil_print("     fnt = [%s]\n", db_column_text(&q, 2));
   266    266       }
   267    267       db_finalize(&q);
   268    268     }
   269    269   
   270    270     /* If FILES appear on the command-line, remove from the "fv" table
   271    271     ** every entry that is not named on the command-line or which is not
   272    272     ** in a directory named on the command-line.
................................................................................
   329    329       zFullPath = mprintf("%s%s", g.zLocalRoot, zName);
   330    330       zFullNewPath = mprintf("%s%s", g.zLocalRoot, zNewName);
   331    331       nameChng = fossil_strcmp(zName, zNewName);
   332    332       if( idv>0 && ridv==0 && idt>0 && ridt>0 ){
   333    333         /* Conflict.  This file has been added to the current checkout
   334    334         ** but also exists in the target checkout.  Use the current version.
   335    335         */
   336         -      printf("CONFLICT %s\n", zName);
          336  +      fossil_print("CONFLICT %s\n", zName);
   337    337         nConflict++;
   338    338       }else if( idt>0 && idv==0 ){
   339    339         /* File added in the target. */
   340         -      printf("ADD %s\n", zName);
          340  +      fossil_print("ADD %s\n", zName);
   341    341         undo_save(zName);
   342    342         if( !nochangeFlag ) vfile_to_disk(0, idt, 0, 0);
   343    343       }else if( idt>0 && idv>0 && ridt!=ridv && chnged==0 ){
   344    344         /* The file is unedited.  Change it to the target version */
   345    345         undo_save(zName);
   346         -      printf("UPDATE %s\n", zName);
          346  +      fossil_print("UPDATE %s\n", zName);
   347    347         if( !nochangeFlag ) vfile_to_disk(0, idt, 0, 0);
   348    348       }else if( idt>0 && idv>0 && file_size(zFullPath)<0 ){
   349    349         /* The file missing from the local check-out. Restore it to the
   350    350         ** version that appears in the target. */
   351         -      printf("UPDATE %s\n", zName);
          351  +      fossil_print("UPDATE %s\n", zName);
   352    352         undo_save(zName);
   353    353         if( !nochangeFlag ) vfile_to_disk(0, idt, 0, 0);
   354    354       }else if( idt==0 && idv>0 ){
   355    355         if( ridv==0 ){
   356    356           /* Added in current checkout.  Continue to hold the file as
   357    357           ** as an addition */
   358    358           db_multi_exec("UPDATE vfile SET vid=%d WHERE id=%d", tid, idv);
   359    359         }else if( chnged ){
   360    360           /* Edited locally but deleted from the target.  Do not track the
   361    361           ** file but keep the edited version around. */
   362         -        printf("CONFLICT %s - edited locally but deleted by update\n", zName);
          362  +        fossil_print("CONFLICT %s - edited locally but deleted by update\n",
          363  +                     zName);
   363    364           nConflict++;
   364    365         }else{
   365         -        printf("REMOVE %s\n", zName);
          366  +        fossil_print("REMOVE %s\n", zName);
   366    367           undo_save(zName);
   367         -        if( !nochangeFlag ) unlink(zFullPath);
          368  +        if( !nochangeFlag ) file_delete(zFullPath);
   368    369         }
   369    370       }else if( idt>0 && idv>0 && ridt!=ridv && chnged ){
   370    371         /* Merge the changes in the current tree into the target version */
   371    372         Blob r, t, v;
   372    373         int rc;
   373    374         if( nameChng ){
   374         -        printf("MERGE %s -> %s\n", zName, zNewName);
          375  +        fossil_print("MERGE %s -> %s\n", zName, zNewName);
   375    376         }else{
   376         -        printf("MERGE %s\n", zName);
          377  +        fossil_print("MERGE %s\n", zName);
   377    378         }
   378    379         undo_save(zName);
   379    380         content_get(ridt, &t);
   380    381         content_get(ridv, &v);
   381    382         rc = merge_3way(&v, zFullPath, &t, &r);
   382    383         if( rc>=0 ){
   383    384           if( !nochangeFlag ){
   384    385             blob_write_to_file(&r, zFullNewPath);
   385    386             file_setexe(zFullNewPath, isexe);
   386    387           }
   387    388           if( rc>0 ){
   388         -          printf("***** %d merge conflicts in %s\n", rc, zNewName);
          389  +          fossil_print("***** %d merge conflicts in %s\n", rc, zNewName);
   389    390             nConflict++;
   390    391           }
   391    392         }else{
   392    393           if( !nochangeFlag ){
   393    394             blob_write_to_file(&t, zFullNewPath);
   394    395             file_setexe(zFullNewPath, isexe);
   395    396           }
   396         -        printf("***** Cannot merge binary file %s\n", zNewName);
          397  +        fossil_print("***** Cannot merge binary file %s\n", zNewName);
   397    398           nConflict++;
   398    399         }
   399         -      if( nameChng && !nochangeFlag ) unlink(zFullPath);
          400  +      if( nameChng && !nochangeFlag ) file_delete(zFullPath);
   400    401         blob_reset(&v);
   401    402         blob_reset(&t);
   402    403         blob_reset(&r);
   403    404       }else{
   404    405         if( chnged ){
   405         -        if( verboseFlag ) printf("EDITED %s\n", zName);
          406  +        if( verboseFlag ) fossil_print("EDITED %s\n", zName);
   406    407         }else{
   407    408           db_bind_int(&mtimeXfer, ":idv", idv);
   408    409           db_bind_int(&mtimeXfer, ":idt", idt);
   409    410           db_step(&mtimeXfer);
   410    411           db_reset(&mtimeXfer);
   411         -        if( verboseFlag ) printf("UNCHANGED %s\n", zName);
          412  +        if( verboseFlag ) fossil_print("UNCHANGED %s\n", zName);
   412    413         }
   413    414       }
   414    415       free(zFullPath);
   415    416       free(zFullNewPath);
   416    417     }
   417    418     db_finalize(&q);
   418    419     db_finalize(&mtimeXfer);
   419         -  printf("--------------\n");
          420  +  fossil_print("--------------\n");
   420    421     show_common_info(tid, "updated-to:", 1, 0);
   421    422   
   422    423     /* Report on conflicts
   423    424     */
   424    425     if( nConflict && !nochangeFlag ){
   425    426       if( internalUpdate ){
   426    427         internalConflictCnt = nConflict;
   427    428       }else{
   428         -      printf("WARNING: %d merge conflicts - see messages above for details.\n",
          429  +      fossil_print("WARNING: %d merge conflicts - see messages above for details.\n",
   429    430                 nConflict);
   430    431       }
   431    432     }
   432    433     
   433    434     /*
   434    435     ** Clean up the mid and pid VFILE entries.  Then commit the changes.
   435    436     */
................................................................................
   568    569       int isExe = 0;
   569    570       char *zFull;
   570    571       zFile = db_column_text(&q, 0);
   571    572       zFull = mprintf("%/%/", g.zLocalRoot, zFile);
   572    573       errCode = historical_version_of_file(zRevision, zFile, &record, &isExe,2);
   573    574       if( errCode==2 ){
   574    575         if( db_int(0, "SELECT rid FROM vfile WHERE pathname=%Q", zFile)==0 ){
   575         -        printf("UNMANAGE: %s\n", zFile);
          576  +        fossil_print("UNMANAGE: %s\n", zFile);
   576    577         }else{
   577    578           undo_save(zFile);
   578         -        unlink(zFull);
   579         -        printf("DELETE: %s\n", zFile);
          579  +        file_delete(zFull);
          580  +        fossil_print("DELETE: %s\n", zFile);
   580    581         }
   581    582         db_multi_exec("DELETE FROM vfile WHERE pathname=%Q", zFile);
   582    583       }else{
   583    584         sqlite3_int64 mtime;
   584    585         undo_save(zFile);
   585    586         blob_write_to_file(&record, zFull);
   586    587         file_setexe(zFull, isExe);
   587         -      printf("REVERTED: %s\n", zFile);
          588  +      fossil_print("REVERTED: %s\n", zFile);
   588    589         mtime = file_mtime(zFull);
   589    590         db_multi_exec(
   590    591            "UPDATE vfile"
   591    592            "   SET mtime=%lld, chnged=0, deleted=0, isexe=%d, mrid=rid,"
   592    593            "       pathname=coalesce(origname,pathname), origname=NULL"     
   593    594            " WHERE pathname=%Q",
   594    595            mtime, isExe, zFile

Changes to src/url.c.

   206    206     int i;
   207    207     url_proxy_options();
   208    208     if( g.argc!=3 && g.argc!=4 ){
   209    209       usage("URL");
   210    210     }
   211    211     url_parse(g.argv[2]);
   212    212     for(i=0; i<2; i++){
   213         -    printf("g.urlIsFile    = %d\n", g.urlIsFile);
   214         -    printf("g.urlIsHttps   = %d\n", g.urlIsHttps);
   215         -    printf("g.urlIsSsh     = %d\n", g.urlIsSsh);
   216         -    printf("g.urlProtocol  = %s\n", g.urlProtocol);
   217         -    printf("g.urlName      = %s\n", g.urlName);
   218         -    printf("g.urlPort      = %d\n", g.urlPort);
   219         -    printf("g.urlDfltPort  = %d\n", g.urlDfltPort);
   220         -    printf("g.urlHostname  = %s\n", g.urlHostname);
   221         -    printf("g.urlPath      = %s\n", g.urlPath);
   222         -    printf("g.urlUser      = %s\n", g.urlUser);
   223         -    printf("g.urlPasswd    = %s\n", g.urlPasswd);
   224         -    printf("g.urlCanonical = %s\n", g.urlCanonical);
   225         -    printf("g.urlFossil    = %s\n", g.urlFossil);
          213  +    fossil_print("g.urlIsFile    = %d\n", g.urlIsFile);
          214  +    fossil_print("g.urlIsHttps   = %d\n", g.urlIsHttps);
          215  +    fossil_print("g.urlIsSsh     = %d\n", g.urlIsSsh);
          216  +    fossil_print("g.urlProtocol  = %s\n", g.urlProtocol);
          217  +    fossil_print("g.urlName      = %s\n", g.urlName);
          218  +    fossil_print("g.urlPort      = %d\n", g.urlPort);
          219  +    fossil_print("g.urlDfltPort  = %d\n", g.urlDfltPort);
          220  +    fossil_print("g.urlHostname  = %s\n", g.urlHostname);
          221  +    fossil_print("g.urlPath      = %s\n", g.urlPath);
          222  +    fossil_print("g.urlUser      = %s\n", g.urlUser);
          223  +    fossil_print("g.urlPasswd    = %s\n", g.urlPasswd);
          224  +    fossil_print("g.urlCanonical = %s\n", g.urlCanonical);
          225  +    fossil_print("g.urlFossil    = %s\n", g.urlFossil);
   226    226       if( g.urlIsFile || g.urlIsSsh ) break;
   227    227       if( i==0 ){
   228         -      printf("********\n");
          228  +      fossil_print("********\n");
   229    229         url_enable_proxy("Using proxy: ");
   230    230       }
   231    231     }
   232    232   }
   233    233   
   234    234   /*
   235    235   ** Proxy specified on the command-line using the --proxy option.
................................................................................
   274    274       char *zOriginalUrl = g.urlCanonical;
   275    275       char *zOriginalHost = g.urlHostname;
   276    276       char *zOriginalUser = g.urlUser;
   277    277       char *zOriginalPasswd = g.urlPasswd;
   278    278       g.urlUser = 0;
   279    279       g.urlPasswd = "";
   280    280       url_parse(zProxy);
   281         -    if( zMsg ) printf("%s%s\n", zMsg, g.urlCanonical);
          281  +    if( zMsg ) fossil_print("%s%s\n", zMsg, g.urlCanonical);
   282    282       g.urlPath = zOriginalUrl;
   283    283       g.urlHostname = zOriginalHost;
   284    284       if( g.urlUser ){
   285    285         char *zCredentials1 = mprintf("%s:%s", g.urlUser, g.urlPasswd);
   286    286         char *zCredentials2 = encode64(zCredentials1, -1);
   287    287         g.urlProxyAuth = mprintf("Basic %z", zCredentials2);
   288    288         free(zCredentials1);

Changes to src/user.c.

   115    115     blob_zero(&secondTry);
   116    116     while(1){
   117    117       prompt_for_passphrase(zPrompt, pPassphrase);
   118    118       if( verify==0 ) break;
   119    119       if( verify==1 && blob_size(pPassphrase)==0 ) break;
   120    120       prompt_for_passphrase("Retype new password: ", &secondTry);
   121    121       if( blob_compare(pPassphrase, &secondTry) ){
   122         -      printf("Passphrases do not match.  Try again...\n");
          122  +      fossil_print("Passphrases do not match.  Try again...\n");
   123    123       }else{
   124    124         break;
   125    125       }
   126    126     }
   127    127     blob_reset(&secondTry);
   128    128   }
   129    129   
................................................................................
   130    130   /*
   131    131   ** Prompt the user to enter a single line of text.
   132    132   */
   133    133   void prompt_user(const char *zPrompt, Blob *pIn){
   134    134     char *z;
   135    135     char zLine[1000];
   136    136     blob_zero(pIn);
   137         -  printf("%s", zPrompt);
          137  +  fossil_print("%s", zPrompt);
   138    138     fflush(stdout);
   139    139     z = fgets(zLine, sizeof(zLine), stdin);
   140    140     if( z ){
   141    141       strip_string(pIn, z);
   142    142     }
   143    143   }
   144    144   
................................................................................
   210    210         "VALUES(%B,%Q,%B,%B,now())",
   211    211         &login, zPw, &caps, &contact
   212    212       );
   213    213       free(zPw);
   214    214     }else if( n>=2 && strncmp(g.argv[2],"default",n)==0 ){
   215    215       user_select();
   216    216       if( g.argc==3 ){
   217         -      printf("%s\n", g.zLogin);
          217  +      fossil_print("%s\n", g.zLogin);
   218    218       }else{
   219    219         if( !db_exists("SELECT 1 FROM user WHERE login=%Q", g.argv[3]) ){
   220    220           fossil_fatal("no such user: %s", g.argv[3]);
   221    221         }
   222    222         if( g.localOpen ){
   223    223           db_lset("default-user", g.argv[3]);
   224    224         }else{
................................................................................
   225    225           db_set("default-user", g.argv[3], 0);
   226    226         }
   227    227       }
   228    228     }else if( n>=2 && strncmp(g.argv[2],"list",n)==0 ){
   229    229       Stmt q;
   230    230       db_prepare(&q, "SELECT login, info FROM user ORDER BY login");
   231    231       while( db_step(&q)==SQLITE_ROW ){
   232         -      printf("%-12s %s\n", db_column_text(&q, 0), db_column_text(&q, 1));
          232  +      fossil_print("%-12s %s\n", db_column_text(&q, 0), db_column_text(&q, 1));
   233    233       }
   234    234       db_finalize(&q);
   235    235     }else if( n>=2 && strncmp(g.argv[2],"password",2)==0 ){
   236    236       char *zPrompt;
   237    237       int uid;
   238    238       Blob pw;
   239    239       if( g.argc!=4 && g.argc!=5 ) usage("password USERNAME ?NEW-PASSWORD?");
................................................................................
   244    244       if( g.argc==5 ){
   245    245         blob_init(&pw, g.argv[4], -1);
   246    246       }else{
   247    247         zPrompt = mprintf("New password for %s: ", g.argv[3]);
   248    248         prompt_for_password(zPrompt, &pw, 1);
   249    249       }
   250    250       if( blob_size(&pw)==0 ){
   251         -      printf("password unchanged\n");
          251  +      fossil_print("password unchanged\n");
   252    252       }else{
   253    253         char *zSecret = sha1_shared_secret(blob_str(&pw), g.argv[3], 0);
   254    254         db_multi_exec("UPDATE user SET pw=%Q, mtime=now() WHERE uid=%d",
   255    255                       zSecret, uid);
   256    256         free(zSecret);
   257    257       }
   258    258     }else if( n>=2 && strncmp(g.argv[2],"capabilities",2)==0 ){
................................................................................
   266    266       }
   267    267       if( g.argc==5 ){
   268    268         db_multi_exec(
   269    269           "UPDATE user SET cap=%Q, mtime=now() WHERE uid=%d",
   270    270           g.argv[4], uid
   271    271         );
   272    272       }
   273         -    printf("%s\n", db_text(0, "SELECT cap FROM user WHERE uid=%d", uid));
          273  +    fossil_print("%s\n", db_text(0, "SELECT cap FROM user WHERE uid=%d", uid));
   274    274     }else{
   275    275       fossil_panic("user subcommand should be one of: "
   276    276                    "capabilities default list new password");
   277    277     }
   278    278   }
   279    279   
   280    280   /*

Changes to src/vfile.c.

   262    262           cReply = 'y';
   263    263         }
   264    264         if( cReply=='n' || cReply=='N' ){
   265    265           blob_reset(&content);
   266    266           continue;
   267    267         }
   268    268       }
   269         -    if( verbose ) printf("%s\n", &zName[nRepos]);
          269  +    if( verbose ) fossil_print("%s\n", &zName[nRepos]);
   270    270       blob_write_to_file(&content, zName);
   271    271       file_setexe(zName, isExe);
   272    272       blob_reset(&content);
   273    273       db_multi_exec("UPDATE vfile SET mtime=%lld WHERE id=%d",
   274    274                     file_mtime(zName), id);
   275    275     }
   276    276     db_finalize(&q);
................................................................................
   284    284     Stmt q;
   285    285     db_prepare(&q, "SELECT %Q || pathname FROM vfile"
   286    286                    " WHERE vid=%d AND mrid>0", g.zLocalRoot, vid);
   287    287     while( db_step(&q)==SQLITE_ROW ){
   288    288       const char *zName;
   289    289   
   290    290       zName = db_column_text(&q, 0);
   291         -    unlink(zName);
          291  +    file_delete(zName);
   292    292     }
   293    293     db_finalize(&q);
   294    294     db_multi_exec("UPDATE vfile SET mtime=NULL WHERE vid=%d AND mrid>0", vid);
   295    295   }
   296    296   
   297    297   /*
   298    298   ** Check to see if the directory named in zPath is the top of a checkout.
................................................................................
   426    426     while( db_step(&q)==SQLITE_ROW ){
   427    427       const char *zFullpath = db_column_text(&q, 0);
   428    428       const char *zName = db_column_text(&q, 1);
   429    429       int isSelected = db_column_int(&q, 3);
   430    430   
   431    431       if( isSelected ){
   432    432         md5sum_step_text(zName, -1);
   433         -      in = fopen(zFullpath,"rb");
          433  +      in = fossil_fopen(zFullpath,"rb");
   434    434         if( in==0 ){
   435    435           md5sum_step_text(" 0\n", -1);
   436    436           continue;
   437    437         }
   438    438         fseek(in, 0L, SEEK_END);
   439    439         sqlite3_snprintf(sizeof(zBuf), zBuf, " %ld\n", ftell(in));
   440    440         fseek(in, 0L, SEEK_SET);
................................................................................
   489    489       const char *zFullpath = db_column_text(&q, 0);
   490    490       const char *zName = db_column_text(&q, 1);
   491    491       int rid = db_column_int(&q, 2);
   492    492   
   493    493       blob_zero(&disk);
   494    494       rc = blob_read_from_file(&disk, zFullpath);
   495    495       if( rc<0 ){
   496         -      printf("ERROR: cannot read file [%s]\n", zFullpath);
          496  +      fossil_print("ERROR: cannot read file [%s]\n", zFullpath);
   497    497         blob_reset(&disk);
   498    498         continue;
   499    499       }
   500    500       blob_zero(&repo);
   501    501       content_get(rid, &repo);
   502    502       if( blob_size(&repo)!=blob_size(&disk) ){
   503         -      printf("ERROR: [%s] is %d bytes on disk but %d in the repository\n",
          503  +      fossil_print("ERROR: [%s] is %d bytes on disk but %d in the repository\n",
   504    504                zName, blob_size(&disk), blob_size(&repo));
   505    505         blob_reset(&disk);
   506    506         blob_reset(&repo);
   507    507         continue;
   508    508       }
   509    509       if( blob_compare(&repo, &disk) ){
   510         -      printf("ERROR: [%s] is different on disk compared to the repository\n",
   511         -             zName);
          510  +      fossil_print(
          511  +          "ERROR: [%s] is different on disk compared to the repository\n",
          512  +          zName);
   512    513       }
   513    514       blob_reset(&disk);
   514    515       blob_reset(&repo);
   515    516     }
   516    517     db_finalize(&q);
   517    518   }
   518    519   

Changes to src/wiki.c.

   914    914       zFile  = (g.argc==4) ? 0 : g.argv[4];
   915    915       if( zFile ){
   916    916         FILE * zF;
   917    917         short doClose = 0;
   918    918         if( (1 == strlen(zFile)) && ('-'==zFile[0]) ){
   919    919           zF = stdout;
   920    920         }else{
   921         -        zF = fopen( zFile, "w" );
          921  +        zF = fossil_fopen( zFile, "w" );
   922    922           doClose = zF ? 1 : 0;
   923    923         }
   924    924         if( ! zF ){
   925    925           fossil_fatal("wiki export could not open output file for writing.");
   926    926         }
   927    927         fprintf(zF,"%.*s\n", i, zBody);
   928    928         if( doClose ) fclose(zF);
   929    929       }else{
   930         -      printf("%.*s\n", i, zBody);
          930  +      fossil_print("%.*s\n", i, zBody);
   931    931       }
   932    932       manifest_destroy(pWiki);
   933    933       return;
   934    934     }else
   935    935     if( strncmp(g.argv[2],"commit",n)==0
   936    936         || strncmp(g.argv[2],"create",n)==0 ){
   937    937       char *zPageName;
................................................................................
   943    943       if( g.argc==4 ){
   944    944         blob_read_from_channel(&content, stdin, -1);
   945    945       }else{
   946    946         blob_read_from_file(&content, g.argv[4]);
   947    947       }
   948    948       if( g.argv[2][1]=='r' ){
   949    949         wiki_cmd_commit(zPageName, 1, &content);
   950         -      printf("Created new wiki page %s.\n", zPageName);
          950  +      fossil_print("Created new wiki page %s.\n", zPageName);
   951    951       }else{
   952    952         wiki_cmd_commit(zPageName, 0, &content);
   953         -      printf("Updated wiki page %s.\n", zPageName);
          953  +      fossil_print("Updated wiki page %s.\n", zPageName);
   954    954       }
   955    955       blob_reset(&content);
   956    956     }else
   957    957     if( strncmp(g.argv[2],"delete",n)==0 ){
   958    958       if( g.argc!=5 ){
   959    959         usage("delete PAGENAME");
   960    960       }
................................................................................
   964    964       Stmt q;
   965    965       db_prepare(&q, 
   966    966         "SELECT substr(tagname, 6) FROM tag WHERE tagname GLOB 'wiki-*'"
   967    967         " ORDER BY lower(tagname) /*sort*/"
   968    968       );
   969    969       while( db_step(&q)==SQLITE_ROW ){
   970    970         const char *zName = db_column_text(&q, 0);
   971         -      printf( "%s\n",zName);
          971  +      fossil_print( "%s\n",zName);
   972    972       }
   973    973       db_finalize(&q);
   974    974     }else
   975    975     {
   976    976       goto wiki_cmd_usage;
   977    977     }
   978    978     return;
   979    979   
   980    980   wiki_cmd_usage:
   981    981     usage("export|create|commit|list ...");
   982    982   }

Changes to src/wikiformat.c.

  1732   1732         }
  1733   1733         default: {
  1734   1734           break;
  1735   1735         }
  1736   1736       }
  1737   1737       z += n;
  1738   1738     }
         1739  +  free(renderer.aStack);
  1739   1740   }

Changes to src/winhttp.c.

    90     90       z = strstr(zHdr, "\r\n\r\n");
    91     91       if( z ){
    92     92         wanted = find_content_length(zHdr) + (&z[4]-zHdr) - amt;
    93     93         break;
    94     94       }
    95     95     }
    96     96     if( amt>=sizeof(zHdr) ) goto end_request;
    97         -  out = fopen(zRequestFName, "wb");
           97  +  out = fossil_fopen(zRequestFName, "wb");
    98     98     if( out==0 ) goto end_request;
    99     99     fwrite(zHdr, 1, amt, out);
   100    100     while( wanted>0 ){
   101    101       got = recv(p->s, zHdr, sizeof(zHdr), 0);
   102    102       if( got==SOCKET_ERROR ) goto end_request;
   103    103       if( got ){
   104    104         fwrite(zHdr, 1, got, out);
................................................................................
   110    110     fclose(out);
   111    111     out = 0;
   112    112     sqlite3_snprintf(sizeof(zCmd), zCmd, "\"%s\" http \"%s\" %s %s %s --nossl%s",
   113    113       fossil_nameofexe(), g.zRepositoryName, zRequestFName, zReplyFName, 
   114    114       inet_ntoa(p->addr.sin_addr), p->zOptions
   115    115     );
   116    116     fossil_system(zCmd);
   117         -  in = fopen(zReplyFName, "rb");
          117  +  in = fossil_fopen(zReplyFName, "rb");
   118    118     if( in ){
   119    119       while( (got = fread(zHdr, 1, sizeof(zHdr), in))>0 ){
   120    120         send(p->s, zHdr, got, 0);
   121    121       }
   122    122     }
   123    123   
   124    124   end_request:
   125    125     if( out ) fclose(out);
   126    126     if( in ) fclose(in);
   127    127     closesocket(p->s);
   128         -  unlink(zRequestFName);
   129         -  unlink(zReplyFName);
          128  +  file_delete(zRequestFName);
          129  +  file_delete(zReplyFName);
   130    130     free(p);
   131    131   }
   132    132   
   133    133   /*
   134    134   ** Start a listening socket and process incoming HTTP requests on
   135    135   ** that socket.
   136    136   */
................................................................................
   144    144     WSADATA wd;
   145    145     SOCKET s = INVALID_SOCKET;
   146    146     SOCKADDR_IN addr;
   147    147     int idCnt = 0;
   148    148     int iPort = mnPort;
   149    149     Blob options;
   150    150   
   151         -  if( zStopper ) unlink(zStopper);
          151  +  if( zStopper ) file_delete(zStopper);
   152    152     blob_zero(&options);
   153    153     if( zNotFound ){
   154    154       blob_appendf(&options, " --notfound %s", zNotFound);
   155    155     }
   156    156     if( g.useLocalauth ){
   157    157       blob_appendf(&options, " --localauth");
   158    158     }
................................................................................
   188    188         fossil_fatal("unable to open listening socket on ports %d", mnPort);
   189    189       }else{
   190    190         fossil_fatal("unable to open listening socket on any"
   191    191                      " port in the range %d..%d", mnPort, mxPort);
   192    192       }
   193    193     }
   194    194     zTempPrefix = mprintf("fossil_server_P%d_", iPort);
   195         -  printf("Listening for HTTP requests on TCP port %d\n", iPort);
          195  +  fossil_print("Listening for HTTP requests on TCP port %d\n", iPort);
   196    196     if( zBrowser ){
   197    197       zBrowser = mprintf(zBrowser, iPort);
   198         -    printf("Launch webbrowser: %s\n", zBrowser);
          198  +    fossil_print("Launch webbrowser: %s\n", zBrowser);
   199    199       fossil_system(zBrowser);
   200    200     }
   201         -  printf("Type Ctrl-C to stop the HTTP server\n");
          201  +  fossil_print("Type Ctrl-C to stop the HTTP server\n");
   202    202     for(;;){
   203    203       SOCKET client;
   204    204       SOCKADDR_IN client_addr;
   205    205       HttpRequest *p;
   206    206       int len = sizeof(client_addr);
   207    207   
   208    208       client = accept(s, (struct sockaddr*)&client_addr, &len);

Changes to src/xfer.c.

  1204   1204     if( g.argc!=2 && g.argc!=3 ){
  1205   1205       usage("?MESSAGEFILE?");
  1206   1206     }
  1207   1207     blob_zero(&g.cgiIn);
  1208   1208     blob_read_from_file(&g.cgiIn, g.argc==2 ? "-" : g.argv[2]);
  1209   1209     disableLogin = 1;
  1210   1210     page_xfer();
  1211         -  printf("%s\n", cgi_extract_content(&notUsed));
         1211  +  fossil_print("%s\n", cgi_extract_content(&notUsed));
  1212   1212   }
  1213   1213   
  1214   1214   /*
  1215   1215   ** Format strings for progress reporting.
  1216   1216   */
  1217   1217   static const char zLabelFormat[] = "%-10s %10s %10s %10s %10s\n";
  1218   1218   static const char zValueFormat[] = "\r%-10s %10d %10d %10d %10d\n";
................................................................................
  1388   1388       nCardSent = 0;
  1389   1389       nCardRcvd = 0;
  1390   1390       xfer.nFileSent = 0;
  1391   1391       xfer.nDeltaSent = 0;
  1392   1392       xfer.nGimmeSent = 0;
  1393   1393       xfer.nIGotSent = 0;
  1394   1394       if( !g.cgiOutput && !g.fQuiet ){
  1395         -      printf("waiting for server...");
         1395  +      fossil_print("waiting for server...");
  1396   1396       }
  1397   1397       fflush(stdout);
  1398   1398       if( http_exchange(&send, &recv, cloneFlag==0 || nCycle>0) ){
  1399   1399         nErr++;
  1400   1400         break;
  1401   1401       }
  1402   1402       lastPctDone = -1;
................................................................................
  1444   1444           continue;
  1445   1445         }
  1446   1446         xfer.nToken = blob_tokenize(&xfer.line, xfer.aToken, count(xfer.aToken));
  1447   1447         nCardRcvd++;
  1448   1448         if( !g.cgiOutput && !g.fQuiet && recv.nUsed>0 ){
  1449   1449           pctDone = (recv.iCursor*100)/recv.nUsed;
  1450   1450           if( pctDone!=lastPctDone ){
  1451         -          printf("\rprocessed: %d%%         ", pctDone);
         1451  +          fossil_print("\rprocessed: %d%%         ", pctDone);
  1452   1452             lastPctDone = pctDone;
  1453   1453             fflush(stdout);
  1454   1454           }
  1455   1455         }
  1456   1456   
  1457   1457         /*   file UUID SIZE \n CONTENT
  1458   1458         **   file UUID DELTASRC SIZE \n CONTENT