您的位置：首页 > 运维架构 > Linux

Linux命令学习总结：dos2unix - unix2dos

2017-05-17 16:07 495 查看

Linux命令学习总结：dos2unix - unix2dos

命令简介：

dos2unix是将Windows格式文件转换为Unix、Linux格式的实用命令。Windows格式文件的换行符为\r\n ,而Unix&Linux文件的换行符为\n. dos2unix命令其实就是将文件中的\r\n 转换为\n。

而unix2dos则是和dos2unix互为孪生的一个命令，它是将Linux&Unix格式文件转换为Windows格式文件的命令。

 

命令语法：

 

dos2unix [options] [-c convmode] [-o file ...] [-n infile outfile ...]

unix2dos [options] [-c convmode] [-o file ...] [-n infile outfile ...]

 

命令参数：

此命令参数是Red Hat Enterprise Linux Server release 5.7下dos2unix命令参数，不同版本Linux的dos2nnix命令参数有可能不同。

参数
长参数
描叙
-h
 
显示命令dos2unix联机帮助信息。
-k
 
保持文件时间戳不变
-q
 
静默模式，不输出转换结果信息等
-V
 
显示命令版本信息
-c
 
转换模式
-o
 
在源文件转换，默认参数
-n
 
保留原本的旧档，将转换后的内容输出到新档案.默认都会直接在原来的文件上修改，
 

使用示例：

1: 查看dos2unix命令的帮助信息

[root@DB-Server myscript]# man dos2unix

 

[root@DB-Server myscript]# dos2unix -h

dos2unix Copyright (c) 1994-1995 Benjamin Lin

         Copyright (c) 1998      Bernd Johannes Wuebben (Version 3.0)

         Copyright (c) 1998      Christian Wurll (Version 3.1)

Usage: dos2unix [-hkqV] [-c convmode] [-o file ...] [-n infile outfile ...]

-h --help        give this help

-k --keepdate    keep output file date

-q --quiet       quiet mode, suppress all warnings

                  always on in stdin->stdout mode

-V --version     display version number

-c --convmode    conversion mode

convmode         ASCII, 7bit, ISO, Mac, default to ASCII

-l --newline     add additional newline in all but Mac convmode

-o --oldfile     write to old file

file ...         files to convert in old file mode

-n --newfile     write to new file

infile           original file in new file mode

outfile          output file in new file mode


 

2: dos2unix filename 将Windows格式文本转换为Unix&Linux格式文件

1: [root@DB-Server myscript]# cat -v test.sh

2: . /home/oracle/.bash_profile^M

3: echo ' '^M

4: date^M

5: echo ' '^M

6: ^M

7: sqlplus test/test @/home/oracle/scripts/test.sql^M

8: ^M

9: echo ' '^M

10: date^M

11: echo ' '^M

12: [root@DB-Server myscript]# dos2unix test.sh

13: dos2unix: converting file test.sh to UNIX format ...

14: [root@DB-Server myscript]# cat -v test.sh

15: . /home/oracle/.bash_profile

16: echo ' '

17: date

18: echo ' '

19: 

20: sqlplus test/test @/home/oracle/scripts/test.sql

21: 

22: echo ' '

23: date

24: echo ' '


 

3： dos2unix 可以一次转换多个文件

1: dos2unix filename1 filename2 filename3


 

4: 默认情况下会在源文件上进行转换，如果需要保留源文件，那么可以使用参数-n dos2unix -n oldfilename newfilename

1: [root@DB-Server myscript]# dos2unix -n dosfile linuxfile

2: dos2unix: converting file dosfile to file linuxfile in UNIX format ...

3: [root@DB-Server myscript]# cat -v dosfile

4: it is a windows dos file^M

5: you should convert to unix&linux format^M

6: [root@DB-Server myscript]# cat -v linuxfile

7: it is a windows dos file

8: you should convert to unix&linux format

9: [root@DB-Server myscript]#






 

5:保持文件时间戳不变

1: [root@DB-Server myscript]# ls -lrt dosfile

2: -rw-r--r-- 1 root root 67 Dec 26 11:46 dosfile

3: [root@DB-Server myscript]# dos2unix dosfile

4: dos2unix: converting file dosfile to UNIX format ...

5: [root@DB-Server myscript]# ls -lrt dosfile

6: -rw-r--r-- 1 root root 65 Dec 26 11:58 dosfile

7: [root@DB-Server myscript]# dos2unix -k dosfile

8: dos2unix: converting file dosfile to UNIX format ...

9: [root@DB-Server myscript]#ls -lrt dosfile 

10: -rw-r--r-- 1 root root 65 Dec 26 11:58 dosfile


6：静默模式格式化文件

1: [root@DB-Server myscript]# unix2dos -q dosfile

2: 

3: [root@DB-Server myscript]#


dos2unix的下载地址为http://sourceforge.net/projects/dos2unix/ ,可以从上面下载最新版本的dos2unix、unix2dos等命令工具以及相关文档，dos2unix的源码如下所示

1: /*

2:

3: *  Name: dos2unix

4:

5: *  Documentation:

6:

7: *    Remove cr ('\x0d') characters from a file.

8:

9: *

10:

11: *  The dos2unix package is distributed under FreeBSD style license.

12:

13: *  See also http://www.freebsd.org/copyright/freebsd-license.html[/code] 
14:

15: *  --------

16:

17: *

18:

19: *  Copyright (C) 2009-2015 Erwin Waterlander

20:

21: *  Copyright (C) 1998 Christian Wurll

22:

23: *  Copyright (C) 1998 Bernd Johannes Wuebben

24:

25: *  Copyright (C) 1994-1995 Benjamin Lin.

26:

27: *  All rights reserved.

28:

29: *

30:

31: *  Redistribution and use in source and binary forms, with or without

32:

33: *  modification, are permitted provided that the following conditions

34:

35: *  are met:

36:

37: *  1. Redistributions of source code must retain the above copyright

38:

39: *     notice, this list of conditions and the following disclaimer.

40:

41: *  2. Redistributions in binary form must reproduce the above copyright

42:

43: *     notice in the documentation and/or other materials provided with

44:

45: *     the distribution.

46:

47: *

48:

49: *  THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY

50:

51: *  EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

52:

53: *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

54:

55: *  PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE

56:

57: *  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

58:

59: *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT

60:

61: *  OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR

62:

63: *  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,

64:

65: *  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE

66:

67: *  OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN

68:

69: *  IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

70:

71: *

72:

73: *  == 1.0 == 1989.10.04 == John Birchfield (jb@koko.csustan.edu)

74:

75: *  == 1.1 == 1994.12.20 == Benjamin Lin (blin@socs.uts.edu.au)

76:

77: *     Cleaned up for Borland C/C++ 4.02

78:

79: *  == 1.2 == 1995.03.16 == Benjamin Lin (blin@socs.uts.edu.au)

80:

81: *     Modified to more conform to UNIX style.

82:

83: *  == 2.0 == 1995.03.19 == Benjamin Lin (blin@socs.uts.edu.au)

84:

85: *     Rewritten from scratch.

86:

87: *  == 2.1 == 1995.03.29 == Benjamin Lin (blin@socs.uts.edu.au)

88:

89: *     Conversion to SunOS charset implemented.

90:

91: *  == 2.2 == 1995.03.30 == Benjamin Lin (blin@socs.uts.edu.au)

92:

93: *     Fixed a bug in 2.1 where in new-file mode, if outfile already exists

94:

95: *     conversion can not be completed properly.

96:

97: *

98:

99: * Added Mac text file translation, i.e. \r to \n conversion

100:

101: * Bernd Johannes Wuebben, wuebben@kde.org

102:

103: * Wed Feb  4 19:12:58 EST 1998

104:

105: *

106:

107: * Added extra newline if ^M occurs

108:

109: * Christian Wurll, wurll@ira.uka.de

110:

111: * Thu Nov 19 1998

112:

113: *

114:

115: *  See ChangeLog.txt for complete version history.

116:

117: *

118:

119: */

120: 

121: 

122: 

123: /* #define DEBUG 1 */

124: 

125: #define __DOS2UNIX_C

126: 

127: 

128: #include "common.h"

129: 

130: #include "dos2unix.h"

131: 

132: # if (defined(_WIN32) && !defined(__CYGWIN__))

133: 

134: #include <windows.h>

135: 

136: #endif

137: 

138: #ifdef D2U_UNICODE

139: 

140: #if !defined(__MSDOS__) && !defined(_WIN32) && !defined(__OS2__)  /* Unix, Cygwin */

141: 

142: # include <langinfo.h>

143: 

144: #endif

145: 

146: #endif

147: 

148: 

149: void PrintLicense(void)

150: 

151: {

152: 

153: printf("%s", _("\

154: 

155: Copyright (C) 2009-2015 Erwin Waterlander\n\

156: 

157: Copyright (C) 1998      Christian Wurll (Version 3.1)\n\

158: 

159: Copyright (C) 1998      Bernd Johannes Wuebben (Version 3.0)\n\

160: 

161: Copyright (C) 1994-1995 Benjamin Lin\n\

162: 

163: All rights reserved.\n\n"));

164: 

165: PrintBSDLicense();

166: 

167: }

168: 

169: 

170: #ifdef D2U_UNICODE

171: 

172: wint_t StripDelimiterW(FILE* ipInF, FILE* ipOutF, CFlag *ipFlag, wint_t CurChar, unsigned int *converted, const char *progname)

173: 

174: {

175: 

176: wint_t TempNextChar;

177: 

178: /* CurChar is always CR (x0d) */

179: 

180: /* In normal dos2unix mode put nothing (skip CR). */

181: 

182: /* Don't modify Mac files when in dos2unix mode. */

183: 

184: if ( (TempNextChar = d2u_getwc(ipInF, ipFlag->bomtype)) != WEOF) {

185: 

186: if (d2u_ungetwc( TempNextChar, ipInF, ipFlag->bomtype) == WEOF) {  /* put back peek char */

187: 

188: d2u_getc_error(ipFlag,progname);

189: 

190: return WEOF;

191: 

192: }

193: 

194: if ( TempNextChar != 0x0a ) {

195: 

196: if (d2u_putwc(CurChar, ipOutF, ipFlag, progname) == WEOF) {  /* Mac line, put CR */

197: 

198: d2u_putwc_error(ipFlag,progname);

199: 

200: return WEOF;

201: 

202: }

203: 

204: } else {

205: 

206: (*converted)++;

207: 

208: if (ipFlag->NewLine) {  /* add additional LF? */

209: 

210: if (d2u_putwc(0x0a, ipOutF, ipFlag, progname) == WEOF) {

211: 

212: d2u_putwc_error(ipFlag,progname);

213: 

214: return WEOF;

215: 

216: }

217: 

218: }

219: 

220: }

221: 

222: } else {

223: 

224: if (ferror(ipInF)) {

225: 

226: d2u_getc_error(ipFlag,progname);

227: 

228: return WEOF;

229: 

230: }

231: 

232: if ( CurChar == 0x0d ) {  /* EOF: last Mac line delimiter (CR)? */

233: 

234: if (d2u_putwc(CurChar, ipOutF, ipFlag, progname) == WEOF) {

235: 

236: d2u_putwc_error(ipFlag,progname);

237: 

238: return WEOF;

239: 

240: }

241: 

242: }

243: 

244: }

245: 

246: return CurChar;

247: 

248: }

249: 

250: #endif

251: 

252: 

253: /* CUR        NEXT

254:

255: 0xd(CR)    0xa(LF)  => put LF if option -l was used

256:

257: 0xd(CR)  ! 0xa(LF)  => put CR

258:

259: 0xd(CR)    EOF      => put CR

260:

261: */

262: 

263: int StripDelimiter(FILE* ipInF, FILE* ipOutF, CFlag *ipFlag, int CurChar, unsigned int *converted, const char *progname)

264: 

265: {

266: 

267: int TempNextChar;

268: 

269: /* CurChar is always CR (x0d) */

270: 

271: /* In normal dos2unix mode put nothing (skip CR). */

272: 

273: /* Don't modify Mac files when in dos2unix mode. */

274: 

275: if ( (TempNextChar = fgetc(ipInF)) != EOF) {

276: 

277: if (ungetc( TempNextChar, ipInF ) == EOF) { /* put back peek char */

278: 

279: d2u_getc_error(ipFlag,progname);

280: 

281: return EOF;

282: 

283: }

284: 

285: if ( TempNextChar != '\x0a' ) {

286: 

287: if (fputc( CurChar, ipOutF ) == EOF) { /* Mac line, put CR */

288: 

289: d2u_putc_error(ipFlag,progname);

290: 

291: return EOF;

292: 

293: }

294: 

295: } else {

296: 

297: (*converted)++;

298: 

299: if (ipFlag->NewLine) {  /* add additional LF? */

300: 

301: if (fputc('\x0a', ipOutF) == EOF) {

302: 

303: d2u_putc_error(ipFlag,progname);

304: 

305: return EOF;

306: 

307: }

308: 

309: }

310: 

311: }

312: 

313: } else {

314: 

315: if (ferror(ipInF)) {

316: 

317: d2u_getc_error(ipFlag,progname);

318: 

319: return EOF;

320: 

321: }

322: 

323: if ( CurChar == '\x0d' ) {  /* EOF: last Mac line delimiter (CR)? */

324: 

325: if (fputc( CurChar, ipOutF ) == EOF) {

326: 

327: d2u_putc_error(ipFlag,progname);

328: 

329: return EOF;

330: 

331: }

332: 

333: }

334: 

335: }

336: 

337: return CurChar;

338: 

339: }

340: 

341: 

342: /* converts stream ipInF to UNIX format text and write to stream ipOutF

343:

344: * RetVal: 0  if success

345:

346: *         -1  otherwise

347:

348: */

349: 

350: #ifdef D2U_UNICODE

351: 

352: int ConvertDosToUnixW(FILE* ipInF, FILE* ipOutF, CFlag *ipFlag, const char *progname)

353: 

354: {

355: 

356: int RetVal = 0;

357: 

358: wint_t TempChar;

359: 

360: wint_t TempNextChar;

361: 

362: unsigned int line_nr = 1;

363: 

364: unsigned int converted = 0;

365: 

366: 

367: ipFlag->status = 0;

368: 

369: 

370: /* CR-LF -> LF */

371: 

372: /* LF    -> LF, in case the input file is a Unix text file */

373: 

374: /* CR    -> CR, in dos2unix mode (don't modify Mac file) */

375: 

376: /* CR    -> LF, in Mac mode */

377: 

378: /* \x0a = Newline/Line Feed (LF) */

379: 

380: /* \x0d = Carriage Return (CR) */

381: 

382: 

383: switch (ipFlag->FromToMode)

384: 

385: {

386: 

387: case FROMTO_DOS2UNIX: /* dos2unix */

388: 

389: while ((TempChar = d2u_getwc(ipInF, ipFlag->bomtype)) != WEOF) {  /* get character */

390: 

391: if ((ipFlag->Force == 0) &&

392: 

393: (TempChar < 32) &&

394: 

395: (TempChar != 0x0a) &&  /* Not an LF */

396: 

397: (TempChar != 0x0d) &&  /* Not a CR */

398: 

399: (TempChar != 0x09) &&  /* Not a TAB */

400: 

401: (TempChar != 0x0c)) {  /* Not a form feed */

402: 

403: RetVal = -1;

404: 

405: ipFlag->status |= BINARY_FILE ;

406: 

407: if (ipFlag->verbose) {

408: 

409: if ((ipFlag->stdio_mode) && (!ipFlag->error)) ipFlag->error = 1;

410: 

411: d2u_fprintf(stderr, "%s: ", progname);

412: 

413: d2u_fprintf(stderr, _("Binary symbol 0x00%02X found at line %u\n"),TempChar, line_nr);

414: 

415: }

416: 

417: break;

418: 

419: }

420: 

421: if (TempChar != 0x0d) {

422: 

423: if (TempChar == 0x0a) /* Count all DOS and Unix line breaks */

424: 

425: ++line_nr;

426: 

427: if (d2u_putwc(TempChar, ipOutF, ipFlag, progname) == WEOF) {

428: 

429: RetVal = -1;

430: 

431: d2u_putwc_error(ipFlag,progname);

432: 

433: break;

434: 

435: }

436: 

437: } else {

438: 

439: if (StripDelimiterW( ipInF, ipOutF, ipFlag, TempChar, &converted, progname) == WEOF) {

440: 

441: RetVal = -1;

442: 

443: break;

444: 

445: }

446: 

447: }

448: 

449: }

450: 

451: if ((TempChar == WEOF) && ferror(ipInF)) {

452: 

453: RetVal = -1;

454: 

455: d2u_getc_error(ipFlag,progname);

456: 

457: }

458: 

459: break;

460: 

461: case FROMTO_MAC2UNIX: /* mac2unix */

462: 

463: while ((TempChar = d2u_getwc(ipInF, ipFlag->bomtype)) != WEOF) {

464: 

465: if ((ipFlag->Force == 0) &&

466: 

467: (TempChar < 32) &&

468: 

469: (TempChar != 0x0a) &&  /* Not an LF */

470: 

471: (TempChar != 0x0d) &&  /* Not a CR */

472: 

473: (TempChar != 0x09) &&  /* Not a TAB */

474: 

475: (TempChar != 0x0c)) {  /* Not a form feed */

476: 

477: RetVal = -1;

478: 

479: ipFlag->status |= BINARY_FILE ;

480: 

481: if (ipFlag->verbose) {

482: 

483: if ((ipFlag->stdio_mode) && (!ipFlag->error)) ipFlag->error = 1;

484: 

485: d2u_fprintf(stderr, "%s: ", progname);

486: 

487: d2u_fprintf(stderr, _("Binary symbol 0x00%02X found at line %u\n"), TempChar, line_nr);

488: 

489: }

490: 

491: break;

492: 

493: }

494: 

495: if ((TempChar != 0x0d)) {

496: 

497: if (TempChar == 0x0a) /* Count all DOS and Unix line breaks */

498: 

499: ++line_nr;

500: 

501: if(d2u_putwc(TempChar, ipOutF, ipFlag, progname) == WEOF) {

502: 

503: RetVal = -1;

504: 

505: d2u_putwc_error(ipFlag,progname);

506: 

507: break;

508: 

509: }

510: 

511: }

512: 

513: else{

514: 

515: /* TempChar is a CR */

516: 

517: if ( (TempNextChar = d2u_getwc(ipInF, ipFlag->bomtype)) != WEOF) {

518: 

519: if (d2u_ungetwc( TempNextChar, ipInF, ipFlag->bomtype) == WEOF) {  /* put back peek char */

520: 

521: d2u_getc_error(ipFlag,progname);

522: 

523: RetVal = -1;

524: 

525: break;

526: 

527: }

528: 

529: /* Don't touch this delimiter if it's a CR,LF pair. */

530: 

531: if ( TempNextChar == 0x0a ) {

532: 

533: if (d2u_putwc(0x0d, ipOutF, ipFlag, progname) == WEOF) { /* put CR, part of DOS CR-LF */

534: 

535: d2u_putwc_error(ipFlag,progname);

536: 

537: RetVal = -1;

538: 

539: break;

540: 

541: }

542: 

543: continue;

544: 

545: }

546: 

547: }

548: 

549: if (d2u_putwc(0x0a, ipOutF, ipFlag, progname) == WEOF) { /* MAC line end (CR). Put LF */

550: 

551: RetVal = -1;

552: 

553: d2u_putwc_error(ipFlag,progname);

554: 

555: break;

556: 

557: }

558: 

559: converted++;

560: 

561: line_nr++; /* Count all Mac line breaks */

562: 

563: if (ipFlag->NewLine) {  /* add additional LF? */

564: 

565: if (d2u_putwc(0x0a, ipOutF, ipFlag, progname) == WEOF) {

566: 

567: RetVal = -1;

568: 

569: d2u_putwc_error(ipFlag,progname);

570: 

571: break;

572: 

573: }

574: 

575: }

576: 

577: }

578: 

579: }

580: 

581: if ((TempChar == WEOF) && ferror(ipInF)) {

582: 

583: RetVal = -1;

584: 

585: d2u_getc_error(ipFlag,progname);

586: 

587: }

588: 

589: break;

590: 

591: default: /* unknown FromToMode */

592: 

593: ;

594: 

595: #if DEBUG

596: 

597: d2u_fprintf(stderr, "%s: ", progname);

598: 

599: d2u_fprintf(stderr, _("program error, invalid conversion mode %d\n"),ipFlag->FromToMode);

600: 

601: exit(1);

602: 

603: #endif

604: 

605: }

606: 

607: if (ipFlag->status & UNICODE_CONVERSION_ERROR)

608: 

609: ipFlag->line_nr = line_nr;

610: 

611: if ((RetVal == 0) && (ipFlag->verbose > 1)) {

612: 

613: d2u_fprintf(stderr, "%s: ", progname);

614: 

615: d2u_fprintf(stderr, _("Converted %u out of %u line breaks.\n"), converted, line_nr -1);

616: 

617: }

618: 

619: return RetVal;

620: 

621: }

622: 

623: #endif

624: 

625: 

626: /* converts stream ipInF to UNIX format text and write to stream ipOutF

627:

628: * RetVal: 0  if success

629:

630: *         -1  otherwise

631:

632: */

633: 

634: int ConvertDosToUnix(FILE* ipInF, FILE* ipOutF, CFlag *ipFlag, const char *progname)

635: 

636: {

637: 

638: int RetVal = 0;

639: 

640: int TempChar;

641: 

642: int TempNextChar;

643: 

644: int *ConvTable;

645: 

646: unsigned int line_nr = 1;

647: 

648: unsigned int converted = 0;

649: 

650: 

651: ipFlag->status = 0;

652: 

653: 

654: switch (ipFlag->ConvMode) {

655: 

656: case CONVMODE_ASCII: /* ascii */

657: 

658: case CONVMODE_UTF16LE: /* Assume UTF-16LE, bomtype = FILE_UTF8 or GB18030 */

659: 

660: case CONVMODE_UTF16BE: /* Assume UTF-16BE, bomtype = FILE_UTF8 or GB18030 */

661: 

662: ConvTable = D2UAsciiTable;

663: 

664: break;

665: 

666: case CONVMODE_7BIT: /* 7bit */

667: 

668: ConvTable = D2U7BitTable;

669: 

670: break;

671: 

672: case CONVMODE_437: /* iso */

673: 

674: ConvTable = D2UIso437Table;

675: 

676: break;

677: 

678: case CONVMODE_850: /* iso */

679: 

680: ConvTable = D2UIso850Table;

681: 

682: break;

683: 

684: case CONVMODE_860: /* iso */

685: 

686: ConvTable = D2UIso860Table;

687: 

688: break;

689: 

690: case CONVMODE_863: /* iso */

691: 

692: ConvTable = D2UIso863Table;

693: 

694: break;

695: 

696: case CONVMODE_865: /* iso */

697: 

698: ConvTable = D2UIso865Table;

699: 

700: break;

701: 

702: case CONVMODE_1252: /* iso */

703: 

704: ConvTable = D2UIso1252Table;

705: 

706: break;

707: 

708: default: /* unknown convmode */

709: 

710: ipFlag->status |= WRONG_CODEPAGE ;

711: 

712: return(-1);

713: 

714: }

715: 

716: /* Turn off ISO and 7-bit conversion for Unicode text files */

717: 

718: if (ipFlag->bomtype > 0)

719: 

720: ConvTable = D2UAsciiTable;

721: 

722: 

723: if ((ipFlag->ConvMode > CONVMODE_7BIT) && (ipFlag->verbose)) { /* not ascii or 7bit */

724: 

725: d2u_fprintf(stderr, "%s: ", progname);

726: 

727: d2u_fprintf(stderr, _("using code page %d.\n"), ipFlag->ConvMode);

728: 

729: }

730: 

731: 

732: /* CR-LF -> LF */

733: 

734: /* LF    -> LF, in case the input file is a Unix text file */

735: 

736: /* CR    -> CR, in dos2unix mode (don't modify Mac file) */

737: 

738: /* CR    -> LF, in Mac mode */

739: 

740: /* \x0a = Newline/Line Feed (LF) */

741: 

742: /* \x0d = Carriage Return (CR) */

743: 

744: 

745: switch (ipFlag->FromToMode) {

746: 

747: case FROMTO_DOS2UNIX: /* dos2unix */

748: 

749: while ((TempChar = fgetc(ipInF)) != EOF) {  /* get character */

750: 

751: if ((ipFlag->Force == 0) &&

752: 

753: (TempChar < 32) &&

754: 

755: (TempChar != '\x0a') &&  /* Not an LF */

756: 

757: (TempChar != '\x0d') &&  /* Not a CR */

758: 

759: (TempChar != '\x09') &&  /* Not a TAB */

760: 

761: (TempChar != '\x0c')) {  /* Not a form feed */

762: 

763: RetVal = -1;

764: 

765: ipFlag->status |= BINARY_FILE ;

766: 

767: if (ipFlag->verbose) {

768: 

769: if ((ipFlag->stdio_mode) && (!ipFlag->error)) ipFlag->error = 1;

770: 

771: d2u_fprintf(stderr, "%s: ", progname);

772: 

773: d2u_fprintf(stderr, _("Binary symbol 0x%02X found at line %u\n"),TempChar, line_nr);

774: 

775: }

776: 

777: break;

778: 

779: }

780: 

781: if (TempChar != '\x0d') {

782: 

783: if (TempChar == '\x0a') /* Count all DOS and Unix line breaks */

784: 

785: ++line_nr;

786: 

787: if (fputc(ConvTable[TempChar], ipOutF) == EOF) {

788: 

789: RetVal = -1;

790: 

791: d2u_putc_error(ipFlag,progname);

792: 

793: break;

794: 

795: }

796: 

797: } else {

798: 

799: if (StripDelimiter( ipInF, ipOutF, ipFlag, TempChar, &converted, progname) == EOF) {

800: 

801: RetVal = -1;

802: 

803: break;

804: 

805: }

806: 

807: }

808: 

809: }

810: 

811: if ((TempChar == EOF) && ferror(ipInF)) {

812: 

813: RetVal = -1;

814: 

815: d2u_getc_error(ipFlag,progname);

816: 

817: }

818: 

819: break;

820: 

821: case FROMTO_MAC2UNIX: /* mac2unix */

822: 

823: while ((TempChar = fgetc(ipInF)) != EOF) {

824: 

825: if ((ipFlag->Force == 0) &&

826: 

827: (TempChar < 32) &&

828: 

829: (TempChar != '\x0a') &&  /* Not an LF */

830: 

831: (TempChar != '\x0d') &&  /* Not a CR */

832: 

833: (TempChar != '\x09') &&  /* Not a TAB */

834: 

835: (TempChar != '\x0c')) {  /* Not a form feed */

836: 

837: RetVal = -1;

838: 

839: ipFlag->status |= BINARY_FILE ;

840: 

841: if (ipFlag->verbose) {

842: 

843: if ((ipFlag->stdio_mode) && (!ipFlag->error)) ipFlag->error = 1;

844: 

845: d2u_fprintf(stderr, "%s: ", progname);

846: 

847: d2u_fprintf(stderr, _("Binary symbol 0x%02X found at line %u\n"),TempChar, line_nr);

848: 

849: }

850: 

851: break;

852: 

853: }

854: 

855: if ((TempChar != '\x0d')) {

856: 

857: if (TempChar == '\x0a') /* Count all DOS and Unix line breaks */

858: 

859: ++line_nr;

860: 

861: if(fputc(ConvTable[TempChar], ipOutF) == EOF) {

862: 

863: RetVal = -1;

864: 

865: d2u_putc_error(ipFlag,progname);

866: 

867: break;

868: 

869: }

870: 

871: }

872: 

873: else{

874: 

875: /* TempChar is a CR */

876: 

877: if ( (TempNextChar = fgetc(ipInF)) != EOF) {

878: 

879: if (ungetc( TempNextChar, ipInF ) == EOF) {  /* put back peek char */

880: 

881: d2u_getc_error(ipFlag,progname);

882: 

883: RetVal = -1;

884: 

885: break;

886: 

887: }

888: 

889: /* Don't touch this delimiter if it's a CR,LF pair. */

890: 

891: if ( TempNextChar == '\x0a' ) {

892: 

893: if (fputc('\x0d', ipOutF) == EOF) { /* put CR, part of DOS CR-LF */

894: 

895: RetVal = -1;

896: 

897: d2u_putc_error(ipFlag,progname);

898: 

899: break;

900: 

901: }

902: 

903: continue;

904: 

905: }

906: 

907: }

908: 

909: if (fputc('\x0a', ipOutF) == EOF) { /* MAC line end (CR). Put LF */

910: 

911: RetVal = -1;

912: 

913: d2u_putc_error(ipFlag,progname);

914: 

915: break;

916: 

917: }

918: 

919: converted++;

920: 

921: line_nr++; /* Count all Mac line breaks */

922: 

923: if (ipFlag->NewLine) {  /* add additional LF? */

924: 

925: if (fputc('\x0a', ipOutF) == EOF) {

926: 

927: RetVal = -1;

928: 

929: d2u_putc_error(ipFlag,progname);

930: 

931: break;

932: 

933: }

934: 

935: }

936: 

937: }

938: 

939: }

940: 

941: if ((TempChar == EOF) && ferror(ipInF)) {

942: 

943: RetVal = -1;

944: 

945: d2u_getc_error(ipFlag,progname);

946: 

947: }

948: 

949: break;

950: 

951: default: /* unknown FromToMode */

952: 

953: ;

954: 

955: #if DEBUG

956: 

957: d2u_fprintf(stderr, "%s: ", progname);

958: 

959: d2u_fprintf(stderr, _("program error, invalid conversion mode %d\n"),ipFlag->FromToMode);

960: 

961: exit(1);

962: 

963: #endif

964: 

965: }

966: 

967: if ((RetVal == 0) && (ipFlag->verbose > 1)) {

968: 

969: d2u_fprintf(stderr, "%s: ", progname);

970: 

971: d2u_fprintf(stderr, _("Converted %u out of %u line breaks.\n"),converted, line_nr -1);

972: 

973: }

974: 

975: return RetVal;

976: 

977: }

978: 

979: 

980: 

981: int main (int argc, char *argv[])

982: 

983: {

984: 

985: /* variable declarations */

986: 

987: char progname[9];

988: 

989: CFlag *pFlag;

990: 

991: char *ptr;

992: 

993: char localedir[1024];

994: 

995: # ifdef __MINGW64__

996: 

997: int _dowildcard = -1; /* enable wildcard expansion for Win64 */

998: 

999: # endif

1000: 

1001: int  argc_new;

1002: 

1003: char **argv_new;

1004: 

1005: 

1006: progname[8] = '\0';

1007: 

1008: strcpy(progname,"dos2unix");

1009: 

1010: 

1011: #ifdef ENABLE_NLS

1012: 

1013: ptr = getenv("DOS2UNIX_LOCALEDIR");

1014: 

1015: if (ptr == NULL)

1016: 

1017: strcpy(localedir,LOCALEDIR);

1018: 

1019: else {

1020: 

1021: if (strlen(ptr) < sizeof(localedir))

1022: 

1023: strcpy(localedir,ptr);

1024: 

1025: else {

1026: 

1027: d2u_fprintf(stderr,"%s: ",progname);

1028: 

1029: d2u_ansi_fprintf(stderr, "%s", _("error: Value of environment variable DOS2UNIX_LOCALEDIR is too long.\n"));

1030: 

1031: strcpy(localedir,LOCALEDIR);

1032: 

1033: }

1034: 

1035: }

1036: 

1037: #endif

1038: 

1039: 

1040: #if defined(ENABLE_NLS) || (defined(D2U_UNICODE) && !defined(__MSDOS__) && !defined(_WIN32) && !defined(__OS2__))

1041: 

1042: /* setlocale() is also needed for nl_langinfo() */

1043: 

1044: setlocale (LC_ALL, "");

1045: 

1046: #endif

1047: 

1048: 

1049: #ifdef ENABLE_NLS

1050: 

1051: bindtextdomain (PACKAGE, localedir);

1052: 

1053: textdomain (PACKAGE);

1054: 

1055: #endif

1056: 

1057: 

1058: 

1059: /* variable initialisations */

1060: 

1061: pFlag = (CFlag*)malloc(sizeof(CFlag));

1062: 

1063: if (pFlag == NULL) {

1064: 

1065: d2u_fprintf(stderr, "dos2unix:");

1066: 

1067: d2u_ansi_fprintf(stderr, " %s\n", strerror(errno));

1068: 

1069: return errno;

1070: 

1071: }

1072: 

1073: pFlag->FromToMode = FROMTO_DOS2UNIX;  /* default dos2unix */

1074: 

1075: pFlag->keep_bom = 0;

1076: 

1077: 

1078: if ( ((ptr=strrchr(argv[0],'/')) == NULL) && ((ptr=strrchr(argv[0],'\\')) == NULL) )

1079: 

1080: ptr = argv[0];

1081: 

1082: else

1083: 

1084: ptr++;

1085: 

1086: 

1087: if ((strcmpi("mac2unix", ptr) == 0) || (strcmpi("mac2unix.exe", ptr) == 0)) {

1088: 

1089: pFlag->FromToMode = FROMTO_MAC2UNIX;

1090: 

1091: strcpy(progname,"mac2unix");

1092: 

1093: }

1094: 

1095: 

1096: #ifdef D2U_UNIFILE

1097: 

1098: /* Get arguments in wide Unicode format in the Windows Command Prompt */

1099: 

1100: wchar_t **wargv;

1101: 

1102: char ***argv_glob;

1103: 

1104: 

1105: /* This does not support wildcard expansion (globbing) */

1106: 

1107: wargv = CommandLineToArgvW(GetCommandLineW(), &argc);

1108: 

1109: 

1110: argv_glob = (char ***)malloc(sizeof(char***));

1111: 

1112: if (argv_glob == NULL) {

1113: 

1114: d2u_fprintf(stderr, "%s:", progname);

1115: 

1116: d2u_ansi_fprintf(stderr, " %s\n", strerror(errno));

1117: 

1118: return errno;

1119: 

1120: }

1121: 

1122: /* Glob the arguments and convert them to UTF-8 */

1123: 

1124: argc_new = glob_warg(argc, wargv, argv_glob, pFlag, progname);

1125: 

1126: argv_new = *argv_glob;

1127: 

1128: #else 

1129: 

1130: argc_new = argc;

1131: 

1132: argv_new = argv;

1133: 

1134: #endif

1135: 

1136: 

1137: #ifdef D2U_UNICODE

1138: 

1139: return parse_options(argc_new, argv_new, pFlag, localedir, progname, PrintLicense, ConvertDosToUnix, ConvertDosToUnixW);

1140: 

1141: #else

1142: 

1143: return parse_options(argc_new, argv_new, pFlag, localedir, progname, PrintLicense, ConvertDosToUnix);

1144: 

1145: #endif

1146: 

1147: }

1148: 


作者：潇湘隐者
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 点击这里给我发消息
标签： 
相关文章推荐
新的分享
章节导航