![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to stdargv.asm CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [OS/2 SDKs] / os2sdk / startup / dos|
Return to stdargv.asm CVS log | Up to [OS/2 SDKs] / os2sdk / startup / dos |
1.1 ! root 1: page ,132 ! 2: TITLE stdargv - standard & wildcard _setargv routine ! 3: ;*** ! 4: ;stdargv.asm - standard & wildcard _setargv routine ! 5: ; ! 6: ; Copyright (c) 1985-1987, Microsoft Corporation. All rights reserved. ! 7: ; ! 8: ;Purpose: ! 9: ; processes program command line, with or without wildcard expansion ! 10: ; ! 11: ;******************************************************************************* ! 12: ! 13: ! 14: ifdef WILDCARD ! 15: name _setargv ; wildcard _setargv routine ! 16: else ! 17: name stdargv ; standard _setargv routine ! 18: endif ! 19: ! 20: ifdef WILDCARD ! 21: ?DF = 1 ; tell cmacros.inc we want to define our own segments ! 22: endif ! 23: ! 24: include version.inc ! 25: .xlist ! 26: include cmacros.inc ! 27: include msdos.inc ! 28: .list ! 29: ! 30: ifdef WILDCARD ; ********************************************** ! 31: ! 32: createSeg _TEXT, code, word, public, CODE, <> ! 33: createSeg _DATA, data, word, public, DATA, DGROUP ! 34: ! 35: createSeg HDR, nhdr, byte, public, MSG, DGROUP ! 36: createSeg MSG, nmsg, byte, public, MSG, DGROUP ! 37: createSeg PAD, npad, byte, common, MSG, DGROUP ! 38: createSeg EPAD, nepad, byte, common, MSG, DGROUP ! 39: ! 40: defGrp DGROUP ; define DGROUP ! 41: ! 42: dataOFFSET equ offset DGROUP: ! 43: ! 44: ; Message used by ___setargv (wildcard version of __setargv) ! 45: ! 46: sBegin nmsg ! 47: assumes ds,data ! 48: dw 8 ! 49: db 'R6008',13,10,'- not enough space for arguments',13,10,0 ! 50: sEnd ! 51: ! 52: sBegin npad ! 53: assumes ds,data ! 54: dw -1 ! 55: ; no padding for now; ! 56: ; MAX padding would be ! 57: ; db 25 dup(0) ! 58: sEnd ! 59: ! 60: ! 61: externP _cwild ; Wildcard Expander ! 62: externNP _amsg_exit ; error handler (unable to allocate) ! 63: ! 64: endif ; WILDCARD ; ********************************************** ! 65: ! 66: ! 67: sBegin data ! 68: assumes ds,data ! 69: ! 70: ifdef _QC ; [1] ! 71: extrn __QCrtcsip:DWORD ; [1] ! 72: endif ;_QC ; [1] ! 73: ! 74: C_CR equ 0DH ; ASCII carriage return ! 75: ! 76: C_BLANK equ ' ' ; ASCII space character ! 77: C_TAB equ 09h ; ASCII horizontal tab character ! 78: ! 79: C_QUOTE equ '"' ; ASCII (double) Quote Charater ! 80: C_BACKSLASH equ '\' ; ASCII backward slash character ! 81: ! 82: externDP __argv ; argument string array address ! 83: externW __argc ; count of argument strings ! 84: externW _psp ; address of Program Segment Prefix ! 85: externB _osmajor ; address of DOS version (major part) ! 86: externD _pgmptr ; far ptr to name of program ! 87: ! 88: staticCP retadr,0 ; return address ! 89: ! 90: ! 91: ifdef WILDCARD ; ********************************************** ! 92: ! 93: dta_flag db 0 ; Has DMA been set yet? ! 94: ! 95: file_reserv db 21 dup (0) ! 96: file_attrib db 0 ! 97: file_time dw 0 ! 98: file_date dw 0 ! 99: file_sizel dw 0 ! 100: file_sizeh dw 0 ! 101: file_name db 13 dup (0) ! 102: ! 103: endif ; WILDCARD ; ********************************************** ! 104: ! 105: sEnd ! 106: ! 107: ; **************************************** ! 108: ! 109: jmps MACRO target ! 110: jmp short target ! 111: ENDM ! 112: ! 113: lje MACRO target ! 114: LOCAL temp ! 115: jne temp ! 116: jmp target ! 117: temp: ! 118: ENDM ! 119: ! 120: ifdef IBMC20 ! 121: ! 122: DELIM MACRO target ! 123: cmp al,C_CR ;; Test for end-of-line character ! 124: je target ! 125: ENDM ! 126: ! 127: LDELIM MACRO target ! 128: cmp al,C_CR ;; Test for end-of-line character ! 129: lje target ! 130: ENDM ! 131: ! 132: else ; IBMC20 ! 133: ! 134: DELIM MACRO target ! 135: cmp al,C_CR ;; Test for end-of-line character ! 136: je target ! 137: or al,al ;; Either Carriage Return or Null ! 138: je target ! 139: ENDM ! 140: ! 141: LDELIM MACRO target ! 142: cmp al,C_CR ;; Test for end-of-line character ! 143: lje target ! 144: or al,al ;; Either Carriage Return or Null ! 145: lje target ! 146: ENDM ! 147: ! 148: endif ; IBMC20 ! 149: ! 150: ; **************************************** ! 151: ! 152: sBegin code ! 153: ! 154: assumes ds,data ! 155: assumes ss,data ! 156: assumes cs,code ! 157: ! 158: page ! 159: ;*** ! 160: ;_setargv, __setargv - set up "argc" and "argv" for C programs ! 161: ; ! 162: ;Purpose: ! 163: ; Gets the command line from the PSP and moves the information ! 164: ; to its place on the stack. ! 165: ; ! 166: ; SIDE EFFECTS: ! 167: ; Allocates space on the stack for the argument strings ! 168: ; and a list of pointers to them. ! 169: ; ASSUMPTIONS: ! 170: ; Under DOS 2, there is no argv[0] string, so "C" is used. ! 171: ; Under DOS 3 and later, the argv[0] string is found in the ! 172: ; environment segment, after the double null that terminates ! 173: ; that segment and after a word of value 1. The rest of the ! 174: ; command line is found in the Program Segment Prefix at ! 175: ; offset 81H, and is terminated by a 0DH. This command "tail" ! 176: ; cannot be greater than 126 bytes in length. ! 177: ; ! 178: ; Quote marks and backslashes are treated specially. A quoted ! 179: ; string is passed as a single argument, not including the ! 180: ; opening and closing quote characters. A quote may be imbedded ! 181: ; in a string by placing an odd number of backslashes (`\') ! 182: ; before it. Each pair of backslashes which precedes a quote ! 183: ; results in a single backslash in the resultant string. ! 184: ; An even number of backslashes followed by a quote results in ! 185: ; half that many backslashes, and the quote begins or ends the ! 186: ; quoted part of the string as is appropriate. Backslashes not ! 187: ; followed by a quote are treated normally. ! 188: ; ! 189: ; [""] ==> [] ! 190: ; [\"] ==> ["] ! 191: ; [" \" "] == [ " ] ! 192: ; [" \\"] == [ \] ! 193: ; [" \\ "] == [ \\ ] ! 194: ; [" \\\" "] == [ \" ] ! 195: ; etc. ! 196: ; ["one two three"] ==> [one two three] ! 197: ; [one" two "three] ==> [one two three] ! 198: ; [o"ne two t"hree] ==> [one two three] ! 199: ; ["one \"two\" three"] ==> [one "two" three] ! 200: ; ["x\\\"x"] ==> [x\"x] ! 201: ; ! 202: ;Entry: ! 203: ; ! 204: ;Exit: ! 205: ; "argv" points to a null-terminated list of pointers to ASCIZ ! 206: ; strings, each of which is an argument from the command line. ! 207: ; "argc" is the number of arguments. The strings are copied from ! 208: ; the Program Segment Prefix into space allocated on the stack. ! 209: ; The list of pointers is also located on the stack. ! 210: ; ! 211: ;Uses: ! 212: ; All registers except DS, SS, and BP are modified ! 213: ; Note especially that SI and DI are NOT preserved! ! 214: ; ! 215: ;Exceptions: ! 216: ; ! 217: ;******************************************************************************* ! 218: ! 219: ifdef WILDCARD ; ********************************************** ! 220: ! 221: labelP <PUBLIC,__setargv> ! 222: ! 223: else ; ********************************************** ! 224: ! 225: labelP <PUBLIC,_setargv> ! 226: ! 227: endif ; WILDCARD ; ********************************************** ! 228: ! 229: pop word ptr [retadr] ; get return address (offset) ! 230: if sizeC ! 231: pop word ptr [retadr+2] ; get return address (segment) ! 232: endif ! 233: mov dx,2 ! 234: cmp byte ptr [_osmajor],dl ; 2 bytes if DOS version = 2.X ! 235: je dos_two ! 236: ! 237: mov es,_psp ! 238: mov es,es:[DOS_envp] ; get environment segment ! 239: mov word ptr [_pgmptr+2],es ; set global variable "_pgmptr" ! 240: xor ax,ax ! 241: cwd ; DX=0 ! 242: mov cx,8000H ! 243: xor di,di ; scan from beginning of environment ! 244: find_env_end: ! 245: repne scasb ! 246: scasb ! 247: jne find_env_end ! 248: ; ! 249: inc di ; skip count word (always 0x0001) ! 250: inc di ! 251: mov word ptr [_pgmptr],di ; set global variable "_pgmptr" ! 252: mov cx,-1 ! 253: repne scasb ! 254: not cx ! 255: mov dx,cx ; DX=number of bytes in argv[0] ! 256: dos_two: ! 257: mov di,1 ; always start with one argument ! 258: mov si,81H ! 259: mov ds,_psp ! 260: assumes ds,nothing ! 261: ;* ! 262: ;* Count the command tail arguments ! 263: ;* ! 264: ; ! 265: ; DI will count the number of arguments ! 266: ; DX will count the number of bytes needed for the arguments ! 267: ; (not including the null terminators) ! 268: ; ! 269: arg100: ! 270: arg110: ! 271: lodsb ! 272: cmp al,C_BLANK ! 273: je arg110 ! 274: cmp al,C_TAB ! 275: je arg110 ! 276: ! 277: DELIM arg400 ! 278: ! 279: inc di ; Another argument ! 280: ; ! 281: ; Parse an argument ! 282: ; ! 283: arg200: ! 284: dec si ; back up to reload character ! 285: arg210: ! 286: lodsb ! 287: ! 288: cmp al,C_BLANK ! 289: je arg100 ! 290: cmp al,C_TAB ! 291: je arg100 ; white space terminates argument ! 292: ! 293: DELIM arg400 ! 294: ! 295: cmp al,C_QUOTE ! 296: je arg310 ! 297: ! 298: cmp al,C_BACKSLASH ! 299: je arg220 ! 300: ! 301: inc dx ! 302: jmps arg210 ! 303: ; ! 304: ; Count backslashes ! 305: ; ! 306: arg220: ! 307: xor cx,cx ! 308: arg221: ! 309: inc cx ; CX counts the backslashes ! 310: lodsb ! 311: cmp al,C_BACKSLASH ! 312: je arg221 ! 313: ; ! 314: cmp al,C_QUOTE ! 315: je arg230 ! 316: ! 317: add dx,cx ; not followed by `"' -- treat `\'s normally ! 318: jmp arg200 ! 319: ; ! 320: arg230: ! 321: mov ax,cx ! 322: shr cx,1 ! 323: adc dx,cx ; add 1 for every pair of backslashes ! 324: test al,1 ; plus 1 for the " if odd number of \ ! 325: jnz arg210 ; " was escaped with a \ ! 326: jmps arg310 ; " opens a quoted substring ! 327: ; ! 328: ; Enter a quoted string ! 329: ; ! 330: arg300: ! 331: dec si ; back up to reload character ! 332: arg310: ! 333: lodsb ! 334: ! 335: DELIM arg400 ! 336: ! 337: cmp al,C_QUOTE ! 338: je arg210 ; end of quoted portion of string ! 339: ! 340: cmp al,C_BACKSLASH ! 341: je arg320 ! 342: ! 343: inc dx ! 344: jmp arg310 ! 345: ; ! 346: ; Count backslashes ! 347: ; ! 348: arg320: ! 349: xor cx,cx ! 350: arg321: ! 351: inc cx ; CX counts the backslashes ! 352: lodsb ! 353: cmp al,C_BACKSLASH ! 354: je arg321 ! 355: ; ! 356: cmp al,C_QUOTE ! 357: je arg330 ! 358: ! 359: add dx,cx ; not followed by `"' -- treat `\'s normally ! 360: jmp arg300 ! 361: ; ! 362: arg330: ! 363: mov ax,cx ! 364: shr cx,1 ! 365: adc dx,cx ; add 1 for every pair of backslashes ! 366: test al,1 ; plus 1 for the " if odd number of \ ! 367: jnz arg310 ; " was escaped with a \ ! 368: jmps arg210 ; " closes a quoted substring ! 369: ; ! 370: ; Command line is fully parsed - compute number of bytes needed ! 371: ; ! 372: arg400: ! 373: ; ! 374: ; Number of bytes needed = ! 375: ; Number of bytes used to make strings + ! 376: ; Number of bytes used to terminate strings + ! 377: ; sizeof(DATAPTR) * ( number of arguments + 1 ) ! 378: ; ! 379: push ss ! 380: pop ds ; Restore DS = DGROUP ! 381: assumes ds,data ! 382: ! 383: mov __argc,di ; Store number of arguments ! 384: ! 385: add dx,di ; add in terminator bytes ! 386: ifdef WILDCARD ! 387: add dx,di ; add in Wildcard flag bytes ! 388: endif ! 389: inc di ; add one for NULL pointer ! 390: shl di,1 ! 391: if sizeD ! 392: shl di,1 ! 393: endif ! 394: add dx,di ; add space for pointers to space for chars ! 395: ! 396: and dl,not 1 ; Round up to an even number of bytes ! 397: ; ! 398: ; Allocate space on the stack ! 399: ; ! 400: ; DX is the total number of bytes needed for strings and pointers ! 401: ; DI is the number of bytes needed for the pointers ! 402: ; ! 403: sub sp,dx ! 404: mov ax,sp ! 405: ! 406: mov word ptr (__argv),ax ! 407: if sizeD ! 408: mov word ptr (__argv+2),ds ! 409: endif ! 410: ; ! 411: ; Copy argument strings and addresses onto heap/stack ! 412: ; Address table is on the top, strings below that ! 413: ; ! 414: mov bx,ax ! 415: add di,bx ! 416: ! 417: push ss ; ES=SS ! 418: pop es ; ES:DI is where the string copies will go ! 419: assumes es,data ! 420: ; ! 421: ; DS:SI points to the argv[0] ! 422: ; ! 423: ; ES:BX points to where argv[0],argv[1],argv[2],... go ! 424: ; ES:DI points to where *argv[0],*argv[1],*argv[2],... go ! 425: ; For wildcard version only: ! 426: ; ES:DX points to the wildcard flag character (prepended to argument) ! 427: ; during the creation of each argument ! 428: ; ! 429: mov ss:[bx],di ; argv[i] - offset part ! 430: if sizeD ! 431: mov ss:[bx+2],ss ; argv[i] - segment part ! 432: add bx,4 ! 433: else ! 434: inc bx ! 435: inc bx ! 436: endif ! 437: ! 438: lds si,[_pgmptr] ; copy argv[0], either fake or from env seg ! 439: assumes ds,nothing ! 440: ! 441: ifdef WILDCARD ! 442: movsb ! 443: dec si ; copy first character as quote flag ! 444: endif ! 445: ! 446: copy_argv0: ! 447: lodsb ! 448: stosb ! 449: or al,al ! 450: jnz copy_argv0 ! 451: ; ! 452: ; DS:SI points to the raw command tail string ! 453: ; ! 454: mov si,81H ; address of strings ! 455: mov ds,ss:[_psp] ; DS:SI is where the source strings are ! 456: assumes ds,nothing ! 457: ! 458: jmps arg510 ! 459: ; ! 460: ; Skip blanks ! 461: ; ! 462: arg500: ! 463: xor ax,ax ! 464: stosb ! 465: arg510: ! 466: lodsb ! 467: cmp al,C_BLANK ! 468: je arg510 ! 469: cmp al,C_TAB ! 470: je arg510 ! 471: ! 472: LDELIM arg810 ! 473: ! 474: mov ss:[bx],di ! 475: if sizeD ! 476: mov ss:[bx+2],ss ! 477: add bx,4 ! 478: else ! 479: inc bx ! 480: inc bx ! 481: endif ! 482: ! 483: ifdef WILDCARD ! 484: mov dx,di ! 485: stosb ; initialize wildcard flag ! 486: endif ! 487: ; ! 488: ; ! 489: ; Parse an argument ! 490: ; ! 491: arg600: ! 492: dec si ; back up to reload character ! 493: arg610: ! 494: lodsb ! 495: ! 496: cmp al,C_BLANK ! 497: je arg500 ! 498: cmp al,C_TAB ! 499: je arg500 ; white space terminates argument ! 500: ! 501: DELIM arg800 ! 502: ! 503: cmp al,C_QUOTE ! 504: je arg710x ! 505: ! 506: cmp al,C_BACKSLASH ! 507: je arg620 ! 508: ! 509: stosb ! 510: jmps arg610 ! 511: ; ! 512: ; Count backslashes ! 513: ; ! 514: arg620: ! 515: xor cx,cx ! 516: arg621: ! 517: inc cx ; CX counts the backslashes ! 518: lodsb ! 519: cmp al,C_BACKSLASH ! 520: je arg621 ! 521: ; ! 522: cmp al,C_QUOTE ! 523: je arg630 ! 524: ! 525: mov al,C_BACKSLASH ! 526: rep stosb ; not followed by `"' -- treat `\'s normally ! 527: jmp arg600 ! 528: ; ! 529: arg630: ! 530: mov al,C_BACKSLASH ! 531: shr cx,1 ! 532: rep stosb ! 533: jnc arg710x ; " opens a quoted substring ! 534: mov al,C_QUOTE ! 535: stosb ! 536: jmp arg610 ; " was escaped with a \ ! 537: ; ! 538: ; Enter a quoted string ! 539: ; ! 540: ifdef WILDCARD ! 541: arg710x: ! 542: inc si ; undoes the "DEC SI" between arg700 and arg710 ! 543: endif ! 544: ! 545: arg700x: ! 546: ! 547: ifdef WILDCARD ! 548: xchg dx,di ; set the wildcard flag character to `"' ! 549: mov al,C_QUOTE ! 550: stosb ! 551: dec di ! 552: xchg dx,di ! 553: endif ! 554: ! 555: arg700: ! 556: dec si ; back up to reload character ! 557: ! 558: ifndef WILDCARD ! 559: arg710x: ! 560: endif ! 561: ! 562: arg710: ! 563: lodsb ! 564: ! 565: DELIM arg800 ! 566: ! 567: cmp al,C_QUOTE ! 568: je arg610 ; end of quoted portion of string ! 569: ! 570: cmp al,C_BACKSLASH ! 571: je arg720 ! 572: ! 573: stosb ! 574: jmp arg710 ! 575: ; ! 576: ; Count backslashes ! 577: ; ! 578: arg720: ! 579: xor cx,cx ! 580: arg721: ! 581: inc cx ; CX counts the backslashes ! 582: lodsb ! 583: cmp al,C_BACKSLASH ! 584: je arg721 ! 585: ; ! 586: cmp al,C_QUOTE ! 587: je arg730 ! 588: ! 589: mov al,C_BACKSLASH ! 590: rep stosb ; not followed by `"' -- treat `\'s normally ! 591: jmp arg700x ! 592: ; ! 593: arg730: ! 594: mov al,C_BACKSLASH ! 595: shr cx,1 ! 596: rep stosb ; store 1 for every pair of backslashes ! 597: jnc arg610 ; " closes a quoted substring ! 598: mov al,C_QUOTE ; " was escaped with a \ ! 599: stosb ! 600: jmps arg710x ! 601: ; ! 602: ; Terminate last argument string, terminate list of argument pointers ! 603: ; ! 604: arg800: ! 605: xor ax,ax ! 606: stosb ; null-terminate final argument ! 607: arg810: ! 608: push ss ! 609: pop ds ! 610: assumes ds,data ! 611: ! 612: mov word ptr [bx],0 ; add null pointer to __argv[] ! 613: if sizeD ! 614: mov word ptr [bx+2],0 ! 615: endif ! 616: ! 617: ifndef WILDCARD ! 618: jmp [retadr] ; THE END ! 619: else ! 620: call _cwild ! 621: test ax,ax ! 622: jz no_arg_err ! 623: ! 624: ifdef _QC ; [1] ! 625: mov ds,cs:[$F_PSP] ;[2] get PSP ! 626: mov ax,ds:[PSP_DGROUP_SEG] ;[2] get DGROUP ! 627: mov ds, ax ;[2] ds = DGROUP ! 628: ! 629: mov ax, word ptr [retadr] ; [1] Offset... ! 630: mov word ptr [__QCrtcsip], ax ; [1] ...save ! 631: if sizeC ! 632: mov ax, word ptr [retadr+2] ; [1] Segment... ! 633: mov word ptr [__QCrtcsip+2], ax ; [1] ...save ! 634: else ; [1] ! 635: mov word ptr [__QCrtcsip+2], cs ; [1] (Near call) ! 636: endif ; [1] ! 637: endif ;_QC ; [1] (_QC) ! 638: ! 639: mov ax,8 ! 640: jmp _amsg_exit ; ! 641: ! 642: no_arg_err: ! 643: jmp [retadr] ! 644: ! 645: page ! 646: ;*** ! 647: ;_find(dir) - find first matching file name against pattern "dir" ! 648: ; ! 649: ;Purpose: ! 650: ; _find(dir) - Find first matching file name against pattern "dir" ! 651: ; If dir == NULL, then get next match for current pattern. ! 652: ; ! 653: ;Entry: ! 654: ; dir = DATA PTR of pattern to match ! 655: ; ! 656: ;Exit: ! 657: ; AX = the address of a static area containing the file name if a ! 658: ; match was found. Returns NULL if no match was found. ! 659: ; ! 660: ;Uses: ! 661: ; CX,DX, [dta_flag]. ! 662: ; ! 663: ;Exceptions: ! 664: ; ! 665: ;******************************************************************************* ! 666: ! 667: cProc _find,<PUBLIC> ! 668: parmdp dir ! 669: cBegin ! 670: test [dta_flag],-1 ! 671: jnz not_very_first ! 672: ! 673: mov [dta_flag],-1 ! 674: ; ! 675: ; Set DTA, where the match structure is returned ! 676: ; ! 677: mov dx,dataOFFSET file_reserv ! 678: callos setdma ! 679: ; ! 680: not_very_first: ! 681: mov ah,DOS_findnext ; assume not first ! 682: ! 683: if sizeD ! 684: push ds ! 685: lds dx,dir ! 686: mov cx,ds ! 687: jcxz find_next ! 688: else ! 689: mov dx,dir ! 690: test dx,dx ! 691: jz find_next ! 692: endif ! 693: mov cx,A_D ; match directories as well as files ! 694: mov ah,DOS_findfirst ! 695: find_next: ! 696: callos ! 697: if sizeD ! 698: pop ds ! 699: endif ! 700: mov ax,dataOFFSET file_name ! 701: if sizeD ! 702: mov dx,ds ! 703: endif ! 704: jnc retname ! 705: ! 706: xor ax,ax ; return 0 for no more matches ! 707: if sizeD ! 708: cwd ! 709: endif ! 710: ! 711: retname: ! 712: ! 713: cEnd ! 714: ! 715: endif ; WILDCARD ; *********************************************** ! 716: ! 717: sEnd code ! 718: ! 719: end
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.