开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > IP电话/视频会议 > 查看源码
mswin.cxx
资源名称：pwlib_1.1pl17.zip　[点击查看]
上传用户：hzhsqp
上传日期：2007-01-06
资源大小：1600k
文件大小：24k
源码类别：

IP电话/视频会议

开发平台：

Visual C++

mswin.cxx：源码内容
  1. /*
  2.  * mswin.cxx
  3.  *
  4.  * General class implementations for 16 bit Windows.
  5.  *
  6.  * Portable Windows Library
  7.  *
  8.  * Copyright (c) 1993-1998 Equivalence Pty. Ltd.
  9.  *
  10.  * The contents of this file are subject to the Mozilla Public License
  11.  * Version 1.0 (the "License"); you may not use this file except in
  12.  * compliance with the License. You may obtain a copy of the License at
  13.  * http://www.mozilla.org/MPL/
  14.  *
  15.  * Software distributed under the License is distributed on an "AS IS"
  16.  * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
  17.  * the License for the specific language governing rights and limitations
  18.  * under the License.
  19.  *
  20.  * The Original Code is Portable Windows Library.
  21.  *
  22.  * The Initial Developer of the Original Code is Equivalence Pty. Ltd.
  23.  *
  24.  * Portions are Copyright (C) 1993 Free Software Foundation, Inc.
  25.  * All Rights Reserved.
  26.  *
  27.  * Contributor(s): ______________________________________.
  28.  *
  29.  * $Log: mswin.cxx,v $
  30.  * Revision 1.17  1998/09/24 03:30:51  robertj
  31.  * Added open software license.
  32.  *
  33.  * Revision 1.16  1996/02/15 14:55:02  robertj
  34.  * Win16 compatibility
  35.  *
  36.  * Revision 1.15  1996/01/28 02:55:33  robertj
  37.  * WIN16 support.
  38.  *
  39.  * Revision 1.14  1995/12/10 11:58:37  robertj
  40.  * Added WIN32 registry support for PConfig objects.
  41.  *
  42.  * Revision 1.13  1995/08/24 12:40:52  robertj
  43.  * Changed PChannel so not a PContainer.
  44.  *
  45.  * Revision 1.12  1995/07/02 01:24:45  robertj
  46.  * Added running of hidden VM for DOS program in PPipeChannel.
  47.  *
  48.  * Revision 1.11  1995/06/17 00:59:23  robertj
  49.  * Moved PPipeChannel::Execute from common dos/windows to individual files.
  50.  *
  51.  * Revision 1.10  1995/03/12 05:00:06  robertj
  52.  * Re-organisation of DOS/WIN16 and WIN32 platforms to maximise common code.
  53.  * Used built-in equate for WIN32 API (_WIN32).
  54.  *
  55.  * Revision 1.9  1995/01/09  12:28:00  robertj
  56.  * Added implementation for PConfig::Environment
  57.  *
  58.  * Revision 1.8  1994/10/23  05:41:29  robertj
  59.  * Fixed config file bugs.
  60.  *
  61.  * Revision 1.7  1994/08/22  00:18:02  robertj
  62.  * Fixed bug in serial comms timers.
  63.  *
  64.  * Revision 1.6  1994/08/04  13:24:27  robertj
  65.  * Added DCB so can set paraemters on closed channel.
  66.  *
  67.  * Revision 1.5  1994/07/27  06:00:10  robertj
  68.  * Backup
  69.  *
  70.  * Revision 1.4  1994/07/21  12:35:18  robertj
  71.  * *** empty log message ***
  72.  *
  73.  * Revision 1.3  1994/07/17  11:01:04  robertj
  74.  * Ehancements, implementation, bug fixes etc.
  75.  *
  76.  * Revision 1.2  1994/07/02  03:18:09  robertj
  77.  * Multi-threading implementation.
  78.  *
  79.  * Revision 1.1  1994/06/25  12:13:01  robertj
  80.  * Initial revision
  81.  *
  82. // Revision 1.1  1994/04/01  14:39:35  robertj
  83. // Initial revision
  84. //
  85.  */
  87. #include "ptlib.h"
  88. #include <errno.h>
  89. #include <fcntl.h>
  91. #include <stdresid.h>
  94. extern "C" HINSTANCE _hInstance;
  97. ///////////////////////////////////////////////////////////////////////////////
  98. // PTime
  100. PString PTime::GetTimeSeparator()
  101. {
  102.   PString str;
  103.   GetProfileString("intl", "sTime", ":", str.GetPointer(100), 99);
  104.   str.MakeMinimumSize();
  105.   return str;
  106. }
  109. BOOL PTime::GetTimeAMPM()
  110. {
  111.   return GetProfileInt("intl", "iTime", 0) != 0;
  112. }
  115. PString PTime::GetTimeAM()
  116. {
  117.   PString str;
  118.   GetProfileString("intl", "s1159", "am", str.GetPointer(100), 99);
  119.   str.MakeMinimumSize();
  120.   return str;
  121. }
  124. PString PTime::GetTimePM()
  125. {
  126.   PString str;
  127.   GetProfileString("intl", "s2359", "pm", str.GetPointer(100), 99);
  128.   str.MakeMinimumSize();
  129.   return str;
  130. }
  133. PString PTime::GetDayName(Weekdays dayOfWeek, NameType type)
  134. {
  135.   static const char * const weekdays[] = {
  136.     "Sunday", "Monday", "Tuesday", "Wednesday",
  137.     "Thursday", "Friday", "Saturday"
  138.   };
  139.   static const char * const abbrev_weekdays[] = {
  140.     "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
  141.   };
  142.   PString str;
  143.   if (LoadString(_hInstance, dayOfWeek+
  144.         (type != FullName ? PSTD_ID_STR_ABBREV_WEEKDAYS : PSTD_ID_STR_WEEKDAYS),
  145.         str.GetPointer(100), 99) == 0)
  146.     return (type != FullName ? abbrev_weekdays : weekdays)[dayOfWeek];
  147.   str.MakeMinimumSize();
  148.   return str;
  149. }
  152. PString PTime::GetDateSeparator()
  153. {
  154.   PString str;
  155.   GetProfileString("intl", "sDate", "-", str.GetPointer(100), 99);
  156.   str.MakeMinimumSize();
  157.   return str;
  158. }
  161. PString PTime::GetMonthName(Months month, NameType type)
  162. {
  163.   static const char * const months[] = { "",
  164.     "January", "February", "March", "April", "May", "June",
  165.     "July", "August", "September", "October", "November", "December"
  166.   };
  167.   static const char * const abbrev_months[] = {
  168.     "Jan", "Feb", "Mar", "Apr", "May", "Jun",
  169.     "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
  170.   };
  171.   PString str;
  172.   if (LoadString(_hInstance, month+
  173.        (UINT)(type != FullName ? PSTD_ID_STR_ABBREV_MONTHS : PSTD_ID_STR_MONTHS),
  174.        str.GetPointer(100), 99) == 0)
  175.     return (type != FullName ? abbrev_months : months)[month];
  176.   str.MakeMinimumSize();
  177.   return str;
  178. }
  181. PTime::DateOrder PTime::GetDateOrder()
  182. {
  183.   return (DateOrder)GetProfileInt("intl", "iDate", 0);
  184. }
  187. BOOL PTime::IsDaylightSavings()
  188. {
  189.   return FALSE;
  190. }
  193. int PTime::GetTimeZone(TimeZoneType type)
  194. {
  195.   return 0;
  196. }
  199. PString PTime::GetTimeZoneString(TimeZoneType type)
  200. {
  201.   return "";
  202. }
  205. ///////////////////////////////////////////////////////////////////////////////
  206. // PSerialChannel
  208. void PSerialChannel::Construct()
  209. {
  210.   char str[50];
  211.   strcpy(str, "com1");
  212.   GetProfileString("ports", str, "9600,n,8,1,x", &str[5], sizeof(str)-6);
  213.   str[4] = ':';
  214.   if (!BuildCommDCB(str, &deviceControlBlock)) {
  215.     osError = EINVAL;
  216.     lastError = BadParameter;
  217.   }
  218. }
  221. PString PSerialChannel::GetName() const
  222. {
  223.   if (IsOpen())
  224.     return psprintf("COM%i", os_handle+1);
  226.   return PString();
  227. }
  230. BOOL PSerialChannel::IsReadBlocked(PObject * obj)
  231. {
  232.   PSerialChannel & chan = *(PSerialChannel *)PAssertNULL(obj);
  233.   COMSTAT stat;
  234.   GetCommError(chan.os_handle, &stat);
  235.   return stat.cbInQue <= 0 &&
  236.          (chan.readTimeout == PMaxTimeInterval || chan.readTimer.IsRunning());
  237. }
  240. BOOL PSerialChannel::Read(void * buf, PINDEX len)
  241. {
  242.   lastReadCount = 0;
  244.   if (!IsOpen()) {
  245.     PThread::Yield();
  246.     osError = EBADF;
  247.     lastError = NotOpen;
  248.     return FALSE;
  249.   }
  251.   if (readTimeout != PMaxTimeInterval)
  252.     readTimer = readTimeout;
  253.   if (IsReadBlocked(this))
  254.     PThread::Current()->Block(&PSerialChannel::IsReadBlocked, this);
  256.   lastReadCount = ReadComm(os_handle, buf, len);
  257.   if (lastReadCount > 0)
  258.     return TRUE;
  260.   COMSTAT stat;
  261.   GetCommError(os_handle, &stat);
  262.   osError = EFAULT;
  263.   lastReadCount = -lastReadCount;
  264.   return lastReadCount > 0;
  265. }
  268. BOOL PSerialChannel::IsWriteBlocked(PObject * obj)
  269. {
  270.   PSerialChannel & chan = *(PSerialChannel *)PAssertNULL(obj);
  271.   COMSTAT stat;
  272.   GetCommError(chan.os_handle, &stat);
  273.   return stat.cbOutQue >= OutputQueueSize &&
  274.        (chan.writeTimeout == PMaxTimeInterval || chan.writeTimer.IsRunning());
  275. }
  278. BOOL PSerialChannel::Write(const void * buf, PINDEX len)
  279. {
  280.   lastWriteCount = 0;
  282.   if (!IsOpen()) {
  283.     osError = EBADF;
  284.     lastError = NotOpen;
  285.     return FALSE;
  286.   }
  288.   if (writeTimeout != PMaxTimeInterval)
  289.     writeTimer = writeTimeout;
  290.   if (IsWriteBlocked(this))
  291.     PThread::Current()->Block(&PSerialChannel::IsWriteBlocked, this);
  293.   lastWriteCount = WriteComm(os_handle, buf, len);
  294.   if (lastWriteCount <= 0) {
  295.     COMSTAT stat;
  296.     GetCommError(os_handle, &stat);
  297.     osError = EFAULT;
  298.     lastWriteCount = -lastWriteCount;
  299.   }
  300.   return lastWriteCount >= len;
  301. }
  304. BOOL PSerialChannel::Close()
  305. {
  306.   if (!IsOpen()) {
  307.     osError = EBADF;
  308.     lastError = NotOpen;
  309.     return FALSE;
  310.   }
  312.   BOOL retVal = CloseComm(os_handle) == 0;
  313.   os_handle = -1;
  314.   return retVal;
  315. }
  318. BOOL PSerialChannel::SetCommsParam(DWORD speed, BYTE data, Parity parity,
  319.                      BYTE stop, FlowControl inputFlow, FlowControl outputFlow)
  320. {
  321.   if (IsOpen())
  322.     PAssert(GetCommState(os_handle, &deviceControlBlock) == 0,
  323.                                                         POperatingSystemError);
  325.   switch (speed) {
  326.     case 0 :
  327.       break;
  328.     case 14400 :
  329.       deviceControlBlock.BaudRate = CBR_14400;
  330.       break;
  331.     case 19200 :
  332.       deviceControlBlock.BaudRate = CBR_19200;
  333.       break;
  334.     case 38400 :
  335.       deviceControlBlock.BaudRate = CBR_38400;
  336.       break;
  337.     case 56000 :
  338.       deviceControlBlock.BaudRate = CBR_56000;
  339.       break;
  340.     case 128000 :
  341.       deviceControlBlock.BaudRate = CBR_128000;
  342.       break;
  343.     case 256000 :
  344.       deviceControlBlock.BaudRate = CBR_256000;
  345.       break;
  346.     default :
  347.       if (speed > 9600) {
  348.         osError = EINVAL;
  349.         return FALSE;
  350.       }
  351.       deviceControlBlock.BaudRate = (UINT)speed;
  352.   }
  354.   if (data > 0)
  355.     deviceControlBlock.ByteSize = data;
  357.   switch (parity) {
  358.     case NoParity :
  359.       deviceControlBlock.Parity = NOPARITY;
  360.       break;
  361.     case OddParity :
  362.       deviceControlBlock.Parity = ODDPARITY;
  363.       break;
  364.     case EvenParity :
  365.       deviceControlBlock.Parity = EVENPARITY;
  366.       break;
  367.     case MarkParity :
  368.       deviceControlBlock.Parity = MARKPARITY;
  369.       break;
  370.     case SpaceParity :
  371.       deviceControlBlock.Parity = SPACEPARITY;
  372.       break;
  373.   }
  374.   switch (stop) {
  375.     case 1 :
  376.       deviceControlBlock.StopBits = ONESTOPBIT;
  377.       break;
  378.     case 2 :
  379.       deviceControlBlock.StopBits = TWOSTOPBITS;
  380.       break;
  381.   }
  382.   switch (inputFlow) {
  383.     case NoFlowControl :
  384.       deviceControlBlock.fRtsflow = FALSE;
  385.       deviceControlBlock.fInX = FALSE;
  386.       break;
  387.     case XonXoff :
  388.       deviceControlBlock.fRtsflow = FALSE;
  389.       deviceControlBlock.fInX = TRUE;
  390.       break;
  391.     case RtsCts :
  392.       deviceControlBlock.fRtsflow = TRUE;
  393.       deviceControlBlock.fInX = FALSE;
  394.       break;
  395.   }
  397.   switch (outputFlow) {
  398.     case NoFlowControl :
  399.       deviceControlBlock.fOutxCtsFlow = FALSE;
  400.       deviceControlBlock.fOutxDsrFlow = FALSE;
  401.       deviceControlBlock.fOutX = FALSE;
  402.       break;
  403.     case XonXoff :
  404.       deviceControlBlock.fOutxCtsFlow = FALSE;
  405.       deviceControlBlock.fOutxDsrFlow = FALSE;
  406.       deviceControlBlock.fOutX = TRUE;
  407.       break;
  408.     case RtsCts :
  409.       deviceControlBlock.fOutxCtsFlow = TRUE;
  410.       deviceControlBlock.fOutxDsrFlow = FALSE;
  411.       deviceControlBlock.fOutX = FALSE;
  412.       break;
  413.   }
  415.   if (!IsOpen()) {
  416.     osError = EBADF;
  417.     lastError = NotOpen;
  418.     lastError = BadParameter;
  419.     return FALSE;
  420.   }
  422.   if (SetCommState(&deviceControlBlock) < 0) {
  423.     osError = EINVAL;
  424.     return FALSE;
  425.   }
  427.   PAssert(GetCommState(os_handle, &deviceControlBlock) == 0,
  428.                                                         POperatingSystemError);
  429.   return TRUE;
  430. }
  433. BOOL PSerialChannel::Open(const PString & port, DWORD speed, BYTE data,
  434.        Parity parity, BYTE stop, FlowControl inputFlow, FlowControl outputFlow)
  435. {
  436.   Close();
  438.   os_handle = OpenComm(port, InputQueueSize, OutputQueueSize);
  439.   if (os_handle < 0) {
  440.     switch (os_handle) {
  441.       case IE_BADID :
  442.       case IE_HARDWARE :
  443.         osError = ENOENT;
  444.         lastError = NotFound;
  445.         break;
  446.       case IE_OPEN :
  447.         osError = EBUSY;
  448.         lastError = DeviceInUse;
  449.         break;
  450.       case IE_MEMORY :
  451.         osError = ENOMEM;
  452.         lastError = NoMemory;
  453.         break;
  454.       case IE_BAUDRATE :
  455.       case IE_BYTESIZE :
  456.         osError = EINVAL;
  457.         lastError = BadParameter;
  458.         break;
  459.       default :
  460.         osError = EFAULT;
  461.         lastError = Miscellaneous;
  462.     }
  463.     os_handle = -1;
  464.     return FALSE;
  465.   }
  467.   deviceControlBlock.Id = (BYTE)os_handle;
  468.   SetCommState(&deviceControlBlock);
  470.   if (!SetCommsParam(speed, data, parity, stop, inputFlow, outputFlow)) {
  471.     CloseComm(os_handle);
  472.     return FALSE;
  473.   }
  475.   SetCommEventMask(os_handle, EV_CTSS|EV_DSR|EV_RING|EV_RLSDS);
  476.   return TRUE;
  477. }
  480. BOOL PSerialChannel::SetSpeed(DWORD speed)
  481. {
  482.   return SetCommsParam(speed,
  483.                  0, DefaultParity, 0, DefaultFlowControl, DefaultFlowControl);
  484. }
  487. DWORD PSerialChannel::GetSpeed() const
  488. {
  489.   switch (deviceControlBlock.BaudRate) {
  490.     case CBR_110 :
  491.       return 110;
  492.     case CBR_300 :
  493.       return 300;
  494.     case CBR_600 :
  495.       return 600;
  496.     case CBR_1200 :
  497.       return 1200;
  498.     case CBR_2400 :
  499.       return 2400;
  500.     case CBR_4800 :
  501.       return 4800;
  502.     case CBR_9600 :
  503.       return 9600;
  504.     case CBR_14400 :
  505.       return 14400;
  506.     case CBR_19200 :
  507.       return 19200;
  508.     case CBR_38400 :
  509.       return 38400;
  510.     case CBR_56000 :
  511.       return 56000;
  512.     case CBR_128000 :
  513.       return 128000;
  514.     case CBR_256000 :
  515.       return 256000;
  516.   }
  517.   return deviceControlBlock.BaudRate;
  518. }
  521. BOOL PSerialChannel::SetDataBits(BYTE data)
  522. {
  523.   return SetCommsParam(0,
  524.               data, DefaultParity, 0, DefaultFlowControl, DefaultFlowControl);
  525. }
  528. BYTE PSerialChannel::GetDataBits() const
  529. {
  530.   return deviceControlBlock.ByteSize;
  531. }
  534. BOOL PSerialChannel::SetParity(Parity parity)
  535. {
  536.   return SetCommsParam(0,0, parity, 0, DefaultFlowControl, DefaultFlowControl);
  537. }
  540. PSerialChannel::Parity PSerialChannel::GetParity() const
  541. {
  542.   switch (deviceControlBlock.Parity) {
  543.     case ODDPARITY :
  544.       return OddParity;
  545.     case EVENPARITY :
  546.       return EvenParity;
  547.     case MARKPARITY :
  548.       return MarkParity;
  549.     case SPACEPARITY :
  550.       return SpaceParity;
  551.   }
  552.   return NoParity;
  553. }
  556. BOOL PSerialChannel::SetStopBits(BYTE stop)
  557. {
  558.   return SetCommsParam(0,
  559.                0, DefaultParity, stop, DefaultFlowControl, DefaultFlowControl);
  560. }
  563. BYTE PSerialChannel::GetStopBits() const
  564. {
  565.   return (BYTE)(deviceControlBlock.StopBits == ONESTOPBIT ? 1 : 2);
  566. }
  569. BOOL PSerialChannel::SetInputFlowControl(FlowControl flowControl)
  570. {
  571.   return SetCommsParam(0,0, DefaultParity, 0, flowControl, DefaultFlowControl);
  572. }
  575. PSerialChannel::FlowControl PSerialChannel::GetInputFlowControl() const
  576. {
  577.   if (deviceControlBlock.fRtsflow)
  578.     return RtsCts;
  579.   if (deviceControlBlock.fInX != 0)
  580.     return XonXoff;
  581.   return NoFlowControl;
  582. }
  585. BOOL PSerialChannel::SetOutputFlowControl(FlowControl flowControl)
  586. {
  587.   return SetCommsParam(0,0, DefaultParity, 0, DefaultFlowControl, flowControl);
  588. }
  591. PSerialChannel::FlowControl PSerialChannel::GetOutputFlowControl() const
  592. {
  593.   if (deviceControlBlock.fOutxCtsFlow != 0)
  594.     return RtsCts;
  595.   if (deviceControlBlock.fOutX != 0)
  596.     return XonXoff;
  597.   return NoFlowControl;
  598. }
  601. void PSerialChannel::SetDTR(BOOL state)
  602. {
  603.   if (!IsOpen()) {
  604.     osError = EBADF;
  605.     lastError = NotOpen;
  606.     return;
  607.   }
  609.   PAssert(EscapeCommFunction(os_handle, state ? SETDTR : CLRDTR) == 0,
  610.                                                       POperatingSystemError);
  611. }
  614. void PSerialChannel::SetRTS(BOOL state)
  615. {
  616.   if (!IsOpen()) {
  617.     osError = EBADF;
  618.     lastError = NotOpen;
  619.     return;
  620.   }
  622.   PAssert(EscapeCommFunction(os_handle, state ? SETRTS : CLRRTS) == 0,
  623.                                                       POperatingSystemError);
  624. }
  627. void PSerialChannel::SetBreak(BOOL state)
  628. {
  629.   if (!IsOpen()) {
  630.     osError = EBADF;
  631.     lastError = NotOpen;
  632.     return;
  633.   }
  635.   if (state)
  636.     PAssert(SetCommBreak(os_handle), POperatingSystemError);
  637.   else
  638.     PAssert(ClearCommBreak(os_handle), POperatingSystemError);
  639. }
  642. BOOL PSerialChannel::GetCTS()
  643. {
  644.   if (!IsOpen()) {
  645.     osError = EBADF;
  646.     lastError = NotOpen;
  647.     return FALSE;
  648.   }
  650.   return (GetCommEventMask(os_handle, 0)&EV_CTSS) != 0;
  651. }
  654. BOOL PSerialChannel::GetDSR()
  655. {
  656.   if (!IsOpen()) {
  657.     osError = EBADF;
  658.     lastError = NotOpen;
  659.     return FALSE;
  660.   }
  662.   return (GetCommEventMask(os_handle, 0)&EV_DSR) != 0;
  663. }
  666. BOOL PSerialChannel::GetDCD()
  667. {
  668.   if (!IsOpen()) {
  669.     osError = EBADF;
  670.     lastError = NotOpen;
  671.     return FALSE;
  672.   }
  674.   return (GetCommEventMask(os_handle, 0)&EV_RLSDS) != 0;
  675. }
  678. BOOL PSerialChannel::GetRing()
  679. {
  680.   if (!IsOpen()) {
  681.     osError = EBADF;
  682.     lastError = NotOpen;
  683.     return FALSE;
  684.   }
  686.   return (GetCommEventMask(os_handle, 0)&EV_RING) != 0;
  687. }
  690. PStringList PSerialChannel::GetPortNames()
  691. {
  692.   static char buf[] = "COM ";
  693.   PStringList ports;
  694.   for (char p = '1'; p <= '4'; p++) {
  695.     buf[3] = p;
  696.     ports.Append(new PString(buf));
  697.   }
  698.   return ports;
  699. }
  702. ///////////////////////////////////////////////////////////////////////////////
  703. // PPipeChannel
  705. BOOL PPipeChannel::Execute()
  706. {
  707.   if (hasRun)
  708.     return FALSE;
  710.   flush();
  711.   if (os_handle >= 0) {
  712.     _close(os_handle);
  713.     os_handle = -1;
  714.   }
  716.   static struct {
  717.     DWORD pifFlags;
  718.     DWORD displayFlags;
  719.     struct {
  720.       DWORD offset;
  721.       WORD  selector;
  722.     } exePath, programArguments, workingDirectory;
  723.     WORD  desiredV86Pages;
  724.     WORD  minimumV86Pages;
  725.     WORD  foregroundPriority;
  726.     WORD  backgroundPriority;
  727.     WORD  maximumEMS;
  728.     WORD  minimumEMS;
  729.     WORD  maximumXMS;
  730.     WORD  minimumXMS;
  731.     DWORD unknown;
  732.     char  windowTitle[128];
  733.   } seb = {
  734.     0x40000006,  // Runs in background, runs in window, close on exit
  735.     0x0000001f,  // Emulate text mode, no monitor ports
  736.     { 0, 0 },
  737.     { 0, 0 },
  738.     { 0, 0 },
  739.     0xffff, // desired memory
  740.     0xffff, // minimum memory
  741.     100,    // foreground priority
  742.     50,     // background priority
  743.     0x0400, // maximum EMS
  744.     0,      // minimum EMS
  745.     0x4000, // maximum XMS
  746.     0,      // minimum XMS
  747.     0,      // unknown
  748.     "PWLib Pipe Channel Process"
  749.   };
  751.   char * commandDotCom = getenv("COMSPEC");
  752.   if (commandDotCom == NULL)
  753.     commandDotCom = "C:\COMMAND.COM";
  754.   seb.exePath.selector = SELECTOROF(commandDotCom);
  755.   seb.exePath.offset   = OFFSETOF  (commandDotCom);
  757.   PString commandArguments = " /c " + subProgName;
  758.   const char * argumentPointer = commandArguments;
  759.   seb.programArguments.selector = SELECTOROF(argumentPointer);
  760.   seb.programArguments.offset   = OFFSETOF  (argumentPointer);
  761.   
  762.   static char * currentDirectory = ".";
  763.   seb.workingDirectory.selector = SELECTOROF(currentDirectory);
  764.   seb.workingDirectory.offset   = OFFSETOF  (currentDirectory);
  766.   void (FAR * shellEntry)();
  767.   _asm mov  ax,1684h;  //Get Shell VXDs protected mode entry point
  768.   _asm mov  bx,0017h;
  769.   _asm int  2fh;
  770.   _asm mov  word ptr [shellEntry], di;
  771.   _asm mov  word ptr [shellEntry+2], es;
  772.   if (shellEntry == NULL)
  773.     return FALSE;
  775.   _asm lea  di, word ptr seb;
  776.   _asm mov  dx, 3;
  777.   _asm push es;
  778.   _asm push ss;
  779.   _asm pop  es;
  780.   shellEntry();
  781.   _asm pop  es;
  783.   DWORD hVirtualMachine;
  784. #if defined(_MSC_VER)
  785.   _asm _emit 66h;
  786. #else
  787.   _asm db 66h;
  788. #endif
  789.   _asm mov  word ptr hVirtualMachine, ax; // Really EAX
  790.   if (hVirtualMachine == 0)
  791.     return FALSE;
  793.   if (fromChild.IsEmpty())
  794.     return TRUE;
  796.   // Wait for child to complete
  797.   
  799.   os_handle = _open(fromChild, _O_RDONLY);
  800.   return ConvertOSError(os_handle);
  801. }
  804. ///////////////////////////////////////////////////////////////////////////////
  805. // Configuration files
  807. void PConfig::Construct(Source src)
  808. {
  809.   switch (src) {
  810.     case System :
  811.       location = "WIN.INI";
  812.       break;
  814.     case Application :
  815.       PFilePath appFile = PProcess::Current()->GetFile();
  816.       location = appFile.GetDirectory() + appFile.GetTitle() + ".INI";
  817.       break;
  818.   }
  820.   source = src;
  821. }
  824. void PConfig::Construct(const PFilePath & filename)
  825. {
  826.   location = filename;
  827.   source = NumSources;
  828. }
  831. PStringList PConfig::GetSections()
  832. {
  833.   PStringList sections;
  835.   if (source != Environment) {
  836.     PString buf;
  837.     char * ptr = buf.GetPointer(10000);
  838.     GetPrivateProfileString(NULL, NULL, "", ptr, 9999, location);
  839.     while (*ptr != '') {
  840.       sections.AppendString(ptr);
  841.       ptr += strlen(ptr)+1;
  842.     }
  843.   }
  845.   return sections;
  846. }
  849. PStringList PConfig::GetKeys(const PString & section) const
  850. {
  851.   PStringList keys;
  853.   if (source == Environment) {
  854.     char ** ptr = _environ;
  855.     while (*ptr != NULL) {
  856.       PString buf = *ptr++;
  857.       keys.AppendString(buf.Left(buf.Find('=')));
  858.     }
  859.   }
  860.   else {
  861.     PString buf;
  862.     char * ptr = buf.GetPointer(10000);
  863.     GetPrivateProfileString(section, NULL, "", ptr, 9999, location);
  864.     while (*ptr != '') {
  865.       keys.AppendString(ptr);
  866.       ptr += strlen(ptr)+1;
  867.     }
  868.   }
  870.   return keys;
  871. }
  874. void PConfig::DeleteSection(const PString & section)
  875. {
  876.   if (source == Environment)
  877.     return;
  879.   PAssert(!section.IsEmpty(), PInvalidParameter);
  880.   PAssertOS(WritePrivateProfileString(section, NULL, NULL, location));
  881. }
  884. void PConfig::DeleteKey(const PString & section, const PString & key)
  885. {
  886.   PAssert(!key.IsEmpty(), PInvalidParameter);
  888.   if (source == Environment) {
  889.     PString str = key;
  890.     PAssert(str.Find('=') == P_MAX_INDEX, PInvalidParameter);
  891.     _putenv(str + "=");
  892.   }
  893.   else {
  894.     PAssert(!section.IsEmpty(), PInvalidParameter);
  895.     PAssertOS(WritePrivateProfileString(section, key, NULL, location));
  896.   }
  897. }
  900. PString PConfig::GetString(const PString & section,
  901.                                     const PString & key, const PString & dflt)
  902. {
  903.   PString str;
  905.   PAssert(!key.IsEmpty(), PInvalidParameter);
  907.   if (source == Environment) {
  908.     PAssert(key.Find('=') == P_MAX_INDEX, PInvalidParameter);
  909.     char * env = getenv(key);
  910.     if (env != NULL)
  911.       str = env;
  912.     else
  913.       str = dflt;
  914.   }
  915.   else {
  916.     PAssert(!section.IsEmpty(), PInvalidParameter);
  917.     GetPrivateProfileString(section, key, dflt,
  918.                                         str.GetPointer(1000), 999, location);
  919.     str.MakeMinimumSize();
  920.   }
  922.   return str;
  923. }
  926. void PConfig::SetString(const PString & section,
  927.                                    const PString & key, const PString & value)
  928. {
  929.   PAssert(!key.IsEmpty(), PInvalidParameter);
  931.   if (source == Environment) {
  932.     PString str = key;
  933.     PAssert(str.Find('=') == P_MAX_INDEX, PInvalidParameter);
  934.     _putenv(str + "=" + value);
  935.   }
  936.   else {
  937.     PAssert(!section.IsEmpty(), PInvalidParameter);
  938.     PAssertOS(WritePrivateProfileString(section, key, value, location));
  939.   }
  940. }
  944. ///////////////////////////////////////////////////////////////////////////////
  945. // Threads
  947. static char NEAR * NEAR * const StackBase = (char NEAR * NEAR *)0xa;
  948. static char NEAR * NEAR * const StackUsed = (char NEAR * NEAR *)0xc;
  949. static char NEAR * NEAR * const StackTop  = (char NEAR * NEAR *)0xe;
  951. void PThread::SwitchContext(PThread * from)
  952. {
  953.   if (from == this) // Switching to itself, ie is only thread
  954.     return;
  956.   if (setjmp(from->context) != 0) // Are being reactivated from previous yield
  957.     return;
  959.   // Save some magic global variables in MS-Windows DGROUP segment
  960.   from->stackBase = *StackBase;
  961.   from->stackTop  = *StackTop;
  962.   from->stackUsed = *StackTop - *StackUsed;
  964.   if (status == Starting) {
  965.     if (setjmp(context) != 0)
  966.       BeginThread();
  967.     context[3] = (int)stackTop-16;  // Change the stack pointer in jmp_buf
  968.   }
  970.   // Restore those MS-Windows magic global for the next context
  971.   *StackBase = stackBase;
  972.   *StackTop = stackTop;
  973.   *StackUsed = stackTop - stackUsed;
  974.   
  975.   longjmp(context, TRUE);
  976.   PAssertAlways("longjmp failed"); // Should never get here
  977. }
  980. ///////////////////////////////////////////////////////////////////////////////
  981. // PDynaLink
  983. PDynaLink::PDynaLink()
  984. {
  985.   _hDLL = NULL;
  986. }
  989. PDynaLink::PDynaLink(const PString & name)
  990. {
  991.   Open(name);
  992. }
  995. PDynaLink::~PDynaLink()
  996. {
  997.   Close();
  998. }
  1001. BOOL PDynaLink::Open(const PString & name)
  1002. {
  1003.   if ((_hDLL = LoadLibrary(name)) < HINSTANCE_ERROR)
  1004.     _hDLL = NULL;
  1005.   return _hDLL != NULL;
  1006. }
  1009. void PDynaLink::Close()
  1010. {
  1011.   if (_hDLL != NULL)
  1012.     FreeLibrary(_hDLL);
  1013. }
  1016. BOOL PDynaLink::IsLoaded() const
  1017. {
  1018.   return _hDLL != NULL;
  1019. }
  1022. BOOL PDynaLink::GetFunction(PINDEX index, Function & func)
  1023. {
  1024.   if (_hDLL == NULL)
  1025.     return FALSE;
  1027.   FARPROC p = GetProcAddress(_hDLL, (LPSTR)(DWORD)LOWORD(index));
  1028.   if (p == NULL)
  1029.     return FALSE;
  1031.   func = (Function)p;
  1032.   return TRUE;
  1033. }
  1036. BOOL PDynaLink::GetFunction(const PString & name, Function & func)
  1037. {
  1038.   if (_hDLL == NULL)
  1039.     return FALSE;
  1041.   FARPROC p = GetProcAddress(_hDLL, name);
  1042.   if (p == NULL)
  1043.     return FALSE;
  1045.   func = (Function)p;
  1046.   return TRUE;
  1047. }
  1051. // End Of File ///////////////////////////////////////////////////////////////