![[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 / os2|
Return to stdargv.asm CVS log | Up to [OS/2 SDKs] / os2sdk / startup / os2 |
1.1 root 1: TITLE stdargv.asm - OS/2 standard & wildcard _setargv routine
2: ;***
3: ;5stdargv.asm - OS/2 standard & wildcard _setargv routine
4: ;
5: ; Copyright (c) 1985-1987, Microsoft Corporation. All rights reserved.
6: ;
7: ;Purpose:
8: ; processes program command line, with or without wildcard expansion
9: ;
10: ;*******************************************************************************
11:
12: ifdef WILDCARD
13: name _setargv ; wildcard _setargv routine
14: else
15: name stdargv ; standard _setargv routine
16: endif
17:
18: include version.inc
19: .xlist
20: include cmacros.inc
21: include msdos.inc
22: .list
23:
24: sBegin data
25: assumes ds,data
26:
27: C_BLANK equ ' ' ; ASCII space character
28: C_TAB equ 09h ; ASCII horizontal tab character
29:
30: C_QUOTE equ '"' ; ASCII (double) Quote Charater
31: C_BACKSLASH equ '\' ; ASCII backward slash character
32:
33: externDP __argv ; argument string array address
34: externW __argc ; count of argument strings
35: externW _aenvseg ; environment segment
36: externW _acmdln ; offset of command line in env. seg.
37: externD _pgmptr ; far pointer to program name
38:
39: staticW cmdstart,0 ; start of command line string
40: staticCP retadr,0 ; return address
41:
42: ifdef WILDCARD
43:
44: staticW findhandle,1 ; handle used for wildcard matching
45:
46: FileFindBuf struc
47: create_date dw ? ;* date of file creation
48: create_time dw ? ;* time of file creation
49: access_date dw ? ;* date of last access
50: access_time dw ? ;* time of last access
51: write_date dw ? ;* date of last write
52: write_time dw ? ;* time of last write
53: file_size dd ? ;* file size (end of data)
54: falloc_size dd ? ;* file allocated size
55: attributes dw ? ;* attributes of the file
56: string_len db ? ;* returned length of ascii name str.
57: file_name db 13 dup (?) ;* name string
58: FileFindBuf ends
59:
60: findbuf FileFindBuf <> ;* struct FileFindBuf findbuf;
61:
62: endif ; WILDCARD
63:
64: sEnd data
65:
66: ;=========================================
67:
68: ifdef WILDCARD
69: extrn DOSFINDFIRST:far
70: extrn DOSFINDNEXT:far
71: externP _cwild ; Wildcard Expander
72: endif
73:
74: ;=========================================
75:
76: jmps MACRO target
77: jmp short target
78: ENDM
79:
80: lje MACRO target
81: LOCAL temp
82: jne temp
83: jmp target
84: temp:
85: ENDM
86:
87: DELIM MACRO
88: or al,al ;; Test for end-of-line character (null)
89: ENDM
90:
91: ;=========================================
92:
93:
94: sBegin code
95:
96: externNP _stdalloc ; routine to allocate heap memory
97: externNP _amsg_exit ; error handler (unable to allocate)
98:
99: assumes ds,data
100: assumes ss,data
101: assumes cs,code
102:
103: page
104: ;***
105: ;_setargv, __setargv - set up "argc" and "argv" for C programs
106: ;
107: ;Purpose:
108: ; Read the command line and create the argv array for C
109: ; programs.
110: ;
111: ;Entry:
112: ; Arguments are retrieved from the program command line.
113: ;
114: ;Exit:
115: ; "argv" points to a null-terminated list of pointers to ASCIZ
116: ; strings, each of which is an argument from the command line.
117: ; "argc" is the number of arguments. The strings are copied from
118: ; the environment segment into space allocated on the heap/stack.
119: ; The list of pointers is also located on the heap or stack.
120: ;
121: ;Uses:
122: ;
123: ;Exceptions:
124: ;
125: ;*******************************************************************************
126:
127:
128: ifdef WILDCARD ; **********************************************
129:
130: labelP <PUBLIC,__setargv>
131:
132: else ; **********************************************
133:
134: labelP <PUBLIC,_setargv>
135:
136: endif ; WILDCARD ; **********************************************
137:
138: pop word ptr [retadr] ; get return address (offset)
139:
140: if sizeC
141: pop word ptr [retadr+2] ; get return address (segment)
142: endif
143: mov ax,_acmdln
144: mov ds,_aenvseg
145: assumes ds,nothing
146:
147: mov si,ax
148: ;
149: ; If there is no argument string, use the
150: ; program name for the command line string.
151: ; Scan back for the null before "PgmPtr"
152: ;
153: find_argv0:
154: dec si
155: jz found_argv0
156: cmp byte ptr ds:[si-1],0
157: jne find_argv0
158: found_argv0:
159: mov word ptr [_pgmptr],si
160: mov word ptr [_pgmptr+2],ds
161: xchg ax,si ; restore SI to [_acmdln]
162: test byte ptr ds:[si],-1
163: jnz store_cmdstart
164: xchg ax,si ; use PgmPtr instead of ArgPtr
165: store_cmdstart:
166: mov [cmdstart],si
167:
168: xor dx,dx ; Start with zero bytes
169: mov di,1 ; Start with one arguments
170: count_argv0:
171: lodsb
172: inc dx ; count each byte in argv[0]
173: or al,al ; including the terminator
174: jnz count_argv0
175: ;*
176: ;* Count the command line arguments
177: ;*
178: ;* ... previous environment strings ...
179: ;* null byte (end of last environment string)
180: ;* null byte (end of environment)
181: ;* program name string
182: ;* null byte
183: ;* DS:SI ==> raw command line string
184: ;* null byte
185: ;* null byte
186: ;*
187: ;* DI will count the number of arguments
188: ;*
189: ;* DX will count the number of bytes needed to
190: ;* store the arguments themselves, incl. final nulls
191: ;*
192: ;*
193: ;* Count the command tail arguments
194: ;*
195: ;
196: ; DI will count the number of arguments
197: ; DX will count the number of bytes needed for the arguments
198: ; (not including the null terminators)
199: ;
200: arg100:
201: arg110:
202: lodsb
203: cmp al,C_BLANK
204: je arg110
205: cmp al,C_TAB
206: je arg110
207:
208: DELIM
209: je arg400
210:
211: inc di ; Another argument
212: ;
213: ; Parse an argument
214: ;
215: arg200:
216: dec si ; back up to reload character
217: arg210:
218: lodsb
219:
220: cmp al,C_BLANK
221: je arg100
222: cmp al,C_TAB
223: je arg100 ; white space terminates argument
224:
225: DELIM
226: je arg400
227:
228: cmp al,C_QUOTE
229: je arg310
230:
231: cmp al,C_BACKSLASH
232: je arg220
233:
234: inc dx
235: jmps arg210
236: ;
237: ; Count backslashes
238: ;
239: arg220:
240: xor cx,cx
241: arg221:
242: inc cx ; CX counts the backslashes
243: lodsb
244: cmp al,C_BACKSLASH
245: je arg221
246: ;
247: cmp al,C_QUOTE
248: je arg230
249:
250: add dx,cx ; not followed by `"' -- treat `\'s normally
251: jmp arg200
252: ;
253: arg230:
254: mov ax,cx
255: shr cx,1
256: adc dx,cx ; add 1 for every pair of backslashes
257: test al,1 ; plus 1 for the " if odd number of \
258: jnz arg210 ; " was escaped with a \
259: jmps arg310 ; " opens a quoted substring
260: ;
261: ; Enter a quoted string
262: ;
263: arg300:
264: dec si ; back up to reload character
265: arg310:
266: lodsb
267:
268: DELIM
269: je arg400
270:
271: cmp al,C_QUOTE
272: je arg210 ; end of quoted portion of string
273:
274: cmp al,C_BACKSLASH
275: je arg320
276:
277: inc dx
278: jmp arg310
279: ;
280: ; Count backslashes
281: ;
282: arg320:
283: xor cx,cx
284: arg321:
285: inc cx ; CX counts the backslashes
286: lodsb
287: cmp al,C_BACKSLASH
288: je arg321
289: ;
290: cmp al,C_QUOTE
291: je arg330
292:
293: add dx,cx ; not followed by `"' -- treat `\'s normally
294: jmp arg300
295: ;
296: arg330:
297: mov ax,cx
298: shr cx,1
299: adc dx,cx ; add 1 for every pair of backslashes
300: test al,1 ; plus 1 for the " if odd number of \
301: jnz arg310 ; " was escaped with a \
302: jmps arg210 ; " closes a quoted substring
303: ;
304: ; Command line is fully parsed - compute number of bytes needed
305: ;
306: arg400:
307: ;
308: ; Number of bytes needed =
309: ; Number of bytes used to make strings +
310: ; Number of bytes used to terminate strings +
311: ; sizeof(DATAPTR) * ( number of arguments + 1 )
312: ;
313: push ss
314: pop ds ; Restore DS = DGROUP
315: assumes ds,data
316:
317: mov __argc,di ; Store number of arguments
318:
319: add dx,di ; add in terminator bytes
320: ifdef WILDCARD
321: add dx,di ; add in Wildcard flag bytes
322: endif
323: inc di ; add one for NULL pointer
324: shl di,1
325: if sizeD
326: shl di,1
327: endif
328: mov ax,di
329: add ax,dx ; add space for pointers to space for chars
330:
331: and al,not 1 ; Round up to an even number of bytes
332: ;
333: ; Allocate space on the heap (or the stack)
334: ;
335: ; AX is the total number of bytes needed for strings and pointers
336: ; DI is the number of bytes needed for the pointers
337: ;
338: call _stdalloc
339: jnc args_ok
340: arg_error:
341: mov ax,8 ;Out of heap/stack space.
342: jmp _amsg_exit
343:
344: args_ok:
345: mov word ptr (__argv),ax
346: if sizeD
347: mov word ptr (__argv+2),ds
348: endif
349: ;
350: ; Copy argument strings and addresses onto heap/stack
351: ; Address table is on the top, strings below that
352: ;
353: mov bx,ax
354: add di,ax
355:
356: push ss ; ES=SS
357: pop es ; ES:DI is where the string copies will go
358: assumes es,data
359: ;
360: ; DS:SI points to the argv[0]
361: ;
362: ; ES:BX points to where argv[0],argv[1],argv[2],... go
363: ; ES:DI points to where *argv[0],*argv[1],*argv[2],... go
364: ; For wildcard version only:
365: ; ES:DX points to the wildcard flag character (prepended to argument)
366: ; during the creation of each argument
367: ;
368:
369: mov ss:[bx],di ; argv[i] - offset part
370: if sizeD
371: mov ss:[bx+2],ss ; argv[i] - segment part
372: add bx,4
373: else
374: inc bx
375: inc bx
376: endif
377:
378: mov si,cmdstart ; Get pointer to argv[0]
379: mov ds,_aenvseg
380: assumes ds,nothing
381:
382: ifdef WILDCARD
383: movsb
384: dec si ; copy first character as quote flag
385: endif
386:
387: copy_argv0:
388: lodsb
389: stosb
390: or al,al
391: jnz copy_argv0
392: ;
393: ; DS:SI points to the raw command tail string
394: ;
395:
396: jmps arg510
397: ;
398: ; Skip blanks
399: ;
400: arg500:
401: xor ax,ax
402: stosb
403: arg510:
404: lodsb
405: cmp al,C_BLANK
406: je arg510
407: cmp al,C_TAB
408: je arg510
409:
410: DELIM
411: lje arg810
412:
413: mov ss:[bx],di
414: if sizeD
415: mov ss:[bx+2],ss
416: add bx,4
417: else
418: inc bx
419: inc bx
420: endif
421:
422: ifdef WILDCARD
423: mov dx,di
424: stosb ; initialize wildcard flag
425: endif
426: ;
427: ;
428: ; Parse an argument
429: ;
430: arg600:
431: dec si ; back up to reload character
432: arg610:
433: lodsb
434:
435: cmp al,C_BLANK
436: je arg500
437: cmp al,C_TAB
438: je arg500 ; white space terminates argument
439:
440: DELIM
441: je arg800
442:
443: cmp al,C_QUOTE
444: je arg710x
445:
446: cmp al,C_BACKSLASH
447: je arg620
448:
449: stosb
450: jmps arg610
451: ;
452: ; Count backslashes
453: ;
454: arg620:
455: xor cx,cx
456: arg621:
457: inc cx ; CX counts the backslashes
458: lodsb
459: cmp al,C_BACKSLASH
460: je arg621
461: ;
462: cmp al,C_QUOTE
463: je arg630
464:
465: mov al,C_BACKSLASH
466: rep stosb ; not followed by `"' -- treat `\'s normally
467: jmp arg600
468: ;
469: arg630:
470: mov al,C_BACKSLASH
471: shr cx,1
472: rep stosb
473: jnc arg710x ; " opens a quoted substring
474: mov al,C_QUOTE
475: stosb
476: jmp arg610 ; " was escaped with a \
477: ;
478: ; Enter a quoted string
479: ;
480: ifdef WILDCARD
481: arg710x:
482: inc si ; undoes the "DEC SI" between arg700 and arg710
483: endif
484:
485: arg700x:
486:
487: ifdef WILDCARD
488: xchg dx,di ; set the wildcard flag character to `"'
489: mov al,C_QUOTE
490: stosb
491: dec di
492: xchg dx,di
493: endif
494:
495: arg700:
496: dec si ; back up to reload character
497:
498: ifndef WILDCARD
499: arg710x:
500: endif
501:
502: arg710:
503: lodsb
504:
505: DELIM
506: je arg800
507:
508: cmp al,C_QUOTE
509: je arg610 ; end of quoted portion of string
510:
511: cmp al,C_BACKSLASH
512: je arg720
513:
514: stosb
515: jmp arg710
516: ;
517: ; Count backslashes
518: ;
519: arg720:
520: xor cx,cx
521: arg721:
522: inc cx ; CX counts the backslashes
523: lodsb
524: cmp al,C_BACKSLASH
525: je arg721
526: ;
527: cmp al,C_QUOTE
528: je arg730
529:
530: mov al,C_BACKSLASH
531: rep stosb ; not followed by `"' -- treat `\'s normally
532: jmp arg700x
533: ;
534: arg730:
535: mov al,C_BACKSLASH
536: shr cx,1
537: rep stosb ; store 1 for every pair of backslashes
538: jnc arg610 ; " closes a quoted substring
539: mov al,C_QUOTE ; " was escaped with a \
540: stosb
541: jmps arg710x
542: ;
543: ; Terminate last argument string, terminate list of argument pointers
544: ;
545: arg800:
546: xor ax,ax
547: stosb ; null-terminate final argument
548: arg810:
549: push ss
550: pop ds
551: assumes ds,data
552:
553: mov word ptr [bx],0 ; add null pointer to __argv[]
554: if sizeD
555: mov word ptr [bx+2],0
556: endif
557:
558: ifndef WILDCARD
559: jmp [retadr] ; THE END
560: else
561: call _cwild
562: test ax,ax
563: jnz to_arg_error
564: jmp [retadr] ; THE END
565:
566: to_arg_error:
567: jmp arg_error
568:
569: page
570: ;***
571: ;_find(pattern) - find matching filename
572: ;
573: ;Purpose:
574: ; if argument is non-null, do a DosFindFirst on that pattern
575: ; otherwise do a DosFindNext call. Return matching filename
576: ; or NULL if no more matches.
577: ;
578: ; char *_find(pattern)
579: ; char *pattern;
580: ; {
581: ; static struct FileFindBuf findbuf;
582: ; static unsigned findhandle=1;
583: ; unsigned findcount=1;
584: ; int rc;
585: ;
586: ; if(pattern)
587: ; rc = DOSFINDFIRST((char far *) pattern,
588: ; (unsigned far *) &findhandle, A_D,
589: ; (struct FileFindBuf far *) &findbuf, sizeof(findbuf),
590: ; (unsigned far *) &findcount, 0L);
591: ; else
592: ; rc = DOSFINDNEXT(findhandle,
593: ; (struct FileFindBuf far *) &findbuf, sizeof(findbuf),
594: ; (unsigned far *) &findcount);
595: ;
596: ; return(rc ? NULL : findbuf.file_name);
597: ; }
598: ;
599: ;Entry:
600: ; pattern = pointer to pattern or NULL
601: ; (NULL means find next matching filename)
602: ;
603: ;Exit:
604: ; AX (or DX:AX) = pointer to matching file name
605: ; or NULL if no more matches.
606: ;
607: ;Uses:
608: ;
609: ;Exceptions:
610: ;
611: ;*******************************************************************************
612:
613: cProc _find,<PUBLIC>,<>
614: parmDP pattern
615: ; localW findcount
616: findcount equ (word ptr [bp-2])
617: cBegin
618: mov ax,1
619: push ax ; mov [findcount],1
620: mov bx,dataOFFSET findbuf
621: mov dx,size findbuf
622: lea ax,findcount
623: ;
624: ; DS:BX = &findbuf
625: ; DX = sizeof(findbuf)
626: ; SS:AX = &findcount
627: ; CX = FP_OFF(pattern)
628: ;
629: if sizeD
630: les cx,pattern
631: cmp word ptr [pattern+2],0
632: jz find_next
633: else
634: mov cx,pattern
635: jcxz find_next
636: endif
637: ;
638: ; Make first call to DOSFINDFIRST
639: ;
640: if sizeD
641: push es
642: else
643: push ds
644: endif
645: push cx ; (char far *) pattern
646: mov cx,dataOFFSET findhandle
647: mov [findhandle],1 ; always use handle 1
648: push ds
649: push cx ; (unsigned far *) & findhandle
650: mov cx,A_D
651: push cx ; match attribute: normal files + directories
652: push ds
653: push bx ; (struct FileFindBuf far *) &findbuf
654: push dx ; sizeof(findbuf)
655: push ss
656: push ax ; (unsigned far *) &findcount
657: xor ax,ax
658: push ax
659: push ax ; 0L (reserved)
660: call DOSFINDFIRST
661: jmp short check_rc
662: ;
663: ; get next match
664: ;
665: find_next:
666: push [findhandle] ; findhandle
667: push ds
668: push bx ; (struct FileFindBuf far *) &findbuf
669: push dx ; sizeof(findbuf)
670: push ss
671: push ax
672: call DOSFINDNEXT
673: ;
674: check_rc:
675: add bx,offset file_name ; BX = findbuf.file_name
676: if sizeD
677: mov dx,ds
678: endif
679: test ax,ax ; check for error in system call
680: xchg ax,bx ; return findbuf.file_name if successful
681: jz rc_zero
682: ;
683: xor ax,ax ; return NULL for error
684: if sizeD
685: cwd
686: endif
687: rc_zero:
688:
689: cEnd
690:
691: endif ; WILDCARD
692:
693: sEnd code
694:
695: end
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.