]> git.saurik.com Git - wxWidgets.git/blame - utils/Install/sfxzip/rexxapi.c
projects / wxWidgets.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
forgotten method declaration
[wxWidgets.git] / utils / Install / sfxzip / rexxapi.c
CommitLineData
f6bcfd97
BP		 1/**********************************************************************
2* REXXAPI.C *
3* *
4* This program adds a ZIP engine directly to the REXX language. *
5* The functions are: *
6* UZDropFuncs -- Makes all functions in this package *
7* unknown to REXX. *
8* UZLoadFuncs -- Makes all functions in this package *
9* known to REXX so REXX programs may *
10* call them. *
11* UZFileTree -- Searches for files matching a given *
12* filespec, including files in *
13* subdirectories. *
14* UZUnZip -- Unzip command-line entry point. *
15* This is functionally equivalent to *
16* using Unzip as an external program. *
17* UZUnZipToVar -- Unzip one file to a variable *
18* UZUnZipToStem -- Unzip files to a variable array *
19* UZVer -- Returns the Unzip version number *
20* *
21**********************************************************************/
22/* Include files */
23
24#ifdef OS2DLL
25
26#define INCL_DOS
27#define INCL_DOSMEMMGR
28#include <string.h>
29#include <stdlib.h>
30#include <stdio.h>
31#include <stdarg.h>
32
33#define UNZIP_INTERNAL
34#include "../unzip.h"
35#include "../version.h"
36
37
38/*********************************************************************/
39/* Various definitions used by various functions. */
40/*********************************************************************/
41
42RexxFunctionHandler UZDropFuncs;
43RexxFunctionHandler UZLoadFuncs;
44RexxFunctionHandler UZFileTree;
45RexxFunctionHandler UZUnZip;
46RexxFunctionHandler UZUnZipToVar;
47RexxFunctionHandler UZUnZipToStem;
48RexxFunctionHandler UZVer;
49RexxFunctionHandler UZAPIVer;
50
51
52int SetOutputVar(__GPRO__ const char *name);
53int SetOutputVarStem(__GPRO__ const char *name);
54int SetOutputVarLength(__GPRO);
55int WriteToVariable(__GPRO__ const char *name, char *buffer, int len);
56int PrintToSubVariable(__GPRO__ int idx, const char *format,...);
57int PrintToVariable(__GPRO__ const char *name, const char *format,...);
58int _PrintToVariable(__GPRO__ const char *name, const char *format, va_list arg_ptr);
59int TextSetNext(__GPRO__ char *format, int len, int all);
60
61#define EZRXSTRING(r,p) {(r).strptr=(PCH)p;(r).strlength=(ULONG)strlen((r).strptr);}
62
63
64/*********************************************************************/
65/* RxFncTable */
66/* Array of names of the UNZIPAPI functions. */
67/* This list is used for registration and deregistration. */
68/*********************************************************************/
69
70static PSZ RxFncTable[] =
71 {
72 "UZDropFuncs",
73 "UZLoadFuncs",
74 "UZFileSearch",
75 "UZFileTree",
76 "UZUnZip",
77 "UZUnZipToVar",
78 "UZUnZipToStem",
79 "UZVer",
80 };
81
82/*********************************************************************/
83/* Numeric Error Return Strings */
84/*********************************************************************/
85
86#define NO_UTIL_ERROR "0" /* No error whatsoever */
87#define ERROR_NOMEM "2" /* Insufficient memory */
88
89/*********************************************************************/
90/* Numeric Return calls */
91/*********************************************************************/
92
93#define INVALID_ROUTINE 40 /* Raise Rexx error */
94#define VALID_ROUTINE 0 /* Successful completion */
95
96/*********************************************************************/
97/* Some useful macros */
98/*********************************************************************/
99
100#define BUILDRXSTRING(t, s) { \
101 strcpy((t)->strptr,(s));\
102 (t)->strlength = strlen((s)); \
103}
104
105
106/*********************************************************************/
107/**************** UNZIPAPI Supporting Functions ********************/
108/**************** UNZIPAPI Supporting Functions ********************/
109/**************** UNZIPAPI Supporting Functions ********************/
110/*********************************************************************/
111
112
113int RexxReturn(__GPRO__ int nodefault, RXSTRING *retstr)
114{
115 int ret = G.os2.rexx_error;
116 if (G.filenotfound)
117 G.os2.rexx_mes = "file not found";
118 if (*G.os2.rexx_mes != '0') {
119 if (retstr->strlength > 255) {
120 DosFreeMem(retstr->strptr);
121 retstr->strptr = NULL;
122 }
123 } else if (nodefault)
124 goto noBuild;
125 BUILDRXSTRING(retstr, G.os2.rexx_mes);
126 noBuild:
127 DESTROYGLOBALS();
128 return ret;
129}
130
131/* Get a variable from REXX, return 0 if OK */
132int GetVariable(__GPRO__ const char *name)
133{
134 G.os2.request.shvnext = NULL;
135 EZRXSTRING(G.os2.request.shvname, name);
136 G.os2.request.shvnamelen = G.os2.request.shvname.strlength;
137 G.os2.request.shvvalue.strptr = G.os2.buffer;
138 G.os2.request.shvvalue.strlength = IBUF_LEN;
139 G.os2.request.shvvaluelen = IBUF_LEN;
140 G.os2.request.shvcode = RXSHV_SYFET;
141 G.os2.request.shvret = 0;
142 switch (RexxVariablePool(&G.os2.request)) {
143 case RXSHV_MEMFL:
144 G.os2.rexx_mes = ERROR_NOMEM;
145 break;
146 case RXSHV_BADN:
147 case RXSHV_NEWV:
148 G.os2.request.shvvaluelen = 0;
149 case RXSHV_OK:
150 *(G.os2.buffer+G.os2.request.shvvaluelen) = 0;
151 return G.os2.request.shvvaluelen;
152 }
153 return 0;
154}
155
156
157/* Get REXX compound variable */
158/* Stem must exist in G.os2.getvar_buf w/ length in G.os2.getvar_len */
159int GetVariableIndex(__GPRO__ int index)
160{
161 sprintf(G.os2.getvar_buf+G.os2.getvar_len,"%d",index);
162 return GetVariable(__G__ G.os2.getvar_buf);
163}
164
165
166/* Transfer REXX array to standard C string array */
167/* Returns number of elements */
168/* User is responsible for calling KillStringArray */
169
170int CompoundToStringArray(__GPRO__ char ***pointer, const char *name)
171{
172 int count;
173 int total;
174 char **trav;
175
176 G.os2.getvar_len = strlen(name);
177 memcpy(G.os2.getvar_buf,name,G.os2.getvar_len+1);
178 if (*(G.os2.getvar_buf+G.os2.getvar_len-1) != '.')
179 *(G.os2.getvar_buf+G.os2.getvar_len++) = '.', *(G.os2.getvar_buf+G.os2.getvar_len) = 0;
180
181 if (GetVariableIndex(__G__ 0))
182 return 0;
183
184 total = atoi(G.os2.buffer);
185 *pointer = (char **)malloc((total+1)<<2);
186 trav = *pointer;
187 for (count = 1; count <= total; count++) {
188 GetVariableIndex(__G__ count);
189 trav[count-1] = (char *)malloc(strlen(G.os2.buffer)+1);
190 strcpy(trav[count-1],G.os2.buffer);
191 }
192 trav[count-1] = NULL;
193 return total;
194}
195
196
197/* Kill string array created by CompoundToStringArray */
198
199void KillStringArray(char **pointer)
200{
201 char **trav=pointer;
202 while (*trav != NULL) {
203 free(*trav);
204 trav++;
205 }
206 free(pointer);
207}
208
209
210/*************************************************************************
211* Function: UZDropFuncs *
212* *
213* Syntax: call UZDropFuncs *
214* *
215* Return: NO_UTIL_ERROR - Successful. *
216*************************************************************************/
217
218ULONG UZDropFuncs(CHAR *name, ULONG numargs, RXSTRING args[],
219 CHAR *queuename, RXSTRING *retstr)
220{
221 INT entries; /* Num of entries */
222 INT j; /* Counter */
223
224 if (numargs != 0) /* no arguments for this */
225 return INVALID_ROUTINE; /* raise an error */
226
227 retstr->strlength = 0; /* return a null string result*/
228
229 entries = sizeof(RxFncTable)/sizeof(PSZ);
230
231 for (j = 0; j < entries; j++)
232 RexxDeregisterFunction(RxFncTable[j]);
233
234 return VALID_ROUTINE; /* no error on call */
235}
236
237
238/*************************************************************************
239* Function: UZFileTree *
240* *
241* Syntax: call UZFileTree zipfile, stem[, include-filespec] *
242* [, exclude-filespec][, options] *
243* *
244* Params: zipfile - Name of zip file to search. *
245* stem - Name of stem var to store results in. *
246* include - Filespec to search for (may include * and ?). *
247* exclude - Filespec to exclude (may include * and ?). *
248* options - Either of the following: *
249* 'F' - Give file statistics. *
250* Length Date Time Name *
251* 'Z' - Give zip statistics, too. *
252* Length Method Size Ratio Date Time CRC-32 Name*
253* Default is to return only filenames *
254* *
255* Return: NO_UTIL_ERROR - Successful. *
256* ERROR_NOMEM - Out of memory. *
257*************************************************************************/
258
259ULONG UZFileTree(CHAR *name, ULONG numargs, RXSTRING args[],
260 CHAR *queuename, RXSTRING *retstr)
261{
262 /* validate arguments */
263 char *incname[2];
264 char *excname[2];
265 CONSTRUCTGLOBALS();
266
267 if (numargs < 2 || numargs > 5 ||
268 !RXVALIDSTRING(args[0]) ||
269 !RXVALIDSTRING(args[1]) ||
270 args[0].strlength > 255) {
271 DESTROYGLOBALS();
272 return INVALID_ROUTINE; /* Invalid call to routine */
273 }
274 /* initialize data area */
275 SetOutputVarStem(__G__ args[1].strptr);
276 G.wildzipfn = args[0].strptr;
277 G.process_all_files = TRUE;
278
279 uO.lflag = 1;
280 uO.zipinfo_mode = TRUE;
281 uO.C_flag = 1;
282 G.extract_flag = FALSE;
283 uO.qflag = 2;
284
285 if (numargs >= 3 && /* check third option */
286 !RXNULLSTRING(args[2]) &&
287 args[2].strlength > 0) { /* a zero length string isn't */
288 if (!(G.filespecs = CompoundToStringArray(__G__ &G.pfnames,args[2].strptr))) {
289 G.pfnames = incname;
290 incname[0] = args[2].strptr;
291 incname[1] = NULL;
292 G.filespecs = 1;
293 }
294 G.process_all_files = FALSE;
295 }
296
297 if (numargs >= 4 && /* check third option */
298 !RXNULLSTRING(args[3]) &&
299 args[3].strlength > 0) { /* a zero length string isn't */
300 if (!(G.xfilespecs = CompoundToStringArray(__G__ &G.pxnames,args[3].strptr))) {
301 G.pxnames = excname;
302 excname[0] = args[3].strptr;
303 excname[1] = NULL;
304 G.xfilespecs = 1;
305 }
306 G.process_all_files = FALSE;
307 }
308
309 if (numargs == 5 && /* check third option */
310 !RXNULLSTRING(args[4]) &&
311 args[4].strlength > 0) { /* a zero length string isn't */
312 int first = *args[4].strptr & 0x5f;
313
314 if (first == 'Z')
315 uO.vflag = 2, uO.lflag = 0, uO.zipinfo_mode = FALSE;
316 else if (first == 'F')
317 uO.vflag = 1, uO.lflag = 0, uO.zipinfo_mode = FALSE;
318 }
319
320 process_zipfiles(__G);
321 SetOutputVarLength(__G);
322 if (G.filespecs > 0 && G.pfnames != incname)
323 KillStringArray(G.pfnames);
324 if (G.xfilespecs > 0 && G.pxnames != excname)
325 KillStringArray(G.pxnames);
326 return RexxReturn(__G__ 0,retstr); /* no error on call */
327}
328
329
330/*************************************************************************
331* Function: UZUnZipToVar *
332* *
333* Syntax: call UZUnZipToVar zipfile, filespec [, stem] *
334* *
335* Params: zipfile - Name of zip file to search. *
336* filespec - File to extract *
337* stem - If you specify a stem variable, the file will be *
338* extracted to the variable, one line per index *
339* In this case, 0 will be returned *
340* *
341* Return: Extracted file *
342* ERROR_NOMEM - Out of memory. *
343*************************************************************************/
344
345ULONG UZUnZipToVar(CHAR *name, ULONG numargs, RXSTRING args[],
346 CHAR *queuename, RXSTRING *retstr)
347{
348 CONSTRUCTGLOBALS();
349 UzpBuffer *ub = (UzpBuffer *)retstr;
350 /* validate arguments */
351 if (numargs < 2 || numargs > 3 ||
352 !RXVALIDSTRING(args[0]) ||
353 !RXVALIDSTRING(args[1]) ||
354 args[0].strlength == 0 ||
355 args[1].strlength == 0) {
356 DESTROYGLOBALS();
357 return INVALID_ROUTINE; /* Invalid call to routine */
358 }
359
360 uO.C_flag = 1;
361 G.redirect_data=1;
362 if (numargs == 3) {
363 if (!RXVALIDSTRING(args[2]) ||
364 RXNULLSTRING(args[1]) ||
365 args[2].strlength == 0) {
366 DESTROYGLOBALS();
367 return INVALID_ROUTINE; /* Invalid call to routine */
368 }
369 SetOutputVarStem(__G__ args[2].strptr);
370 G.redirect_text = 0;
371 G.redirect_data++;
372 }
373 unzipToMemory(__G__ args[0].strptr, args[1].strptr,
374 G.redirect_data==1 ? ub : NULL);
375 return RexxReturn(__G__ G.redirect_data==1,retstr);
376}
377
378
379/*************************************************************************
380* Function: UZUnZipToStem *
381* *
382* Syntax: call UZUnZipToStem zipfile, stem[, include-filespec] *
383* [, exclude-filespec][, mode] *
384* *
385* Params: zipfile - Name of zip file to search. *
386* stem - Name of stem var to store files in. *
387* include - Filespec to search for (may include * and ?). *
388* exclude - Filespec to exclude (may include * and ?). *
389* mode - Specifies 'F'lat or 'T'ree mode. Umm, this is *
390* hard to explain so I'll give an example, too. *
391* Assuming a file unzip.zip containing: *
392* unzip.c *
393* unshrink.c *
394* extract.c *
395* os2/makefile.os2 *
396* os2/os2.c *
397* os2/dll/dll.def *
398* os2/dll/unzipapi.c *
399* *
400* -- In flat mode, each file is stored in *
401* stem.fullname i.e. stem."os2/dll/unzipapi.c" *
402* A list of files is created in stem.<index> *
403* *
404* Flat mode returns: *
405* stem.0 = 7 *
406* stem.1 = unzip.c *
407* stem.2 = unshrink.c *
408* stem.3 = extract.c *
409* stem.4 = os2/makefile.os2 *
410* stem.5 = os2/os2.c *
411* stem.6 = os2/dll/dll.def *
412* stem.7 = os2/dll/unzipapi.c *
413* *
414* And the following contain the contents of the *
415* various programs: *
416* stem.unzip.c *
417* stem.unshrink.c *
418* stem.extract.c *
419* stem.os2/makefile.os2 *
420* stem.os2/os2.c *
421* stem.os2/dll/dll.def *
422* stem.os2/dll/unzipapi.c *
423* *
424* -- In tree mode, slashes are converted to periods*
425* in the pathname thus the above file would have*
426* been stored in stem.os2.dll.unzipapi.c *
427* The index would then be stored in stem.OS2. *
428* DLL.<index>. *
429* *
430* NOTE: All path names are converted to uppercase *
431* *
432* Tree mode returns: *
433* stem.0 = 4 *
434* stem.1 = unzip.c *
435* stem.2 = unshrink.c *
436* stem.3 = extract.c *
437* stem.4 = OS2/ *
438* *
439* stem.OS2.0 = 3 *
440* stem.OS2.1 = makefile.os2 *
441* stem.OS2.2 = os2.c *
442* stem.OS2.3 = DLL/ *
443* *
444* stem.OS2.DLL.0 = 2 *
445* stem.OS2.DLL.1 = def *
446* stem.OS2.DLL.2 = unzipapi.c *
447* *
448* And the following contain the contents of the *
449* various programs: *
450* stem.unzip.c *
451* stem.unshrink.c *
452* stem.extract.c *
453* stem.OS2.makefile.os2 *
454* stem.OS2.os2.c *
455* stem.OS2.DLL.dll.def *
456* stem.OS2.DLL.unzipapi.c *
457* *
458* *
459* Return: NO_UTIL_ERROR - Successful. *
460* ERROR_NOMEM - Out of memory. *
461*************************************************************************/
462
463ULONG UZUnZipToStem(CHAR *name, ULONG numargs, RXSTRING args[],
464 CHAR *queuename, RXSTRING *retstr)
465{
466 char *incname[2];
467 char *excname[2];
468 CONSTRUCTGLOBALS();
469 /* validate arguments */
470 if (numargs < 2 || numargs > 5 ||
471 !RXVALIDSTRING(args[0]) ||
472 !RXVALIDSTRING(args[1]) ||
473 args[0].strlength > 255) {
474 DESTROYGLOBALS();
475 return INVALID_ROUTINE; /* Invalid call to routine */
476 }
477 /* initialize data area */
478 G.wildzipfn = args[0].strptr;
479 G.process_all_files = TRUE;
480
481 uO.C_flag = 1;
482 G.extract_flag = TRUE;
483 SetOutputVarStem(__G__ args[1].strptr);
484 G.redirect_data = 3;
485 G.redirect_text = 0;
486
487 if (numargs >= 3 && /* check third option */
488 !RXNULLSTRING(args[2]) &&
489 args[2].strlength > 0) { /* a zero length string isn't */
490 if (!(G.filespecs = CompoundToStringArray(__G__ &G.pfnames,args[2].strptr))) {
491 G.pfnames = incname;
492 incname[0] = args[2].strptr;
493 incname[1] = NULL;
494 G.filespecs = 1;
495 }
496 G.process_all_files = FALSE;
497 }
498
499 if (numargs >= 4 && /* check third option */
500 !RXNULLSTRING(args[3]) &&
501 args[3].strlength > 0) { /* a zero length string isn't */
502 if (!(G.xfilespecs = CompoundToStringArray(__G__ &G.pxnames,args[3].strptr))) {
503 G.pxnames = excname;
504 excname[0] = args[3].strptr;
505 excname[1] = NULL;
506 G.xfilespecs = 1;
507 }
508 G.process_all_files = FALSE;
509 }
510
511 if (numargs == 5 && /* check third option */
512 !RXNULLSTRING(args[4]) &&
513 (*args[4].strptr & 0x5f) == 'T') {
514 G.redirect_data++;
515 G.os2.request.shvnext = NULL;
516 EZRXSTRING(G.os2.request.shvname, args[4].strptr);
517 G.os2.request.shvnamelen = G.os2.request.shvname.strlength;
518 G.os2.request.shvcode = RXSHV_SYDRO;
519 G.os2.request.shvret = 0;
520 RexxVariablePool(&G.os2.request);
521 }
522
523
524 uO.qflag = 2;
525
526 process_zipfiles(__G);
527 if (G.filespecs > 0 && G.pfnames != incname)
528 KillStringArray(G.pfnames);
529 if (G.xfilespecs > 0 && G.pxnames != excname)
530 KillStringArray(G.pxnames);
531 if (G.redirect_data == 3)
532 SetOutputVarLength(__G);
533 return RexxReturn(__G__ 0,retstr); /* no error on call */
534}
535
536
537/*************************************************************************
538* Function: UZLoadFuncs *
539* *
540* Syntax: call UZLoadFuncs [option] *
541* *
542* Params: none *
543* *
544* Return: null string *
545*************************************************************************/
546
547ULONG UZLoadFuncs(CHAR *name, ULONG numargs, RXSTRING args[],
548 CHAR *queuename, RXSTRING *retstr)
549{
550 INT entries; /* Num of entries */
551 INT j; /* Counter */
552
553 retstr->strlength = 0; /* set return value */
554 /* check arguments */
555 if (numargs > 0)
556 return INVALID_ROUTINE;
557
558 entries = sizeof(RxFncTable)/sizeof(PSZ);
559
560 for (j = 0; j < entries; j++) {
561 RexxRegisterFunctionDll(RxFncTable[j],
562 "UNZIP32", RxFncTable[j]);
563 }
564 return VALID_ROUTINE;
565}
566
567
568
569/*************************************************************************
570* Function: UZVer *
571* *
572* Syntax: call UZVer *
573* *
574* Return: Version of Unzip *
575*************************************************************************/
576
577ULONG UZVer(CHAR *name, ULONG numargs, RXSTRING args[],
578 CHAR *queuename, RXSTRING *retstr)
579{
580 if (numargs > 1) /* validate arg count */
581 return INVALID_ROUTINE;
582
583 if (numargs == 0 || (*args[0].strptr & 0x5f) != 'L')
584 /* strcpy( retstr->strptr, UZ_VERNUM ); "5.13a BETA" */
585 sprintf( retstr->strptr, "%d.%d%d%s", UZ_MAJORVER, UZ_MINORVER,
586 PATCHLEVEL, BETALEVEL );
587 else
588 /* strcpy( retstr->strptr, UZ_VERSION ); UZ_VERNUM" of 26 Sep 94" */
589 sprintf( retstr->strptr, "%d.%d%d%s of %s", UZ_MAJORVER, UZ_MINORVER,
590 PATCHLEVEL, BETALEVEL, VERSION_DATE );
591 retstr->strlength = strlen(retstr->strptr);
592 return VALID_ROUTINE;
593}
594
595
596/*************************************************************************
597* Function: UZUnZip *
598* *
599* Syntax: call UZUnZip *
600* *
601* Return: Unzip return code *
602*************************************************************************/
603
604ULONG UZUnZip(CHAR *name, ULONG numargs, RXSTRING args[],
605 CHAR *queuename, RXSTRING *retstr)
606{
607 char *argv[30];
608 char *scan;
609 int argc=0;
610 int idx;
611 CONSTRUCTGLOBALS();
612
613 if (numargs < 1 || numargs > 2 ||
614 args[0].strlength > 255) {
615 DESTROYGLOBALS();
616 return INVALID_ROUTINE; /* Invalid call to routine */
617 }
618 /* initialize data area */
619 if (numargs == 2)
620 SetOutputVarStem(__G__ args[1].strptr);
621
622 scan = args[0].strptr;
623 argv[argc++] = ""; /* D:\\SOURCECODE\\UNZIP51S\\UNZIP.COM"; */
624 while (*scan == ' ')
625 scan++;
626 argv[argc++] = scan;
627 while ( (scan = strchr(scan,' ')) != NULL) {
628 *scan++ = 0;
629 while (*scan == ' ')
630 scan++;
631 argv[argc++] = scan;
632 }
633 if (*argv[argc-1] == 0)
634 argc--;
635 argv[argc] = 0;
636
637 /* GRR: should resetMainFlags() be called in here somewhere? */
638
639 sprintf(retstr->strptr, "%d", unzip(__G__ argc, argv)); /* a.k.a. MAIN() */
640 if (numargs == 2)
641 SetOutputVarLength(__G);
642 retstr->strlength = strlen(retstr->strptr);
643 return RexxReturn(__G__ 1,retstr);
644}
645
646int varmessage(__GPRO__ uch *buf, ulg size)
647{
648 if (size > 0)
649 memcpy(G.os2.buffer+G.os2.putchar_idx,buf,size);
650 G.os2.putchar_idx = TextSetNext(__G__ G.os2.buffer, size+G.os2.putchar_idx,0);
651 return 0;
652}
653
654int varputchar(__GPRO__ int c)
655{
656 G.os2.buffer[G.os2.putchar_idx++] = c;
657 if (c == '\n') {
658 G.os2.buffer[G.os2.putchar_idx] = 0;
659 if (G.os2.output_var[0])
660 G.os2.putchar_idx = TextSetNext(__G__ G.os2.buffer, G.os2.putchar_idx,0);
661 else {
662 G.os2.buffer[--G.os2.putchar_idx] = 0;
663 puts(G.os2.buffer);
664 G.os2.putchar_idx = 0;
665 }
666 }
667 return 1;
668}
669
670
671
672int SetOutputVarStem(__GPRO__ const char *name)
673{
674 int len=strlen(name);
675 G.redirect_text=1;
676 G.os2.output_idx = 0;
677 strcpy(G.os2.output_var, name);
678 if (len) {
679 strupr(G.os2.output_var); /* uppercase the name */
680 if (*(G.os2.output_var+len-1) != '.') {
681 *(G.os2.output_var+len) = '.';
682 len++;
683 *(G.os2.output_var+len) = 0;
684 }
685 WriteToVariable(__G__ G.os2.output_var,"",0);
686 }
687 G.os2.stem_len = len;
688 return G.os2.stem_len;
689}
690
691int SetOutputVar(__GPRO__ const char *name)
692{
693 int len=strlen(name);
694 G.redirect_text=1;
695 G.os2.output_idx = 0;
696 strcpy(G.os2.output_var, name);
697 strupr(G.os2.output_var); /* uppercase the name */
698 if (*(name+len-1) == '.')
699 G.os2.stem_len = len;
700 else
701 G.os2.stem_len = 0;
702 return G.os2.stem_len;
703}
704
705int SetOutputVarLength(__GPRO)
706{
707 if (G.os2.stem_len > 0) {
708 if (G.os2.putchar_idx)
709 TextSetNext(__G__ G.os2.buffer,G.os2.putchar_idx,1);
710 return PrintToSubVariable(__G__ 0,"%d",G.os2.output_idx);
711 }
712 return 0;
713}
714
715int PrintToVariable(__GPRO__ const char *name, const char *format,...)
716{
717 va_list arg_ptr;
718 int ret;
719
720 va_start(arg_ptr, format);
721 ret = _PrintToVariable(__G__ name, format, arg_ptr);
722 va_end(arg_ptr);
723 return ret;
724}
725
726int WriteToVariable(__GPRO__ const char *name, char *buffer, int len)
727{
728 G.os2.request.shvnext = NULL;
729 EZRXSTRING(G.os2.request.shvname, name);
730 G.os2.request.shvnamelen = G.os2.request.shvname.strlength;
731 G.os2.request.shvvalue.strptr = buffer;
732 G.os2.request.shvvalue.strlength = len;
733 G.os2.request.shvvaluelen = len;
734 G.os2.request.shvcode = RXSHV_SET;
735 G.os2.request.shvret = 0;
736 switch (RexxVariablePool(&G.os2.request)) {
737 case RXSHV_BADN:
738 G.os2.rexx_error = INVALID_ROUTINE;
739 break;
740 case RXSHV_MEMFL:
741 G.os2.rexx_mes = ERROR_NOMEM;
742 break;
743 case RXSHV_OK:
744 return 0;
745 }
746 return INVALID_ROUTINE; /* error on non-zero */
747}
748
749int _PrintToVariable(__GPRO__ const char *name, const char *format, va_list arg_ptr)
750{
751 int ret = vsprintf(G.os2.buffer, format, arg_ptr);
752 WriteToVariable(__G__ name, G.os2.buffer, strlen(G.os2.buffer));
753 return ret;
754}
755
756int PrintToSubVariable(__GPRO__ int idx, const char *format, ...)
757{
758 va_list arg_ptr;
759 int ret;
760
761 if (G.os2.stem_len == 0)
762 return INVALID_ROUTINE; /* error on non-zero */
763 sprintf(G.os2.output_var+G.os2.stem_len,"%d",idx);
764
765 va_start(arg_ptr, format);
766 ret = _PrintToVariable(__G__ G.os2.output_var, format, arg_ptr);
767 va_end(arg_ptr);
768 return ret;
769}
770
771
772int WriteToNextVariable(__GPRO__ char *buffer, int len)
773{
774 if (G.os2.stem_len > 0) {
775 G.os2.output_idx++;
776 sprintf(G.os2.output_var+G.os2.stem_len,"%d",G.os2.output_idx);
777 }
778 return WriteToVariable(__G__ G.os2.output_var, buffer, len);
779}
780
781
782int TextSetNext(__GPRO__ char *buffer, int len, int all)
783{
784 char *scan = buffer, *next, *base=buffer;
785 int remaining=len;
786 int ret;
787
788 while ((next = strchr(scan,'\n')) != NULL && remaining > 0) {
789 if (next > scan && *(next-1) == 0xd)
790 *(next-1) = 0;
791 else
792 *next = 0;
793 if (WriteToNextVariable(__G__ scan,strlen(scan)))
794 return 0;
795 next++;
796 remaining -= (next-scan);
797 scan = next;
798 }
799 if (remaining > 0)
800 if (all) {
801 *(scan+remaining) = 0;
802 WriteToNextVariable(__G__ scan,remaining);
803 } else {
804 memcpy(buffer,scan,remaining);
805 return remaining;
806 }
807
808 return 0;
809}
810
811int finish_REXX_redirect(__GPRO)
812{
813 char *scan, *ptr;
814 int idx=0, first=1, offset;
815
816 if (!G.redirect_size)
817 return 0;
818 switch(G.redirect_data) {
819 case 1:
820 break;
821 case 2:
822 TextSetNext(__G__ G.redirect_buffer, G.redirect_size, 1);
823 SetOutputVarLength(__G);
824 DosFreeMem(G.redirect_buffer);
825 G.redirect_buffer = NULL;
826 G.redirect_size = 0;
827 break;
828 case 3:
829 WriteToNextVariable(__G__ G.filename,strlen(G.filename));
830 sprintf(G.os2.output_var+G.os2.stem_len,G.filename);
831 WriteToVariable(__G__ G.os2.output_var, G.redirect_buffer, G.redirect_size);
832 DosFreeMem(G.redirect_buffer);
833 G.redirect_buffer = NULL;
834 G.redirect_size = 0;
835 break;
836 case 4:
837 if ((scan = strrchr(G.filename,'/')) != NULL) {
838 idx = *scan;
839 *scan = 0;
840 strupr(G.filename);
841 *scan = idx;
842 }
843 scan = G.os2.output_var+G.os2.stem_len;
844 strcpy(scan,G.filename);
845 while ((scan = strchr(scan,'/')) != NULL)
846 *scan = '.';
847 WriteToVariable(__G__ G.os2.output_var, G.redirect_buffer, G.redirect_size);
848 DosFreeMem(G.redirect_buffer);
849 G.redirect_buffer = NULL;
850 G.redirect_size = 0;
851 strcpy(G.os2.getvar_buf, G.os2.output_var);
852 do {
853 if ((scan = strrchr(G.filename,'/')) == NULL)
854 offset = 0;
855 else
856 offset = scan-G.filename+1;
857 if (first || !GetVariable(__G__ G.os2.output_var)) {
858 ptr = G.os2.getvar_buf+offset+G.os2.stem_len;
859 *ptr = '0';
860 *(ptr+1) = 0;
861 if (!GetVariable(__G__ G.os2.getvar_buf))
862 idx = 1;
863 else
864 idx = atoi(G.os2.buffer)+1;
865 PrintToVariable(__G__ G.os2.getvar_buf,"%d",idx);
866 sprintf(ptr,"%d",idx);
867 if (!first) {
868 PrintToVariable(__G__ G.os2.output_var,"%d",idx);
869 idx = strlen(G.filename);
870 *(G.filename+idx) = '/';
871 *(G.filename+idx+1) = 0;
872 }
873 WriteToVariable(__G__ G.os2.getvar_buf,G.filename+offset,strlen(G.filename+offset));
874 first=0;
875 }
876 if (offset) {
877 *(G.os2.output_var+G.os2.stem_len+offset-1) = 0;
878 *scan = 0;
879 }
880 } while (offset);
881 break;
882 }
883 return 0;
884}
885
886#endif /* OS2DLL */
wxWidgets (Impactor)