w32tex
About: TeX Live provides a comprehensive TeX system including all the major TeX-related programs, macro packages, and fonts that are free software. Windows sources.
  Fossies Dox: w32tex-src.tar.xz  ("unofficial" and yet experimental doxygen-generated source code documentation)  

sh10.c
Go to the documentation of this file.
1 /*
2  * MS-DOS SHELL - Function Processing
3  *
4  * MS-DOS SHELL - Copyright (c) 1990,4 Data Logic Limited
5  *
6  * This code is subject to the following copyright restrictions:
7  *
8  * 1. Redistribution and use in source and binary forms are permitted
9  * provided that the above copyright notice is duplicated in the
10  * source form and the copyright notice in file sh6.c is displayed
11  * on entry to the program.
12  *
13  * 2. The sources (or parts thereof) or objects generated from the sources
14  * (or parts of sources) cannot be sold under any circumstances.
15  *
16  * Note: 1. The PrintProcessTree code is based on code written by Kai Uwe
17  * Rommel
18  *
19  * 2. When parts of the original 2.1 shell were replaced by the Lexical
20  * Analsyer written by Simon J. Gerraty (for his Public Domain Korn
21  * Shell, which is also based on Charles Forsyth original idea), a
22  * number of changes were made to reflect the changes Simon made to
23  * the Parse output tree. Some parts of this code in this module
24  * are based on the algorithms/ideas that he incorporated into his
25  * shell, in particular the Function Processing functions.
26  *
27  * $Header: /usr/users/istewart/shell/sh2.3/Release/RCS/sh10.c,v 2.15 1994/08/25 20:49:11 istewart Exp $
28  *
29  * $Log: sh10.c,v $
30  * Revision 2.15 1994/08/25 20:49:11 istewart
31  * MS Shell 2.3 Release
32  *
33  * Revision 2.14 1994/02/23 09:23:38 istewart
34  * Beta 233 updates
35  *
36  * Revision 2.13 1994/02/01 10:25:20 istewart
37  * Release 2.3 Beta 2, including first NT port
38  *
39  * Revision 2.12 1994/01/11 17:55:25 istewart
40  * Release 2.3 Beta 0 patches
41  *
42  * Revision 2.11 1993/12/01 11:58:34 istewart
43  * Release 226 beta
44  *
45  * Revision 2.10 1993/08/25 16:03:57 istewart
46  * Beta 225 - see Notes file
47  *
48  * Revision 2.9 1993/07/02 10:21:35 istewart
49  * 224 Beta fixes
50  *
51  * Revision 2.8 1993/06/14 11:01:44 istewart
52  * More changes for 223 beta
53  *
54  * Revision 2.7 1993/06/02 09:52:35 istewart
55  * Beta 223 Updates - see Notes file
56  *
57  * Revision 2.6 1993/02/16 16:03:15 istewart
58  * Beta 2.22 Release
59  *
60  * Revision 2.5 1993/01/26 18:35:09 istewart
61  * Release 2.2 beta 0
62  *
63  * Revision 2.4 1992/12/14 10:54:56 istewart
64  * BETA 215 Fixes and 2.1 Release
65  *
66  * Revision 2.3 1992/11/06 10:03:44 istewart
67  * 214 Beta test updates
68  *
69  * Revision 2.2 1992/07/16 14:33:34 istewart
70  * Beta 212 Baseline
71  *
72  * Revision 2.1 1992/07/10 10:52:48 istewart
73  * 211 Beta updates
74  *
75  * Revision 2.0 1992/04/13 17:39:09 Ian_Stewartson
76  * MS-Shell 2.0 Baseline release
77  *
78  */
79 
80 #include <sys/types.h>
81 #include <sys/stat.h>
82 #include <stdio.h>
83 #include <signal.h>
84 #include <errno.h>
85 #include <setjmp.h>
86 #include <ctype.h>
87 #include <string.h>
88 #include <unistd.h>
89 #include <stdlib.h>
90 #include <fcntl.h>
91 #include <limits.h>
92 #include <dirent.h>
93 #include "sh.h"
94 
95 #if (OS_TYPE == OS_UNIX)
96 # include <sys/times.h>
97 #endif
98 
99 /* Function declarations */
100 
101 static void F_LOCAL PrintCommand (C_Op *, int);
103 static void F_LOCAL PrintCaseCommand (C_Op *);
104 static void F_LOCAL PrintIndentedString (char *, int, int);
105 static void F_LOCAL PrintVarArg (unsigned char *);
106 static void F_LOCAL fputMagicChar (unsigned int);
107 static void F_LOCAL PrintMode (int);
108 
109 static void F_LOCAL SaveReleaseExecuteTree (C_Op *, void (*)(void *));
110 static void F_LOCAL SaveReleaseWordList (char **, void (*)(void *));
111 static void F_LOCAL SaveReleaseIOActions (IO_Actions **, void (*)(void *));
112 static void SaveTreeEntry (void *);
113 
115 static char ** F_LOCAL DuplicateWordList (char **list);
117 
118 static int FindFunction (const void *, const void *);
119 static int SearchFunction (const void *, const void *);
120 static void DisplayFunction (const void *, VISIT, int);
121 static void DeleteAFunction (const void *, VISIT, int);
122 
123 static int FindAlias (const void *, const void *);
124 static int SearchAlias (const void *, const void *);
125 static void UntrackAlias (const void *, VISIT, int);
126 static void DisplayAlias (const void *, VISIT, int);
127 
128 #if (OS_TYPE != OS_DOS)
129 static void DisplayJob (const void *, VISIT, int);
130 static void CountJob (const void *, VISIT, int);
131 static int SearchJob (const void *, const void *);
132 static int FindJob (const void *, const void *);
133 static void FindJobByString (const void *, VISIT, int);
134 static int FindJobByPID (const void *, const void *);
135 static int FindJobBySession (const void *, const void *);
136 #endif
137 
138 #if (OS_TYPE == OS_OS2)
139 # if (OS_SIZE == OS_32)
140 # if !defined (__EMX__)
141 # define Dos32GetPrty DosGetPrty
142 # define Dos32QProcStatus DosQProcStatus
143 # pragma linkage (DosQProcStatus, far16 pascal)
144 # pragma linkage (DosGetPrty, far16 pascal)
145 # else
146 USHORT _THUNK_FUNCTION (Dos16GetPrty) ();
147 USHORT _THUNK_FUNCTION (Dos16QProcStatus) ();
148 # endif
149 extern USHORT Dos32QProcStatus (PVOID, USHORT);
150 extern USHORT Dos32GetPrty (USHORT, PUSHORT, USHORT);
151 # else
152 # define Dos32QProcStatus DosQProcStatus
153 # define Dos32GetPrty DosGetPrty
154 extern USHORT APIENTRY Dos32QProcStatus (PVOID, USHORT);
155 # endif
156 #endif
157 
158 /*
159  * OS/2 Process Information structures
160  *
161  *
162  * Declare OS2 1.x 16-bit version structures
163  */
164 
165 #if (OS_TYPE == OS_OS2) && (OS_SIZE == OS_16)
166 typedef struct process
167 {
168  USHORT pid;
169  USHORT ppid;
170  USHORT threads;
172  USHORT modhandle;
173  USHORT module;
174 } V1Process_t;
175 
176 typedef struct module
177 {
178  USHORT modhandle;
179  USHORT max_dependents;
180  USHORT *dependents;
181  UCHAR *modname;
182 } V1Module_t;
183 
184 typedef struct ProcessInfo
185 {
186  V1Process_t **V1Processes;
187  V1Module_t **V1Modules;
188  USHORT M_Processes;
189  USHORT N_Processes;
190  USHORT M_Modules;
191  USHORT N_Modules;
192 } V1ProcessStatus_t;
193 #endif
194 
195 /*
196  * OS2 2.0 - 32 Bit version structures
197  */
198 
199 #if (OS_TYPE == OS_OS2)
200 # if (OS_SIZE == OS_32)
201 # define PTR(ptr) (ptr)
202 # else
203 # define PTR(ptr) ((void *)((((ULONG)ps) & 0xFFFF0000L) | \
204  (((ULONG)(ptr)) & 0x0000FFFFL) ))
205 # endif
206 
207 # define PROCESS_END_INDICATOR 3
208 
209 /* Process Status structures */
210 
211 # if (OS_SIZE == OS_32)
212 # pragma pack(1)
213 # endif
214 
215 /*
216  * Thread Info
217  */
218 
219 typedef struct thread2
220 {
221  ULONG ulRecType; /* Record type (thread = 100) */
222  USHORT tidWithinProcess; /* TID within process (TID is */
223  /* 4 bytes!!) */
224  USHORT usSlot; /* Unique thread slot number */
225  ULONG ulBlockId; /* Sleep id thread is sleeping on*/
226  ULONG ulPriority; /* Priority */
227  ULONG ulSysTime; /* Thread System Time */
228  ULONG ulUserTime; /* Thread User Time */
229  UCHAR uchState; /* 1=ready,2=blocked,5=running */
230  UCHAR uchPad; /* Filler */
231  USHORT usPad; /* Filler */
232 } V2Thread_t;
233 
234 /*
235  * Process Information
236  */
237 
238 typedef struct process2
239 {
240  ULONG ulEndIndicator; /* 1 means not end, 3 means */
241  /* last entry */
242  V2Thread_t *ptiFirst; /* Address of the 1st Thread */
243  /* Control Blk */
244  USHORT pid; /* Process ID (2 bytes - PID */
245  /* is 4 bytes) */
246  USHORT pidParent; /* Parent's process ID */
247  ULONG ulType; /* Process Type */
248  ULONG ulStatus; /* Process Status */
249  ULONG idSession; /* Session ID */
250  USHORT hModRef; /* Module handle of EXE */
251  USHORT usThreadCount; /* Number of threads in this */
252  /* process */
253  ULONG ulSessionType; /* Session Type */
254  PVOID pvReserved; /* Unknown */
255  USHORT usSem16Count; /* Number of 16-bit system */
256  /* semaphores */
257  USHORT usDllCount; /* Number of Dlls used by */
258  /* process */
259  USHORT usShrMemHandles; /* Number of shared memory */
260  /* handles */
261  USHORT usReserved; /* Unknown */
262  PUSHORT pusSem16TableAddr; /* Address of a 16-bit semaphore*/
263  /* table */
264  PUSHORT pusDllTableAddr; /* Address of a Dll table */
265  PUSHORT pusShrMemTableAddr; /* Address of a shared memory */
266  /* table */
267 } V2Process_t;
268 
269 /*
270  * Process Status header
271  */
272 
273 typedef struct processstatus2
274 {
275  PVOID psumm; /* SUMMARY section ptr */
276  V2Process_t *ppi; /* PROCESS section ptr */
277  PVOID psi; /* SEM section ptr (add 16 to offset) */
278  PVOID pDontKnow1; /* */
279  PVOID psmi; /* SHARED MEMORY section ptr */
280  PVOID pmi; /* MODULE section ptr */
281  PVOID pDontKnow2; /* */
282  PVOID pDontKnow3; /* */
283 } V2ProcessStatus_t;
284 
285 # if (OS_SIZE == OS_32)
286 # pragma pack()
287 # endif
288 #endif
289 
290 /*
291  * Associated functions
292  */
293 
294 #if (OS_TYPE == OS_OS2) && (OS_SIZE == OS_16)
295 static int SortV1Processes (void *, void *);
296 static void F_LOCAL PrintV1ProcessTree (pid_t, int,
297  V1ProcessStatus_t *);
298 static bool F_LOCAL Parse_V1ProcessTable (UCHAR *,
299  V1ProcessStatus_t *);
300 #endif
301 
302 #if (OS_TYPE == OS_OS2)
303 static void F_LOCAL V2_DisplayProcessTree (USHORT, USHORT,
304  V2ProcessStatus_t *);
305 static V2ProcessStatus_t * F_LOCAL GetProcessStatus (char *);
306 #endif
307 
308 #if (OS_TYPE != OS_DOS)
309 static char *JobSearchKey; /* Job search string */
310 static int NumberOfJobs = 0; /* Number of Jobs */
311 static JobList **JobSearchEntry; /* Matching entry */
312 #endif
313 
314 static bool DisplayListMode = FALSE;/* Mode for Display Job/Alias */
315 static int Print_indent; /* Current indent level */
316 
317  /* IO types */
318 static char *IOTypes [] = { "<", ">", "<>", "<<", ">>", ">&" };
319 
320 /*
321  * Duplicate a memory area
322  */
323 
324 #define DuplicateMemoryArea(area, type) \
325  (type)((area == (void *)NULL) \
326  ? (void *)NULL \
327  : DuplicateMemoryCell (area))
328 
329 /*
330  * Print ALL functions
331  */
332 
334 {
336  return 0;
337 }
338 
339 /*
340  * TWALK function to display the JOB, FUNCTION and ALIAS trees
341  */
342 
343 #if (OS_TYPE != OS_DOS)
344 static void CountJob (const void *key, VISIT visit, int level)
345 {
346  if ((visit == postorder) || (visit == leaf))
347  NumberOfJobs++;
348 }
349 
350 static void DisplayJob (const void *key, VISIT visit, int level)
351 {
352  if ((visit == postorder) || (visit == leaf))
353  {
354  printf ("[%d] %c", (*(JobList **)key)->Number,
355  ((*(JobList **)key)->Number == CurrentJob)
356  ? CHAR_PLUS
357  : (((*(JobList **)key)->Number == PreviousJob)
358  ? CHAR_HYPHEN : CHAR_SPACE));
359 
360  if (DisplayListMode)
361  printf (" %d", (*(JobList **)key)->pid);
362 
363  fputchar (CHAR_TAB);
364  FlushStreams ();
365  DisplayLineWithControl ((*(JobList **)key)->Command);
366  fputchar (CHAR_NEW_LINE);
367  }
368 }
369 #endif
370 
371 static void DisplayFunction (const void *key, VISIT visit, int level)
372 {
373  if ((visit == postorder) || (visit == leaf))
375 
376 }
377 
378 static void DisplayAlias (const void *key, VISIT visit, int level)
379 {
380  if (((visit == postorder) || (visit == leaf)) &&
381  (!DisplayListMode || (*(AliasList **)key)->AFlags & ALIAS_TRACKED))
382  PrintAlias ((*(AliasList **)key)->name);
383 }
384 
385 
386 /*
387  * DISPLAY A FUNCTION TREE
388  */
389 
390 /*
391  * print the execute tree - used for displaying functions
392  */
393 
394 void PrintFunction (register C_Op *t, int mode)
395 {
396  char **wp;
397 
398  if (t == (C_Op *)NULL)
399  return;
400 
401 /* Check for start of print */
402 
403  if (t->type == TFUNC)
404  {
405  Print_indent = 0;
406  printf (LIT_2Strings, t->str, "()");
407  PrintFunction (t->left, PF_MODE_NORMAL);
408  FlushStreams ();
409  return;
410  }
411 
412 /* Otherwise, process the tree and print it */
413 
414  switch (t->type)
415  {
416  case TASYNC: /* Asyn commands */
417  PrintFunction (t->left, PF_MODE_ASYNC);
418  return;
419 
420  case TCOPROCESS: /* Co-process */
421  PrintFunction (t->left, PF_MODE_COPROC);
422  return;
423 
424  case TPAREN: /* () */
425  case TCOM: /* A command process */
426  PrintCommand (t, mode);
427  return;
428 
429  case TPIPE: /* Pipe processing */
430  PrintFunction (t->left, PF_MODE_NORMAL);
432  PrintFunction (t->right, mode);
433  return;
434 
435  case TLIST: /* Entries in a for statement */
436  PrintFunction (t->left, PF_MODE_NORMAL);
437  PrintFunction (t->right, mode);
438  return;
439 
440  case TOR: /* || and && */
441  case TAND:
442  PrintFunction (t->left, PF_MODE_NORMAL);
443 
444  if (t->right != (C_Op *)NULL)
445  {
446  PrintIndentedString ((t->type == TAND) ? "&&\n" : "||\n",
447  0, PF_MODE_NORMAL);
448  PrintFunction (t->right, mode);
449  }
450 
451  return;
452 
453  case TFOR: /* First part of a for statement*/
454  case TSELECT:
455  PrintIndentedString ((t->type == TFOR) ? "for " : "select ",
456  0, PF_MODE_NORMAL);
457  foputs (t->str);
458 
459  if ((wp = t->vars) != NOWORDS)
460  {
461  foputs (" in");
462 
463  while (*wp != NOWORD)
464  {
465  fputchar (CHAR_SPACE);
466  PrintVarArg ((unsigned char *)*(wp++));
467  }
468  }
469 
470  fputchar (CHAR_NEW_LINE);
471  PrintIndentedString ("do\n", 1, PF_MODE_NORMAL);
472  PrintFunction (t->left, PF_MODE_NORMAL);
474  return;
475 
476  case TWHILE: /* WHILE and UNTIL functions */
477  case TUNTIL:
478  PrintIndentedString ((t->type == TWHILE) ? "while\n" : "until\n",
479  1, PF_MODE_NORMAL);
480  PrintFunction (t->left, PF_MODE_NORMAL);
481  Print_indent--;
482  PrintIndentedString ("do\n", 1, PF_MODE_NORMAL);
483  PrintFunction (t->right, PF_MODE_NORMAL);
485  return;
486 
487  case TIF: /* IF and ELSE IF functions */
488  case TELIF:
489  if (t->type == TIF)
490  PrintIndentedString ("if\n", 1, PF_MODE_NORMAL);
491 
492  else
493  PrintIndentedString ("elif\n", 1, PF_MODE_NORMAL);
494 
495  PrintFunction (t->left, PF_MODE_NORMAL);
496 
497  if (t->right != (C_Op *)NULL)
498  {
499  Print_indent -= 1;
500  PrintIndentedString ("then\n", 1, PF_MODE_NORMAL);
501  PrintFunction (t->right->left, PF_MODE_NORMAL);
502 
503  if (t->right->right != (C_Op *)NULL)
504  {
505  Print_indent -= 1;
506 
507  if (t->right->right->type != TELIF)
508  PrintIndentedString ("else\n", 1, PF_MODE_NORMAL);
509 
510  PrintFunction (t->right->right, PF_MODE_NORMAL);
511  }
512  }
513 
514  if (t->type == TIF)
515  PrintIndentedString ("fi", -1, mode);
516 
517  return;
518 
519  case TCASE: /* CASE function */
520  PrintIndentedString ("case ", 1, PF_MODE_NORMAL);
521  PrintVarArg ((unsigned char *)t->str);
522  puts (" in");
523  PrintCaseCommand (t->left);
524  PrintIndentedString ("esac", -1, mode);
525  return;
526 
527  case TBRACE: /* {} statement */
529  if (t->left != (C_Op *)NULL)
530  PrintFunction (t->left, mode);
531 
533  return;
534 
535  case TTIME:
536  PrintIndentedString ("time\n", 1, PF_MODE_NORMAL);
537  PrintFunction (t->left, mode);
538  Print_indent--;
539  return;
540  }
541 }
542 
543 
544 /*
545  * Print a command line
546  */
547 
548 static void F_LOCAL PrintCommand (register C_Op *t, int mode)
549 {
550  IO_Actions **iopp;
551  char **wp;
552  int i;
553 
554 /* Parenthesis ? */
555 
556  if (t->type == TPAREN)
557  {
559  PrintFunction (t->left, PF_MODE_NORMAL);
560  PrintIndentedString (")", -1, PF_MODE_NO);
561 
562  }
563 
564  else
565  {
567 
568  /* Process arguments and assigments */
569 
570  for (i = 0, wp = t->vars; i < 2; i++)
571  {
572  if (wp != NOWORDS)
573  {
574  while (*wp != NOWORD)
575  {
576  PrintVarArg ((unsigned char *)*(wp++));
577 
578  if (*wp != NOWORD)
579  fputchar (CHAR_SPACE);
580  }
581  }
582 
583  wp = t->args;
584  }
585  }
586 
587 /* Set up anyother IO required */
588 
589  if ((iopp = t->ioact) != (IO_Actions **)NULL)
590  {
591  while (*iopp != (IO_Actions *)NULL)
592  PrintIOInformation (*(iopp++));
593  }
594 
595  PrintMode (mode);
596 }
597 
598 /*
599  * Print an argument or variable assigment string
600  */
601 
602 static void F_LOCAL PrintVarArg (unsigned char *string)
603 {
604  register unsigned c;
605  register bool quoted = FALSE;
606 
607  while (1)
608  {
609  switch ((c = *(string++)))
610  {
611  case WORD_EOS: /* end of string */
612  return;
613 
614  case WORD_CHAR: /* unquoted character */
615  fputMagicChar (*(string++));
616  break;
617 
618  case WORD_QCHAR: /* quoted character */
619  case WORD_QTCHAR:
620  if (!quoted)
621  fputchar (CHAR_META);
622 
623  fputMagicChar (*(string++));
624  break;
625 
626  case WORD_OQUOTE: /* opening " or ' */
627  case WORD_ODQUOTE:
628  quoted = TRUE;
629  fputchar ((c == WORD_OQUOTE) ? CHAR_SINGLE_QUOTE
631  break;
632 
633  case WORD_CQUOTE: /* closing " or ' */
634  case WORD_CDQUOTE:
635  quoted = FALSE;
636  fputchar ((c == WORD_CQUOTE) ? CHAR_SINGLE_QUOTE
638  break;
639 
640  case WORD_OARRAY: /* Opening ${...[...] ... */
641  fputchar (CHAR_OPEN_BRACKETS);
642  break;
643 
644  case WORD_CARRAY: /* Closing ${...[...] ... */
645  case WORD_OSUBST: /* opening ${ substitution */
646  if (c == WORD_CARRAY)
647  fputchar (CHAR_CLOSE_BRACKETS);
648 
649 /* Start of variable - output the name */
650 
651  else
652  {
653  fputchar (CHAR_VARIABLE);
654  fputchar (CHAR_OPEN_BRACES);
655 
656  while ((c = *(string++)) != 0)
657  fputchar (c);
658  }
659 
660 /* Check for some special characters */
661 
662  if ((*string != WORD_CSUBST) && (*string != WORD_OARRAY))
663  {
664  if (((c = *(string++)) & CHAR_MAGIC) &&
665  (IS_VarOp (c & 0x7f)))
666  {
667 
668 /* Check for %% or ## */
669  if (((c &= 0x7f) == CHAR_MATCH_START) ||
670  (c == CHAR_MATCH_END))
671  fputMagicChar (c);
672 
673 /* :?string case */
674  else
675  fputMagicChar (':');
676 
677  }
678 
679  fputMagicChar (c);
680  }
681 
682  break;
683 
684  case WORD_CSUBST: /* closing } of above */
685  fputchar (CHAR_CLOSE_BRACES);
686  break;
687 
688  case WORD_COMSUB: /* $() substitution (0 terminated) */
689  case WORD_OMATHS: /* opening $(()) substitution (0 term) */
690  fputchar (CHAR_VARIABLE);
691  fputchar (CHAR_OPEN_PARATHENSIS);
692 
693  if (c == WORD_OMATHS)
694  fputchar (CHAR_OPEN_PARATHENSIS);
695 
696  while (*string != 0)
697  fputMagicChar (*(string++));
698 
699  string++; /* Skip over the terminator */
700  fputchar (CHAR_CLOSE_PARATHENSIS);
701 
702  if (c == WORD_OMATHS)
703  fputchar (CHAR_CLOSE_PARATHENSIS);
704 
705  break;
706  }
707  }
708 }
709 
710 
711 /*
712  * Output a potentially magic character
713  */
714 
715 static void F_LOCAL fputMagicChar (unsigned int c)
716 {
717  if ((c & 0x60) == 0)
718  {
719  fputchar ((c & CHAR_MAGIC) ? CHAR_VARIABLE : '^');
720  fputchar (((c & 0x7F) | 0x40));
721  }
722 
723  else if ((c&0x7F) == 0x7F)
724  {
725  fputchar ((c & CHAR_MAGIC) ? CHAR_VARIABLE : '^');
726  fputchar ('?');
727  }
728 
729  else
730  fputchar (c);
731 }
732 
733 
734 /*
735  * Print the IO re-direction
736  */
737 
738 static void F_LOCAL PrintIOInformation (register IO_Actions *iop)
739 {
740  int unit = iop->io_unit;
741  int IOflag = iop->io_flag & IOTYPE;
742  char *type;
743  bool TermQuote = FALSE;
744 
745 /* Set up the IO type string and display it */
746 
747  type = IOTypes [IOflag - 1];
748 
749  if ((IOflag == IODUP) && (!unit))
750  type = "<&";
751 
752  printf (" %d%s", unit, type);
753 
754 /* Print clobber override and skip tabs information on here documents */
755 
756  if (iop->io_flag & IOCLOBBER)
757  fputchar (CHAR_PIPE);
758 
759  if (iop->io_flag & IOSKIP)
760  fputchar (CHAR_HYPHEN);
761 
762 /* Quoted here document ? */
763 
764  if ((TermQuote = C2bool ((IOflag == IOHERE) && (!(iop->io_flag & IOEVAL)))))
765  fputchar (CHAR_SINGLE_QUOTE);
766 
767 /* Here document names are in expanded format */
768 
769  (IOflag == IOHERE) ? (void)foputs (iop->io_name)
770  : (void)PrintVarArg ((unsigned char *)iop->io_name);
771 
772  if (TermQuote)
773  fputchar (CHAR_SINGLE_QUOTE);
774 }
775 
776 /*
777  * Print out the contents of a case statement
778  */
779 
781 {
782  register char **wp;
783 
784  while (t != (C_Op *)NULL)
785  {
786 
787 /* Print patterns (the conditions) */
788 
790 
791  for (wp = t->vars; *wp != NOWORD; )
792  {
793  PrintVarArg ((unsigned char *)*(wp++));
794 
795  if (*wp != NOWORD)
796  foputs (" | ");
797  }
798 
799  puts (" )");
800  Print_indent += 1;
801 
802 /* print the functions */
803 
804  PrintFunction (t->left, PF_MODE_NORMAL);
806  t = t->right;
807  }
808 }
809 
810 /*
811  * Print an indented string
812  */
813 
814 static void F_LOCAL PrintIndentedString (char *cp, int indent, int mode)
815 {
816  int i;
817 
818  if (indent < 0)
819  Print_indent += indent;
820 
821  for (i = 0; i < (Print_indent / 2); i++)
822  fputchar (CHAR_TAB);
823 
824  if (Print_indent % 2)
825  foputs (" ");
826 
827  foputs (cp);
828 
829 /* Append the mode */
830 
831  if ((mode != PF_MODE_NORMAL) || (indent < 0))
832  PrintMode (mode);
833 
834  if (indent > 0)
835  Print_indent += indent;
836 }
837 
838 /*
839  * Output mode
840  */
841 
842 static void F_LOCAL PrintMode (int mode)
843 {
844  if (mode == PF_MODE_ASYNC)
845  foputs (" &\n");
846 
847  else if (mode == PF_MODE_COPROC)
848  foputs (" |&\n");
849 
850  else if (mode == PF_MODE_NORMAL)
851  fputchar (CHAR_NEW_LINE);
852 }
853 
854 /*
855  * TWALK and TDELETE compare functions for FUNCTION, ALIAS and JOB trees
856  *
857  * Note: We know about these two function, so we know the key is always
858  * the first parameter. So we only pass the char * not the FunctionList
859  * pointer (in the case of JOB, its an int *)
860  */
861 
862 static int FindFunction (const void *key1, const void *key2)
863 {
864  return strcmp (key1, ((FunctionList *)key2)->tree->str);
865 }
866 
867 static int FindAlias (const void *key1, const void *key2)
868 {
869  return strcmp (key1, ((AliasList *)key2)->name);
870 }
871 
872 /* By string name */
873 
874 #if (OS_TYPE != OS_DOS)
875 static void FindJobByString (const void *key, VISIT visit, int level)
876 {
877  if (JobSearchEntry != (JobList **)NULL)
878  return;
879 
880  if (((visit == postorder) || (visit == leaf)) &&
881  (((*JobSearchKey == CHAR_MATCH_ANY) &&
882  (strstr (((JobList *)key)->Command, JobSearchKey) != (char *)NULL)) ||
883  ((*JobSearchKey != CHAR_MATCH_ANY) &&
884  (strncmp (JobSearchKey, ((JobList *)key)->Command,
885  strlen (JobSearchKey)) == 0))))
886  JobSearchEntry = (JobList **)&key;
887 }
888 
889 /* By process id */
890 
891 static int FindJobByPID (const void *key1, const void *key2)
892 {
893  return *(PID *)key1 - ((JobList *)key2)->pid;
894 }
895 
896 /* By session id */
897 
898 static int FindJobBySession (const void *key1, const void *key2)
899 {
900  return *(unsigned short *)key1 - ((JobList *)key2)->SessionId;
901 }
902 
903 /* By job number */
904 
905 static int FindJob (const void *key1, const void *key2)
906 {
907  return *(int *)key1 - ((JobList *)key2)->Number;
908 }
909 #endif
910 
911 /*
912  * Look up a function in the save tree
913  */
914 
915 FunctionList *LookUpFunction (char *name, bool AllowDot)
916 {
918 
919  if (AllowDot || (*name != '.'))
921 
922  return fp != (FunctionList **)NULL ? *fp : (FunctionList *)NULL;
923 }
924 
925 
926 /*
927  * TSEARCH compare functions for FUNCTION, ALIAS and JOB trees
928  */
929 
930 static int SearchFunction (const void *key1, const void *key2)
931 {
932  return strcmp (((FunctionList *)key1)->tree->str,
933  ((FunctionList *)key2)->tree->str);
934 }
935 
936 static int SearchAlias (const void *key1, const void *key2)
937 {
938  return strcmp (((AliasList *)key1)->name, ((AliasList *)key2)->name);
939 }
940 
941 #if (OS_TYPE != OS_DOS)
942 static int SearchJob (const void *key1, const void *key2)
943 {
944  return ((JobList *)key1)->Number - ((JobList *)key2)->Number;
945 }
946 #endif
947 
948 /*
949  * SAVE/DELETE A FUNCTION
950  */
951 
952 /*
953  * Save a function tree
954  */
955 
957 {
958  char *name = t->str;
959  register FunctionList *fp;
960  void (*save_signal)(int);
961  char *sname = name;
962 
963 /* Allow dot as the first character */
964 
965  if ((*name == '.') && (strlen (name) > (size_t)1))
966  sname++;
967 
968  if (!IsValidAliasName (sname, FALSE))
969  {
971  return FALSE;
972  }
973 
974 /* Create new entry */
975 
976  if ((fp = (FunctionList *)GetAllocatedSpace (sizeof (FunctionList)))
977  == (FunctionList *)NULL)
978  return FALSE;
979 
980 /* Delete the old function if it exists */
981 
982  DeleteFunction (t);
983 
984 /* Disable signals */
985 
986  save_signal = signal (SIGINT, SIG_IGN);
987  fp->tree = t;
988  fp->Traced = FALSE;
989 
990 /* Set up the tree */
991 
992  if (tsearch (fp, &FunctionTree, SearchFunction) != (void *)NULL)
993  {
994  SetMemoryAreaNumber ((void *)fp, 0);
996  }
997 
998 /* Restore signals */
999 
1000  signal (SIGINT, save_signal);
1001  return TRUE;
1002 }
1003 
1004 /*
1005  * Clean up functions on exit. We should just delete the files, but its
1006  * easier to delete the functions
1007  */
1008 
1010 {
1011  void (*save_signal)(int);
1012 
1013  save_signal = signal (SIGINT, SIG_IGN);
1015  signal (SIGINT, save_signal);
1016 }
1017 
1018 /*
1019  * Associate TREE WALK function to delete all functions
1020  */
1021 
1022 static void DeleteAFunction (const void *key, VISIT visit, int level)
1023 {
1024  if ((visit == postorder) || (visit == leaf))
1025  SaveReleaseExecuteTree ((*(FunctionList **)key)->tree,
1027 }
1028 
1029 /*
1030  * Delete a function tree
1031  */
1032 
1034 {
1035  char *name = t->str;
1036  register FunctionList *fp = LookUpFunction (name, TRUE);
1037  void (*save_signal)(int);
1038 
1039  if (fp == (FunctionList *)NULL)
1040  return;
1041 
1042 /* Disable signals */
1043 
1044  save_signal = signal (SIGINT, SIG_IGN);
1045 
1046 /* Free the tree and delete the entry */
1047 
1050  ReleaseMemoryCell ((void *)fp);
1051 
1052 /* Restore signals */
1053 
1054  signal (SIGINT, save_signal);
1055 }
1056 
1057 
1058 /*
1059  * Set ExTree areas to zero function
1060  */
1061 
1062 static void SaveTreeEntry (void *s)
1063 {
1064  SetMemoryAreaNumber (s, 0);
1065 }
1066 
1067 /*
1068  * Set/Free function tree area by recursively processing of tree
1069  */
1070 
1071 static void F_LOCAL SaveReleaseExecuteTree (C_Op *t, void (* func)(void *))
1072 {
1073  if (t == (C_Op *)NULL)
1074  return;
1075 
1076 /*
1077  * Process the tree - saving or deleting
1078  */
1079 
1080  if (t->str != (char *)NULL)
1081  (*func)((void *)t->str);
1082 
1083  SaveReleaseWordList (t->vars, func);
1084  SaveReleaseWordList (t->args, func);
1085  SaveReleaseIOActions (t->ioact, func);
1086  SaveReleaseExecuteTree (t->left, func);
1087  SaveReleaseExecuteTree (t->right, func);
1088 
1089  (*func)((void *)t);
1090 }
1091 
1092 
1093 /*
1094  * Save/Release a Block of words
1095  */
1096 
1097 static void F_LOCAL SaveReleaseWordList (char **list, void (* func)(void *))
1098 {
1099  char **Slist = list;
1100 
1101  if (list == NOWORDS)
1102  return;
1103 
1104 /* Ok - save/release it */
1105 
1106  while (*list != NOWORD)
1107  (*func)((void *)*(list++));
1108 
1109 /* Handle the block itself */
1110 
1111  (*func)((void *)Slist);
1112 }
1113 
1114 
1115 /*
1116  * Save/Release the IO Actions block
1117  */
1118 
1119 static void F_LOCAL SaveReleaseIOActions (IO_Actions **list, void (* func)(void *))
1120 {
1121  IO_Actions **Slist = list;
1122 
1123  if (list == (IO_Actions **)NULL)
1124  return;
1125 
1126 /* Ok - save/release it */
1127 
1128  while (*list != (IO_Actions *)NULL)
1129  {
1130 
1131 /*
1132  * If this is a Here Document, we need some clever processing to stop it
1133  * beening deleted or to delete it when the function disappears
1134  */
1135 
1136  if (((*list)->io_flag & IOTYPE) == IOHERE)
1137  {
1138 
1139 /*
1140  * Mark this is a function file name. This should stop the here processing
1141  * from deleting it
1142  */
1143 
1144  (*list)->io_flag |= IOFUNCTION;
1145 
1146 /* If this is a delete - delete the file name */
1147 
1148  if (func == ReleaseMemoryCell)
1149  unlink ((*list)->io_name);
1150  }
1151 
1152 /* OK, normal processing now!! */
1153 
1154  (*func)((void *)(*list)->io_name);
1155  (*func)((void *)*(list++));
1156  }
1157 
1158 /* Handle the block itself */
1159 
1160  (*func)((void *)Slist);
1161 }
1162 
1163 
1164 /*
1165  * FUNCTION TREE DUPLICATION
1166  */
1167 
1168 /*
1169  * Copy function tree area by recursively processing of tree
1170  */
1171 
1173 {
1174  C_Op *New_t;
1175 
1176  if (Old_t == (C_Op *)NULL)
1177  return (C_Op *)NULL;
1178 
1179 /*
1180  * This will copy function and for identifiers quite accidently
1181  */
1182 
1183  New_t = (C_Op *)DuplicateMemoryCell (Old_t);
1184  New_t->str = DuplicateMemoryArea (Old_t->str, char *);
1185  New_t->vars = DuplicateWordList (Old_t->vars);
1186  New_t->args = DuplicateWordList (Old_t->args);
1187  New_t->ioact = DuplicateIOActions (Old_t->ioact);
1188  New_t->left = DuplicateFunctionTree (Old_t->left);
1189  New_t->right = DuplicateFunctionTree (Old_t->right);
1190  return New_t;
1191 }
1192 
1193 
1194 /*
1195  * Duplicate a Block of words
1196  */
1197 
1198 static char ** F_LOCAL DuplicateWordList (char **list)
1199 {
1200  char **Nlist;
1201  char **Np;
1202 
1203  if ((Nlist = DuplicateMemoryArea (list, char **)) == (char **)NULL)
1204  return NOWORDS;
1205 
1206 /* Ok - dup it */
1207 
1208  for (Np = Nlist; *list != NOWORD; list++)
1209  *(Np++) = DuplicateMemoryArea (*list, char *);
1210 
1211 /* Terminate it */
1212 
1213  *Np = NOWORD;
1214 
1215  return Nlist;
1216 }
1217 
1218 
1219 /*
1220  * Duplicate the IO Actions block
1221  */
1222 
1224 {
1225  IO_Actions **Nlist;
1226  IO_Actions **Np;
1227 
1228  if ((Nlist = DuplicateMemoryArea (list,
1229  IO_Actions **)) == (IO_Actions **)NULL)
1230  return (IO_Actions **)NULL;
1231 
1232 /* Ok - dup it */
1233 
1234  for (Np = Nlist; *list != (IO_Actions *)NULL; list++, Np++)
1235  {
1237  (*Np)->io_name = DuplicateMemoryArea ((*list)->io_name, char *);
1238  }
1239 
1240 /* Terminate it */
1241 
1242  *Np = (IO_Actions *)NULL;
1243  return Nlist;
1244 }
1245 
1246 
1247 /*
1248  * Duplicate the tree
1249  */
1250 
1252 {
1253  ErrorPoint save_ErrorReturnPoint;
1254  jmp_buf new_ErrorReturnPoint;
1255  C_Op *New_t = (C_Op *)NULL;
1256 
1257 /* Set up for error handling - like out of space */
1258 
1259  save_ErrorReturnPoint = e.ErrorReturnPoint;
1260 
1261  if (SetErrorPoint (new_ErrorReturnPoint) == 0)
1262  New_t = DuplicateFunctionTree (Old_t);
1263 
1264  e.ErrorReturnPoint = save_ErrorReturnPoint;
1265  return New_t;
1266 }
1267 
1268 /*
1269  * Alias processing
1270  */
1271 
1272 void PrintAlias (char *name)
1273 {
1274  register AliasList *al = LookUpAlias (name, FALSE);
1275 
1276  if ((al == (AliasList *)NULL) || (al->value == null))
1277  return;
1278 
1279  printf (ListVarFormat, name, al->value);
1280 }
1281 
1282 /*
1283  * Print All Aliases
1284  */
1285 
1286 int PrintAllAlias (bool tracked)
1287 {
1288  DisplayListMode = tracked; /* Set mode */
1289 
1291  return 0;
1292 }
1293 
1294 /*
1295  * Save an alias
1296  */
1297 
1298 bool SaveAlias (char *name, char *arguments, bool tracked)
1299 {
1300  register AliasList *al;
1301  void (*save_signal)(int);
1302 
1303 
1304 /* Create new entry */
1305 
1306  if (((al = (AliasList *)GetAllocatedSpace (sizeof (AliasList)))
1307  == (AliasList *)NULL) ||
1308  ((al->name = GetAllocatedSpace (strlen (name) + 1)) == (char *)NULL))
1309  return FALSE;
1310 
1311  if ((arguments != null) &&
1312  ((al->value = GetAllocatedSpace (strlen (arguments) + 1))
1313  == (char *)NULL))
1314  return FALSE;
1315 
1316 /* Delete old name */
1317 
1318  DeleteAlias (name);
1319 
1320 /* Disable signals */
1321 
1322  save_signal = signal (SIGINT, SIG_IGN);
1323  strcpy (al->name, name);
1324 
1325 /* Add it to the tree */
1326 
1327  if (tsearch (al, &AliasTree, SearchAlias) != (void *)NULL)
1328  {
1329  SetMemoryAreaNumber ((void *)al, 0);
1330  SetMemoryAreaNumber ((void *)al->name, 0);
1331 
1332  if (arguments != null)
1333  SetMemoryAreaNumber ((void *)strcpy (al->value, arguments), 0);
1334 
1335  else
1336  al->value = null;
1337 
1338  if (tracked)
1339  al->AFlags = ALIAS_TRACKED;
1340  }
1341 
1342 
1343 /* Restore signals */
1344 
1345  signal (SIGINT, save_signal);
1346  return TRUE;
1347 }
1348 
1349 /*
1350  * Delete an alias
1351  */
1352 
1353 void DeleteAlias (char *name)
1354 {
1355  register AliasList **alp = (AliasList **)tfind (name, &AliasTree,
1356  FindAlias);
1357  void (*save_signal)(int);
1358  register AliasList *al;
1359 
1360  if (alp == (AliasList **)NULL)
1361  return;
1362 
1363 /* Disable signals */
1364 
1365  save_signal = signal (SIGINT, SIG_IGN);
1366 
1367 /* Delete the tree entry and release the memory */
1368 
1369  al = *alp;
1371  ReleaseMemoryCell ((void *)al->name);
1372 
1373  if (al->value != null)
1374  ReleaseMemoryCell ((void *)al->value);
1375 
1376  ReleaseMemoryCell ((void *)al);
1377 
1378 /* Restore signals */
1379 
1380  signal (SIGINT, save_signal);
1381 }
1382 
1383 /*
1384  * Search for an Alias
1385  */
1386 
1387 AliasList *LookUpAlias (char *name, bool CreateTracked)
1388 {
1389  AliasList **alp = (AliasList **)tfind (name, &AliasTree, FindAlias);
1390  char *path;
1391 
1392 /* If we found a tracked alias, which has been untracked, re-track it if
1393  * necesary
1394  */
1395 
1396  if ((alp != (AliasList **)NULL) && ((*alp)->value == null))
1397  {
1398  if (CreateTracked &&
1399  ((path = AllocateMemoryCell (FFNAME_MAX)) != (char *)NULL) &&
1401  {
1402  SetMemoryAreaNumber ((void *)path, 0);
1403  (*alp)->value = PATH_TO_UNIX (path);
1404  return *alp;
1405  }
1406 
1407  else
1408  return (AliasList *)NULL;
1409  }
1410 
1411  return (alp == (AliasList **)NULL) ? (AliasList *)NULL : *alp;
1412 }
1413 
1414 /*
1415  * Check for valid alias name
1416  */
1417 
1418 bool IsValidAliasName (char *s, bool alias)
1419 {
1420  if (!IS_VariableFC ((int)*s) || LookUpSymbol (s))
1421  return FALSE;
1422 
1423  while (IS_VariableSC ((int)*s))
1424  ++s;
1425 
1426  return C2bool (!*s);
1427 }
1428 
1429 /*
1430  * Untrack all Aliases
1431  */
1432 
1434 {
1436 }
1437 
1438 /*
1439  * The associate TWALK function
1440  */
1441 
1442 static void UntrackAlias (const void *key, VISIT visit, int level)
1443 {
1444  AliasList *al = *(AliasList **)key;
1445 
1446  if (((visit == postorder) || (visit == leaf)) &&
1447  (al->AFlags & ALIAS_TRACKED) && (al->value != null))
1448  {
1449  ReleaseMemoryCell ((void *)al->value);
1450  al->value = null;
1451  }
1452 }
1453 
1454 /*
1455  * Look up a job in the save tree
1456  */
1457 
1458 #if (OS_TYPE != OS_DOS)
1459 JobList *LookUpJob (int JobNumber)
1460 {
1461  JobList **jp = (JobList **)tfind (&JobNumber, &JobTree, FindJob);
1462 
1463  return jp != (JobList **)NULL ? *jp : (JobList *)NULL;
1464 }
1465 
1466 /*
1467  * Search for a job
1468  */
1469 
1470 JobList *SearchForJob (char *String)
1471 {
1472  JobSearchKey = String;
1473  JobSearchEntry = (JobList **)NULL;
1474 
1475  if ((strcmp (String, "%") == 0) || (strcmp (String, "+") == 0))
1476  return LookUpJob (CurrentJob);
1477 
1478  else if (strcmp (String, "-") == 0)
1479  return LookUpJob (PreviousJob);
1480 
1481 /* Search for it */
1482 
1483  twalk (JobTree, FindJobByString);
1484  return JobSearchEntry != (JobList **)NULL ? *JobSearchEntry
1485  : (JobList *)NULL;
1486 }
1487 
1488 /*
1489  * Delete a job by Session ID
1490  */
1491 
1492 void DeleteJobBySession (unsigned short SessionId)
1493 {
1494  register JobList **jpp = (JobList **)tfind (&SessionId, &JobTree,
1495  FindJobBySession);
1496 
1497  if (jpp != (JobList **)NULL)
1498  DeleteJob ((*jpp)->pid);
1499 }
1500 
1501 /*
1502  * Delete a job by Process ID
1503  */
1504 
1505 void DeleteJob (PID pid)
1506 {
1507  register JobList **jpp = (JobList **)tfind (&pid, &JobTree,
1508  FindJobByPID);
1509  void (*save_signal)(int);
1510  JobList *jp;
1511 
1512  if (jpp == (JobList **)NULL)
1513  return;
1514 
1515 /* Disable signals */
1516 
1517  save_signal = signal (SIGINT, SIG_IGN);
1518  jp = *jpp;
1519 
1520 /* Free the tree and delete the entry */
1521 
1522  tdelete (&pid, &JobTree, FindJobByPID);
1523 
1524  if (jp->Number == PreviousJob)
1525  PreviousJob = 0;
1526 
1527  if (jp->Number == CurrentJob)
1528  CurrentJob = PreviousJob;
1529 
1530  ReleaseMemoryCell ((void *)jp->Command);
1531  ReleaseMemoryCell ((void *)jp);
1532 
1533 /* Restore signals */
1534 
1535  signal (SIGINT, save_signal);
1536 }
1537 
1538 /*
1539  * Save a job ID
1540  */
1541 
1542 int AddNewJob (PID pid, unsigned short SessionId, char *command)
1543 {
1544  register JobList *jp;
1545  static int JobNumber = 1;
1546  void (*save_signal)(int);
1547  char *tmp;
1548 
1549 /* We if we can get the full command */
1550 
1551  if ((tmp = GetLastHistoryString ()) != (char *)NULL)
1552  command = tmp;
1553 
1554 /* Create new entry */
1555 
1556  if (((jp = (JobList *)GetAllocatedSpace (sizeof (JobList))) == (JobList *)NULL) ||
1557  ((jp->Command = GetAllocatedSpace (strlen (command) + 1)) == (char *)NULL))
1558  return 0;
1559 
1560 /* Get the next available job number */
1561 
1562  while (TRUE)
1563  {
1564  jp->pid = pid;
1565  jp->Number = JobNumber++;
1566  jp->SessionId = SessionId;
1567 
1568  if (JobNumber > 32000)
1569  JobNumber = 1;
1570 
1571  if (tfind (jp, &JobTree, SearchJob) == (void *)NULL)
1572  break;
1573  }
1574 
1575 /* Disable signals */
1576 
1577  save_signal = signal (SIGINT, SIG_IGN);
1578 
1579  if (tsearch (jp, &JobTree, SearchJob) != (void *)NULL)
1580  {
1581  SetMemoryAreaNumber ((void *)jp, 0);
1582  SetMemoryAreaNumber ((void *)strcpy (jp->Command, command), 0);
1583  PATH_TO_UNIX (jp->Command);
1584  }
1585 
1586 /* Restore signals */
1587 
1588  signal (SIGINT, save_signal);
1589 
1590  PreviousJob = CurrentJob;
1591  return CurrentJob = jp->Number;
1592 }
1593 
1594 /*
1595  * Display Jobs
1596  */
1597 
1598 int PrintJobs (bool Mode)
1599 {
1600  DisplayListMode = Mode; /* Set mode */
1601 
1602  twalk (JobTree, DisplayJob);
1603  return 0;
1604 }
1605 
1606 /*
1607  * Count the number of active jobs
1608  */
1609 
1610 int NumberOfActiveJobs (void)
1611 {
1612  NumberOfJobs = 0;
1613 
1614  twalk (JobTree, CountJob);
1615  return NumberOfJobs;
1616 }
1617 #endif
1618 
1619 /*
1620  * OS2 1.x - Parse the kernel process information
1621  */
1622 
1623 #if (OS_TYPE == OS_OS2) && (OS_SIZE == OS_16)
1624 static bool F_LOCAL Parse_V1ProcessTable (UCHAR * bBuf, V1ProcessStatus_t *pi)
1625 {
1626  USHORT sel, offs;
1627  USHORT type, tpid;
1628  USHORT count, kount;
1629  UCHAR buffer[256];
1630  UCHAR *cptr, *ptr;
1631 
1632  ptr = bBuf;
1633  sel = SELECTOROF (ptr);
1634 
1635  while ((type = *(USHORT *) ptr) != 0xFFFFU )
1636  {
1637  ptr += 2;
1638  offs = *(USHORT *) ptr;
1639  ptr += 2;
1640 
1641  switch ( type )
1642  {
1643  case 0: /* Process */
1644  if (pi->N_Processes >= pi->M_Processes)
1645  {
1646  V1Process_t **newp = (V1Process_t **)ReAllocateSpace (
1647  (void *)pi->V1Processes,
1648  (pi->M_Processes + 50) *
1649  sizeof (V1Process_t *));
1650 
1651  if (newp == (V1Process_t **)NULL)
1652  return TRUE;
1653 
1654  pi->V1Processes = newp;
1655  pi->M_Processes += 50;
1656  }
1657 
1658 /* Create the process entry */
1659 
1660  pi->V1Processes[pi->N_Processes] =
1661  (V1Process_t *) GetAllocatedSpace (sizeof (V1Process_t));
1662 
1663  if (pi->V1Processes[pi->N_Processes] == (V1Process_t *)NULL)
1664  return TRUE;
1665 
1666  pi->V1Processes[pi->N_Processes]->pid = *(USHORT *)ptr;
1667  ptr += 2;
1668  pi->V1Processes[pi->N_Processes]->ppid = *(USHORT *) ptr;
1669  ptr += 2;
1670  ptr += 2;
1671  pi->V1Processes[pi->N_Processes]->modhandle = *(USHORT *) ptr;
1672  pi->V1Processes[pi->N_Processes++]->threads = 0;
1673 
1674  break;
1675 
1676  case 1: /* Thread */
1677  ptr += 2;
1678  tpid = *(USHORT *) ptr;
1679 
1680 /* Increment the thread count for the process */
1681 
1682  for (count = 0; count < pi->N_Processes; count++)
1683  {
1684  if (pi->V1Processes[count]->pid == tpid)
1685  {
1686  ++pi->V1Processes[count]->threads;
1687  break;
1688  }
1689  }
1690 
1691  break;
1692 
1693  case 2: /* module */
1694  if (pi->N_Modules >= pi->M_Modules)
1695  {
1696  V1Module_t **newm = (V1Module_t **)ReAllocateSpace (
1697  (void *)pi->V1Modules,
1698  (pi->M_Modules + 50) *
1699  sizeof (V1Module_t *));
1700 
1701  if (newm == (V1Module_t **)NULL)
1702  return TRUE;
1703 
1704  pi->V1Modules = newm;
1705  pi->M_Modules += 50;
1706  }
1707 
1708  pi->V1Modules[pi->N_Modules]
1709  = (V1Module_t *)GetAllocatedSpace (sizeof(V1Module_t));
1710 
1711  if (pi->V1Modules[pi->N_Modules] == (V1Module_t *)NULL)
1712  return TRUE;
1713 
1714  pi->V1Modules[pi->N_Modules]->modhandle = *(USHORT *) ptr;
1715  ptr += 2;
1716  pi->V1Modules[pi->N_Modules]->max_dependents = *(USHORT *) ptr;
1717  ptr += 2;
1718  ptr += 2;
1719  ptr += 2;
1720 
1721  if (pi->V1Modules[pi->N_Modules] -> max_dependents)
1722  ptr += (pi->V1Modules[pi->N_Modules] -> max_dependents) * 2;
1723 
1724  for (cptr = buffer; *cptr++ = *ptr++;)
1725  continue;
1726 
1727  if ((pi->V1Modules[pi->N_Modules]->modname =
1728  StringCopy (buffer)) == null)
1729  return 1;
1730 
1731  ++pi->N_Modules;
1732 
1733  break;
1734 
1735  case 3: /* system semaphore */
1736  case 4: /* shared memory */
1737  break;
1738  }
1739 
1740  ptr = MAKEP(sel, offs);
1741  }
1742 
1743 /* Count modules */
1744 
1745  for (count = 0; count < pi->N_Processes; count++)
1746  {
1747  for (kount = 0; kount < pi->N_Modules; kount++)
1748  {
1749  if (pi->V1Processes[count]->modhandle ==
1750  pi->V1Modules[kount]->modhandle)
1751  {
1752  pi->V1Processes[count]->module = kount;
1753  break;
1754  }
1755  }
1756  }
1757 
1758 /* Count children */
1759 
1760  for (count = 0; count < pi->N_Processes; count++)
1761  {
1762  for (kount = 0; kount < pi->N_Processes; kount++)
1763  {
1764  if (pi->V1Processes[count]->pid == pi->V1Processes[kount]->ppid)
1765  (pi->V1Processes[count]->children)++;
1766  }
1767  }
1768 
1769  return FALSE;
1770 }
1771 
1772 /*
1773  * Process the process information
1774  */
1775 
1776 static void F_LOCAL PrintV1ProcessTree (pid_t pid, int indent,
1777  V1ProcessStatus_t *pi)
1778 {
1779  USHORT count;
1780  UCHAR *mName, pName[256];
1781 
1782  for (count = 0; count < pi->N_Processes; count++)
1783  {
1784  if ((indent && (pi->V1Processes[count]->ppid == (USHORT)pid)) ||
1785  ((!indent) && (pi->V1Processes[count]->pid == (USHORT)pid)))
1786  {
1787  if (pi->V1Processes[count]->module)
1788  {
1789  mName = pi->V1Modules[pi->V1Processes[count]->module]->modname;
1790  DosGetModName (pi->V1Processes[count]->modhandle,
1791  sizeof(pName), pName);
1792  }
1793 
1794  else
1795  {
1796  mName = "unknown"; /* Zombie process, */
1797  pName[0] = 0;
1798  }
1799 
1800  printf ("%5d %5d %3d %-8s %*s%s\n", pi->V1Processes[count]->pid,
1801  pi->V1Processes[count]->ppid,
1802  pi->V1Processes[count]->threads, mName, indent, "", pName);
1803 
1804  PrintV1ProcessTree (pi->V1Processes[count]->pid, indent + 2, pi);
1805  }
1806  }
1807 }
1808 
1809 
1810 static int SortV1Processes (void *p1, void *p2)
1811 {
1812  return (*(V1Process_t **)p1)->pid - (*(V1Process_t **)p2)->pid;
1813 }
1814 #endif
1815 
1816 /*
1817  * OS/2 2.x 32-bit version - Display Process Tree
1818  */
1819 
1820 #if (OS_TYPE == OS_OS2)
1821 static void F_LOCAL V2_DisplayProcessTree (USHORT pid, USHORT indent,
1822  V2ProcessStatus_t *ps)
1823 {
1824  V2Process_t *proc;
1825  UCHAR name[FFNAME_MAX];
1826  USHORT prty;
1827 
1828 /* Not sure if there isn't another termination method */
1829 
1830  for (proc = PTR (ps->ppi); (proc->ulEndIndicator != PROCESS_END_INDICATOR);
1831  proc = (V2Process_t *) PTR (proc->ptiFirst + proc->usThreadCount))
1832  {
1833  if ((indent && (proc->pidParent == pid)) ||
1834  ((!indent) && (proc->pid == pid)))
1835  {
1836 # if (OS_SIZE == OS_32)
1837  if (DosQueryModuleName (proc->hModRef, sizeof (name), name))
1838 # else
1839  if (DosGetModName (proc->hModRef, sizeof (name), name))
1840 # endif
1841  strcpy(name, "<unknown>");
1842 
1843  if (Dos32GetPrty (PRTYS_PROCESS, &prty, proc->pid))
1844  prty = 0;
1845 
1846  printf ("%5d %5d %3d %04x %*s%s\n", proc->pid, proc->pidParent,
1847  proc->usThreadCount, prty, indent, "", name);
1848 
1849  V2_DisplayProcessTree (proc->pid, indent + 2, ps);
1850  }
1851  }
1852 }
1853 
1854 /*
1855  * Print the Process Tree
1856  */
1857 
1858 int PrintProcessTree (pid_t pid)
1859 {
1860 # if (OS_SIZE == OS_16)
1861  USHORT rc;
1862 
1863 /* Switch on release number */
1864 
1865  if (_osmajor < 20)
1866  {
1867  UCHAR *pBuf = GetAllocatedSpace (0x2000);
1868  USHORT count;
1869  V1ProcessStatus_t pi;
1870 
1871  pi.M_Processes = pi.M_Modules = pi.N_Processes = pi.N_Modules = 0;
1872  pi.V1Processes = NULL;
1873  pi.V1Modules = NULL;
1874 
1875  if (pBuf == (UCHAR *)NULL)
1876  return 1;
1877 
1878  if (rc = Dos32QProcStatus (pBuf, 0x2000))
1879  return PrintWarningMessage ("jobs: DosQProcStatus failed\n%s",
1880  GetOSSystemErrorMessage (rc));
1881 
1882  if (Parse_V1ProcessTable (pBuf, &pi))
1883  return 1;
1884 
1885  ReleaseMemoryCell ((void *)pBuf);
1886 
1887  qsort ((void *)pi.V1Processes, pi.N_Processes, sizeof (V1Process_t *),
1888  SortV1Processes);
1889 
1890  puts (" PID PPID TC Name Program");
1891  PrintV1ProcessTree (pid, 0, &pi);
1892 
1893  for (count = 0; count < pi.N_Processes; count++)
1894  ReleaseMemoryCell ((void *)pi.V1Processes[count]);
1895 
1896  for (count = 0; count < pi.N_Modules; count++)
1897  {
1898  ReleaseMemoryCell ((void *)pi.V1Modules[count] -> modname);
1899  ReleaseMemoryCell ((void *)pi.V1Modules[count]);
1900  }
1901 
1902  ReleaseMemoryCell ((void *)pi.V1Processes);
1903  ReleaseMemoryCell ((void *)pi.V1Modules);
1904  }
1905 
1906 /*
1907  * OS2 2.0 - grap space, get the information and display it
1908  */
1909 
1910  else
1911 # endif
1912 # if defined (__WATCOMC__)
1913  {
1914  int res;
1915 
1916  if ((res = spawnlp (P_WAIT, "ps.exe", "ps", IntegerToString (pid),
1917  (char *)NULL)) < 0)
1918  return PrintWarningMessage ("jobs: cannot find ps.exe\n");
1919 
1920  else if (res)
1921  return 1;
1922  }
1923 # else
1924  {
1925  V2ProcessStatus_t *ps;
1926 
1927  if ((ps = GetProcessStatus ("jobs")) == (V2ProcessStatus_t *)NULL)
1928  return 1;
1929 
1930  puts (" PID PPID TC PRI Program");
1931  V2_DisplayProcessTree (pid, 0, ps);
1932  ReleaseMemoryCell ((void *)ps);
1933  }
1934 # endif
1935  return 0;
1936 }
1937 
1938 /*
1939  * Get OS/2 2.x Process Structure
1940  */
1941 
1942 static V2ProcessStatus_t * F_LOCAL GetProcessStatus (char *name)
1943 {
1944  OSCALL_RET rc;
1945  V2ProcessStatus_t *ps;
1946 
1947  if ((ps = (V2ProcessStatus_t *)GetAllocatedSpace (0x8000))
1948  == (V2ProcessStatus_t *)NULL)
1949  return (V2ProcessStatus_t *)NULL;
1950 
1951  if ((rc = Dos32QProcStatus (ps, 0x8000)))
1952  {
1953  PrintWarningMessage ("%s: DosQProcStatus failed\n%s", name,
1954  GetOSSystemErrorMessage (rc));
1955  return (V2ProcessStatus_t *)NULL;
1956  }
1957 
1958  return ps;
1959 }
1960 #endif
1961 
1962 /*
1963  * A unix version of print process tree
1964  */
1965 
1966 #if (OS_TYPE == OS_UNIX)
1967 int PrintProcessTree (pid_t pid)
1968 {
1969  return system ("ps") ? PrintWarningMessage ("jobs: cannot find ps\n")
1970  : 0;
1971 }
1972 #endif
1973 
1974 /*
1975  * A sort of times is available for OS/2. Not quite the complete UNIX
1976  * emulation, since it only reports current children. However!
1977  * I think the times in the process structure are in 1/100th second.
1978  */
1979 
1980 #if (OS_TYPE == OS_OS2) && (OS_SIZE == OS_32)
1981 int PrintTimes (void)
1982 {
1983  V2ProcessStatus_t *ps;
1984  V2Process_t *ppiLocal;
1985  V2Thread_t *ptiCurrent;
1986  time_t *Utime;
1987  time_t *Stime;
1988  int i;
1989  USHORT pid = getpid ();
1990  time_t tms_utime = 0;
1991  time_t tms_stime = 0;
1992  time_t tms_cutime = 0;
1993  time_t tms_cstime = 0;
1994 
1995 /* Initialise */
1996 
1997  if ((ps = GetProcessStatus ("times")) == (V2ProcessStatus_t *)NULL)
1998  return 1;
1999 
2000 /* Scan the process tree */
2001 
2002  for (ppiLocal = ps->ppi;
2003  (ppiLocal->ulEndIndicator != PROCESS_END_INDICATOR);
2004  ppiLocal = (V2Process_t *) (ppiLocal->ptiFirst +
2005  ppiLocal->usThreadCount))
2006  {
2007  if (ppiLocal->pidParent == pid)
2008  {
2009  Utime = &tms_cutime;
2010  Stime = &tms_cstime;
2011  }
2012 
2013  else if (ppiLocal->pid == pid)
2014  {
2015  Utime = &tms_utime;
2016  Stime = &tms_stime;
2017  }
2018 
2019 /* If neither - skip */
2020 
2021  else
2022  continue;
2023 
2024 /* Process threads */
2025 
2026  ptiCurrent = ppiLocal->ptiFirst;
2027 
2028  for (i = 0; i < ppiLocal->usThreadCount; i++, ptiCurrent++)
2029  {
2030  *Utime += ptiCurrent->ulUserTime;
2031  *Stime += ptiCurrent->ulSysTime;
2032  }
2033  }
2034 
2035 /* Dump the info */
2036 
2037  printf ("%ldm%.2ld.%.2lds %ldm%ld.%.2lds\n",
2038  tms_utime / 6000L, (tms_utime % 6000L) / 100L, tms_utime % 100L,
2039  tms_stime / 6000L, (tms_stime % 6000L) / 100L, tms_stime % 100L);
2040  printf ("%ldm%.2ld.%.2lds %ldm%ld.%.2lds\n",
2041  tms_cutime / 6000L, (tms_cutime % 6000L) / 100L, tms_cutime % 100L,
2042  tms_cstime / 6000L, (tms_cstime % 6000L) / 100L, tms_cstime % 100L);
2043 
2044  return 0;
2045 }
2046 #endif
2047 
2048 /* NT Version */
2049 
2050 #if (OS_TYPE == OS_NT)
2051 int PrintTimes (void)
2052 {
2053  FILETIME CreationTime;
2054  FILETIME ExitTime;
2055  FILETIME KernelTime;
2056  FILETIME UserTime;
2057 
2058  if (!GetProcessTimes (0, &CreationTime, &ExitTime, &KernelTime, &UserTime))
2059  return PrintWarningMessage ("times: GetProcesTimes failed\n%s",
2060  GetOSSystemErrorMessage (GetLastError ()));
2061 
2062  printf ("Kernel Time = %ld %ld\n", KernelTime.dwHighDateTime,
2063  KernelTime.dwLowDateTime);
2064  printf ("User Time = %ld %ld\n", UserTime.dwHighDateTime,
2065  UserTime.dwLowDateTime);
2066 
2067  return 0;
2068 }
2069 #endif
2070 
2071 /* UNIX Version */
2072 
2073 #if (OS_TYPE == OS_UNIX)
2074 int PrintTimes (void)
2075 {
2076  struct tms tms;
2077 
2078  times (&tms);
2079 
2080  printf ("%dm%.2d.%.2ds %dm%d.%.2ds\n%dm%.2d.%.2ds %dm%d.%.2ds\n",
2081  tms.tms_utime / (60L * (long)CLK_TCK),
2082  (tms.tms_utime % (60L * (long)CLK_TCK)) / (long)CLK_TCK,
2083  tms.tms_utime % (long)CLK_TCK,
2084  tms.tms_stime / (60L * (long)CLK_TCK),
2085  (tms.tms_stime % (60L * (long)CLK_TCK)) / (long)CLK_TCK,
2086  tms.tms_stime % (long)CLK_TCK,
2087  tms.tms_cutime / (60L * (long)CLK_TCK),
2088  (tms.tms_cutime % (60L * (long)CLK_TCK)) / (long)CLK_TCK,
2089  tms.tms_cutime % (long)CLK_TCK,
2090  tms.tms_cstime / (60L * (long)CLK_TCK),
2091  (tms.tms_cstime % (60L * (long)CLK_TCK)) / (long)CLK_TCK,
2092  tms.tms_cstime % (long)CLK_TCK);
2093 
2094  return 0;
2095 }
2096 #endif
2097 
2098 /*
2099  * Specials for EMX
2100  */
2101 
2102 #if defined (__EMX__) && (OS_TYPE == OS_OS2)
2103 USHORT Dos32GetPrty (USHORT usScope, PUSHORT pusPriority, USHORT pid)
2104 {
2105  return ((USHORT)
2106  (_THUNK_PROLOG (2 + 4 + 2);
2107  _THUNK_SHORT (usScope);
2108  _THUNK_FLAT (pusPriority);
2109  _THUNK_SHORT (pid);
2110  _THUNK_CALL (Dos16GetPrty)));
2111 }
2112 
2113 USHORT Dos32QProcStatus (PVOID pvProcData, USHORT usSize)
2114 {
2115  return ((USHORT)
2116  (_THUNK_PROLOG (4 + 2);
2117  _THUNK_FLAT (pvProcData);
2118  _THUNK_SHORT (usSize);
2119  _THUNK_CALL (Dos16QProcStatus)));
2120 }
2121 #endif
cp
Definition: action.c:1035
int level
Definition: afm2pl.c:1694
#define type(a)
Definition: aptex-macros.h:171
#define count(a)
Definition: aptex-macros.h:781
#define name
#define mode
Definition: aptex-macros.h:510
char * p2
Definition: bmpfont.h:62
int rc
Definition: bmpfont.h:9
char * p1
Definition: bmpfont.h:62
#define PTR(x)
Definition: bootstrap.c:36
static int GetLastError(void)
Definition: call.c:26
@ FALSE
Definition: dd.h:101
@ TRUE
Definition: dd.h:102
int process()
@ Number
Definition: psspecial.c:66
int strcmp()
Definition: coll.cpp:143
int printf()
char * strcpy()
static void
Definition: fpif.c:118
arguments
Definition: gendict.cpp:64
#define s
Definition: afcover.h:80
#define t
Definition: afcover.h:96
#define c(n)
Definition: gpos-common.c:150
struct child * children
Definition: job.c:229
char String
Definition: tttypes.h:35
#define NULL
Definition: ftobjs.h:61
small capitals from c petite p scientific i
Definition: afcover.h:80
sizeof(AF_ModuleRec)
#define unlink(file)
Definition: config.h:413
unsigned short USHORT
Definition: sfnt.h:36
char * strstr()
#define spawnlp
Definition: win32lib.h:91
#define system(p)
Definition: win32lib.h:269
#define getpid
Definition: win32lib.h:76
int indent
Definition: main.c:118
const char * alias
Definition: nkf.c:1121
int pid_t
Definition: types.h:81
long time_t
Definition: types.h:18
int strncmp()
#define qsort
Definition: includes.h:72
#define CLK_TCK
Definition: limits.h:101
cell * list
Definition: list_routines.h:30
static luaL_Reg func[]
Definition: except.c:32
#define size_t
Definition: glob.c:257
static double const pi
Definition: clipper.cpp:53
constexpr auto visit(Visitor &&visitor, Vs &&... vs) -> decltype((detail::all(lib::array< bool, sizeof...(Vs)>{{!vs.valueless_by_exception()...}}) ?(void) 0 :throw_bad_variant_access()), detail::visitation::variant::visit_value(lib::forward< Visitor >(visitor), lib::forward< Vs >(vs)...))
Definition: variant.hpp:2697
struct _module * module
Definition: obx.h:96
struct _proc * proc
Definition: obx.h:95
unsigned long ULONG
Definition: pdfgen.h:158
static bool ps
Definition: pdftocairo.cc:91
#define res(length)
Definition: picttoppm.c:287
set set set set set set set set set set set set set set set set set set set set *set set set macro pixldst op &r &cond WK op &r &cond WK op &r &cond WK else op &m &cond &ia op &r &cond WK else op &m &cond &ia elseif elseif else error unsupported base if elseif elseif else error unsupported unaligned pixldst unaligned endm macro pixst base base else pixldst base endif endm macro PF ptr
#define fp
static char modname[80]
Definition: buildvm_lib.c:15
int Np
Definition: rate.c:113
void DeleteFunction(C_Op *t)
Definition: sh10.c:1033
static void near SaveReleaseWordList(char **, void(*)(void *))
Definition: sh10.c:1097
int PrintAllAlias(bool tracked)
Definition: sh10.c:1286
static void near PrintVarArg(unsigned char *)
Definition: sh10.c:602
void DeleteAlias(char *name)
Definition: sh10.c:1353
bool SaveAlias(char *name, char *arguments, bool tracked)
Definition: sh10.c:1298
static void DisplayFunction(const void *, VISIT, int)
Definition: sh10.c:371
#define DuplicateMemoryArea(area, type)
Definition: sh10.c:324
static void near PrintIOInformation(IO_Actions *)
static int SearchAlias(const void *, const void *)
Definition: sh10.c:936
static void near PrintMode(int)
Definition: sh10.c:842
static bool DisplayListMode
Definition: sh10.c:314
static IO_Actions **near DuplicateIOActions(IO_Actions **)
Definition: sh10.c:1223
bool SaveFunction(C_Op *t)
Definition: sh10.c:956
static C_Op *near DuplicateFunctionTree(C_Op *)
Definition: sh10.c:1172
static void DeleteAFunction(const void *, VISIT, int)
Definition: sh10.c:1022
static char * IOTypes[]
Definition: sh10.c:318
void DeleteAllFunctions(void)
Definition: sh10.c:1009
static void UntrackAlias(const void *, VISIT, int)
Definition: sh10.c:1442
void PrintAlias(char *name)
Definition: sh10.c:1272
bool IsValidAliasName(char *s, bool alias)
Definition: sh10.c:1418
static void near PrintCaseCommand(C_Op *)
Definition: sh10.c:780
void UnTrackAllAliases(void)
Definition: sh10.c:1433
static int SearchFunction(const void *, const void *)
Definition: sh10.c:930
static void DisplayAlias(const void *, VISIT, int)
Definition: sh10.c:378
static void near fputMagicChar(unsigned int)
Definition: sh10.c:715
int PrintAllFunctions(void)
Definition: sh10.c:333
static int Print_indent
Definition: sh10.c:315
static char **near DuplicateWordList(char **list)
Definition: sh10.c:1198
FunctionList * LookUpFunction(char *name, bool AllowDot)
Definition: sh10.c:915
static void near PrintCommand(C_Op *, int)
C_Op * CopyFunction(C_Op *Old_t)
Definition: sh10.c:1251
static void near SaveReleaseIOActions(IO_Actions **, void(*)(void *))
Definition: sh10.c:1119
AliasList * LookUpAlias(char *name, bool CreateTracked)
Definition: sh10.c:1387
static int FindAlias(const void *, const void *)
Definition: sh10.c:867
void PrintFunction(register C_Op *t, int mode)
Definition: sh10.c:394
static void near SaveReleaseExecuteTree(C_Op *, void(*)(void *))
Definition: sh10.c:1071
static int FindFunction(const void *, const void *)
Definition: sh10.c:862
static void near PrintIndentedString(char *, int, int)
Definition: sh10.c:814
static void SaveTreeEntry(void *)
Definition: sh10.c:1062
#define F_LOCAL
Definition: sh.h:121
void * tdelete(void *, void **, int(*)(const void *, const void *))
#define CHAR_NEW_LINE
Definition: sh.h:1007
#define ALIAS_TRACKED
Definition: sh.h:1602
void * tfind(void *, void **, int(*)(const void *, const void *))
#define TFUNC
Definition: sh.h:1257
#define CHAR_HYPHEN
Definition: sh.h:1038
void FlushStreams(void)
Definition: sh8.c:1646
void twalk(const void *, void(*)(const void *, VISIT, int))
#define IS_VariableSC(c)
Definition: sh.h:1084
#define PF_MODE_COPROC
Definition: sh.h:2290
char * IntegerToString(int)
Definition: sh1.c:1171
#define IOCLOBBER
Definition: sh.h:1661
#define TSELECT
Definition: sh.h:1258
#define WORD_OQUOTE
Definition: sh.h:1270
#define TCOM
Definition: sh.h:1241
void * GetAllocatedSpace(size_t)
Definition: sh1.c:1241
#define C2bool(c)
Definition: sh.h:1476
#define EXTENSION_NOT_FOUND
Definition: sh.h:1188
void * AliasTree
Definition: sh6.c:153
#define WORD_OSUBST
Definition: sh.h:1274
#define CHAR_META
Definition: sh.h:1058
#define FFNAME_MAX
Definition: sh.h:981
#define TCOPROCESS
Definition: sh.h:1248
#define WORD_CQUOTE
Definition: sh.h:1271
#define WORD_OMATHS
Definition: sh.h:1276
#define CHAR_PLUS
Definition: sh.h:1037
#define PF_MODE_ASYNC
Definition: sh.h:2289
#define IS_VarOp(c)
Definition: sh.h:1091
#define CHAR_MATCH_END
Definition: sh.h:1034
#define TTIME
Definition: sh.h:1259
#define WORD_QCHAR
Definition: sh.h:1267
#define CHAR_VARIABLE
Definition: sh.h:1030
#define WORD_OARRAY
Definition: sh.h:1277
#define TFOR
Definition: sh.h:1247
#define PF_MODE_NORMAL
Definition: sh.h:2288
void * tsearch(void *, void **, int(*)(const void *, const void *))
#define WORD_ODQUOTE
Definition: sh.h:1272
#define CHAR_TAB
Definition: sh.h:1014
#define WORD_CHAR
Definition: sh.h:1266
#define IOEVAL
Definition: sh.h:1659
#define CHAR_DOUBLE_QUOTE
Definition: sh.h:1009
#define TPIPE
Definition: sh.h:1243
#define TCASE
Definition: sh.h:1249
#define WORD_CSUBST
Definition: sh.h:1275
void * FunctionTree
Definition: sh6.c:151
#define CHAR_SINGLE_QUOTE
Definition: sh.h:1008
int FindLocationOfExecutable(char *, char *)
Definition: system.c:716
#define TELIF
Definition: sh.h:1253
#define CHAR_MATCH_ANY
Definition: sh.h:1056
int LookUpSymbol(char *)
Definition: sh2.c:947
void DisplayLineWithControl(char *)
Definition: sh9.c:2755
char * ListVarFormat
Definition: sh6.c:264
#define CHAR_OPEN_PARATHENSIS
Definition: sh.h:1019
ShellFileEnvironment e
Definition: sh6.c:388
char LIT_done[]
Definition: sh6.c:259
#define NOWORD
Definition: sh.h:1149
#define TBRACE
Definition: sh.h:1255
#define CHAR_OPEN_BRACES
Definition: sh.h:1021
#define CHAR_OPEN_BRACKETS
Definition: sh.h:1023
#define IOFUNCTION
Definition: sh.h:1662
#define IOHERE
Definition: sh.h:1655
void ReleaseMemoryCell(void *)
Definition: sh1.c:2141
char * LIT_2Strings
Definition: sh6.c:267
#define TLIST
Definition: sh.h:1244
#define IOTYPE
Definition: sh.h:1651
#define SetErrorPoint(a)
Definition: sh.h:1678
#define IOSKIP
Definition: sh.h:1660
char * StringCopy(char *)
Definition: sh1.c:1325
void * DuplicateMemoryCell(void *)
Definition: sh1.c:1280
#define NOWORDS
Definition: sh.h:1150
#define IS_VariableFC(c)
Definition: sh.h:1083
#define ErrorPoint
Definition: sh.h:1677
void * ReAllocateSpace(void *, size_t)
Definition: sh1.c:1255
#define TOR
Definition: sh.h:1245
#define TWHILE
Definition: sh.h:1251
char * LIT_Invalidfunction
Definition: sh6.c:273
#define IODUP
Definition: sh.h:1657
int _osmajor
Definition: sh1.c:1
#define CHAR_MATCH_START
Definition: sh.h:1029
#define TIF
Definition: sh.h:1250
#define CHAR_MAGIC
Definition: sh.h:1060
void SetMemoryAreaNumber(void *, int)
Definition: sh1.c:2302
#define TPAREN
Definition: sh.h:1242
#define PF_MODE_NO
Definition: sh.h:2291
#define CHAR_PIPE
Definition: sh.h:1026
#define CHAR_CLOSE_BRACES
Definition: sh.h:1022
#define WORD_COMSUB
Definition: sh.h:1269
#define WORD_EOS
Definition: sh.h:1265
char * AllocateMemoryCell(size_t)
Definition: sh1.c:2071
#define CHAR_CLOSE_BRACKETS
Definition: sh.h:1024
#define P_WAIT
Definition: sh.h:330
#define TAND
Definition: sh.h:1246
#define PATH_TO_UNIX(x)
Definition: sh.h:1112
VISIT
Definition: sh.h:2439
@ postorder
Definition: sh.h:2439
@ leaf
Definition: sh.h:2439
int foputs(char *)
Definition: sh8.c:3390
#define WORD_CARRAY
Definition: sh.h:1278
#define CHAR_SPACE
Definition: sh.h:1012
#define OSCALL_RET
Definition: sh.h:650
#define CHAR_CLOSE_PARATHENSIS
Definition: sh.h:1020
#define WORD_CDQUOTE
Definition: sh.h:1273
#define TUNTIL
Definition: sh.h:1252
int PrintWarningMessage(char *,...)
Definition: sh1.c:1010
#define WORD_QTCHAR
Definition: sh.h:1268
char * BasicErrorMessage
Definition: sh6.c:242
#define TASYNC
Definition: sh.h:1256
Definition: sh.h:1594
int AFlags
Definition: sh.h:1597
char * name
Definition: sh.h:1595
char * value
Definition: sh.h:1596
A string of characters.
Definition: t1part.c:49
Definition: obx.h:117
Definition: obx.h:103
Definition: utils.c:300
int * ErrorReturnPoint
Definition: sh.h:1690
Definition: sh.h:1645
short io_flag
Definition: sh.h:1647
short io_unit
Definition: sh.h:1646
char * io_name
Definition: sh.h:1648
Definition: sh.h:1226
char ** args
Definition: sh.h:1228
struct ioword ** ioact
Definition: sh.h:1230
struct op * left
Definition: sh.h:1231
struct op * right
Definition: sh.h:1232
char * str
Definition: sh.h:1233
char ** vars
Definition: sh.h:1229
Definition: tpic.c:45
Definition: sh2.c:920
Definition: dvips.h:235
Definition: fio.h:71
pointer path
Definition: t1imager.h:36
void signal(SIGFPE, sig_err)
*job_name strlen((char *) job_name) - 4)
#define key
Definition: tex2xindy.c:753
return() int(((double) *(font_tbl[cur_fnt].wtbl+(int)(*(font_tbl[cur_fnt].char_wi+(int)(ch - font_tbl[cur_fnt].char_f)% 256)))/(double)(1L<< 20)) *(double) font_tbl[cur_fnt].scale)
int pid
Definition: ttf2pfb.c:129
static const char * pName
Definition: wrtjava.cpp:92