home *** CD-ROM | disk | FTP | other *** search
/ Programmer 7500 / MAX_PROGRAMMERS.iso / INFO / TURBOPAS / TPROUTN.ZIP / READENV.INC < prev    next >
Encoding:
Text File  |  1985-04-15  |  9.5 KB  |  149 lines
  1. { -------------------------------------------------------------------------- }
  2. {  READENV.INC                                                               }
  3. {          Copyright (C) 1985   24 Karat Consulting                          }
  4. {                               4702 S. Alaska St.                           }
  5. {                               Seattle, Washington 98118                    }
  6. {                                                                            }
  7. { These Turbo Pascal functions can be used to search the DOS environment     }
  8. { area.                                                                      }
  9. {                                                                            }
  10. { ENVSTR     returns a Turbo string containing the DOS environment area.     }
  11. {                                                                            }
  12. { NEXTENVSTR returns the next string (keyword and value) in the environment, }
  13. {            starting at the index passed.                                   }
  14. {                                                                            }
  15. { READENV    returns a string whose value is the current environment setting }
  16. {            for the keyword passed, or a null string if the keyword is not  }
  17. {            found.                                                          }
  18. {                                                                            }
  19. { Typical environment keywords are PATH (the DOS search path) and COMSPEC    } 
  20. { (the name of the command processor).  Remember that the environment passed }
  21. { to a program is a READ-ONLY copy of the real DOS environment...thus you    }
  22. { can't put new strings in from an executing program to be read by           }
  23. { another...but you can use it to communicate between two separate programs. }
  24. { The Pascal statements to use these functions are:                          }
  25. {                                                                            }
  26. {     StringVar := EnvStr;               (* move environment into string *)  }
  27. {     StringVar := ReadEnv(KeywordName); (* read environment for a key   *)  } 
  28. {     StringVar := NextEnvStr(Env,N);    (* read string in environment,  *)  }
  29. {                                        (*   starting at N              *)  }
  30. {  e.g.,                                                                     }
  31. {     Type                                                                   }
  32. {        Lstr = string[255];                                                 }
  33. {     Var                                                                    }
  34. {        Env,                                                                }
  35. {         Works : lstr;                                                      }
  36. {        Worki  : integer;                                                   }
  37. {     begin                                                                  }
  38. {        Env     := EnvStr;                                                  }
  39. {        writeln('Value for COMSPEC is ',ReadEnv('COMSPEC'));                }
  40. {        Worki   := 1;                                                       }
  41. {        writeln('Environment settings are: ');                              }
  42. {        repeat                                                              }
  43. {          Works := NextEnvStr(Env,Worki);                                   }
  44. {          if length(Works) > 0 then writeln(Works)                          }
  45. {        until length(Works) = 0                                             }
  46. {     end;                                                                   }
  47. {                                                                            }
  48. { The DOS command to put variables into the environment is:                  }
  49. {     SET keyword=value                                                      }
  50. { Keywords are stored uppercase, but their values are stored as is.  You can }
  51. { use this (undocumented) feature in .BAT files to read environment          }
  52. { variables:                                                                 }
  53. {                                                                            }
  54. {     ECHO The value of COMSPEC is %COMSPEC%                                 }
  55. {                                                                            }
  56. { that is, enclose the environment variable name in %'s to read its value.   }
  57. {                                                                            }
  58. { WARNING:  These functions assume an environment area of not more than 255  }
  59. { bytes; that is, the size of a Turbo string.  DOS sets up an initial        }
  60. { environment area of 127 bytes.  DOS will expand this dynamically when you  }
  61. { use the SET command for more environment variables, and more space is      }
  62. { needed.  (This only applies to SET commands issued at the DOS prompt, not  }
  63. { from within .BAT files).  However, if you have installed any resident      }
  64. { routines, you can't expand the environment area any further.  There are    }
  65. { several public domain routines to get around this limitation...however,    }
  66. { this routine assumes you haven't got more than the 255 bytes that Turbo    }
  67. { can handle in a string.  If you do, don't use this routine.                }
  68. {                                                                            }
  69. { This routine has been placed in the Public Domain by the author and copies }
  70. { may be freely made for non-commercial, demonstration, or evaluation        }
  71. { purposes.  If you use this routine in a program for sale or for commercial }
  72. { purposes, please send money ($2 to $5 would be sufficient) to the address  }
  73. { above; or if you make some wonderful correction or enhancement, please     }
  74. { notify us at the same address.  Thank you.                                 }
  75. {                                                                            }
  76. { Turbo Pascal is a Copyright of Borland International Inc.                  }
  77. { -------------------------------------------------------------------------- }
  78.  
  79. type
  80.   lstr = string[255];
  81.  
  82. function EnvStr: lstr;
  83. { -------------------------------------------------------------------------- }
  84. { This function returns a string containing the DOS environment.             }
  85. { -------------------------------------------------------------------------- }
  86. var
  87.   i    : integer;
  88.   ev   : integer absolute cseg:$002c;    { pointer to environment in PSP     }
  89.   evstr: lstr;
  90. begin
  91.   i := 0;                                { find real length of environment   }
  92.   while memw[ev:i] <> 0 do i := i+1;     { 2 null bytes ends the environment }
  93.   if i > 255 then i := 255;              { limit of Turbo string length      }
  94.   Move(mem[ev:0],evstr[1],i+1);          { move used bytes to Turbo string   }
  95.   evstr[0] := chr(i+1);                  {  and set length field             }
  96. end;
  97.  
  98. function NextEnvStr(evstr: lstr; var strt: integer): lstr;
  99. { -------------------------------------------------------------------------- }
  100. { This function gets the string starting at STRT in EVSTR, delimited by      }
  101. {   CHR(0).  A null string returned indicates the end of the environment.    }
  102. { -------------------------------------------------------------------------- }
  103. var
  104.   lst : lstr;
  105.   i   : integer;
  106. begin
  107.   i := strt;
  108.   if i > 1 then delete(evstr,1,i-1);     { remove unneeded part of string    }
  109.   i := pos(chr(0),evstr);                { find the next null char           }
  110.   if i < 2 then EnvStr := ''             { 1-end of env; 0-ERROR!!           }
  111.   else begin
  112.          move(evstr[1],lst[1],i-1);      { move string to temp string        }
  113.          lst[0] := chr(i-1);             { set string length field           }
  114.          strt := strt+i;                 { increment next field starting pos }
  115.          EnvStr := lst                   { return string                     }
  116.        end;
  117. end;
  118.                                     
  119. function ReadEnv(keyword: lstr): lstr;
  120. { -------------------------------------------------------------------------- }
  121. { This function looks in the DOS environment for KEYWORD, and returns its    }
  122. {   current value.  If KEYWORD isn't found, a null string is returned.       }
  123. { -------------------------------------------------------------------------- }
  124. var
  125.   i,lp   : integer;                         { work variables                 }
  126.   evarea,                                   { Turbo string for environment   }
  127.    estr  : lstr;
  128. begin
  129.   for i := 1 to length(keyword) do
  130.     keyword[i] := UpCase(keyword[i]);       { environment parms are uppercase}
  131.   if keyword[length(keyword)] <> '=' then   { environment format is:         }
  132.     keyword := keyword + '=';               {  KEYWORD=value                 }
  133.   lp := Length(keyword);                    { get length of parameter        }
  134.      
  135.   evarea := EnvStr;                         { get DOS environment into string}
  136.  
  137.   i := 1;                                   { set index to start at 1        }
  138.   estr := NextEnvStr(evarea,i);             { get first environment string   }
  139.  
  140.   while (estr <> '') and                { null string means exhausted search }
  141.         (Copy(estr,1,lp) <> keyword) do {  if it's not our keyword, skip it, }
  142.       estr := NextEnvStr(evarea,i);     {    and extract the next string     }
  143.   if estr <> '' then                    { we found the string requested      }
  144.     Delete(estr,1,lp);                  { remove the KEYWORD= part           }
  145.   ReadEnv := estr;                      { set return value                   }
  146. end; 
  147.  
  148.  
  149. remove the KEYWORD