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

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

IP电话/视频会议

开发平台：

Visual C++

osutils.cxx：源码内容
  1. /*
  2.  * osutils.cxx
  3.  *
  4.  * Operating System utilities.
  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: osutils.cxx,v $
  30.  * Revision 1.144  2000/06/26 11:17:20  robertj
  31.  * Nucleus++ port (incomplete).
  32.  *
  33.  * Revision 1.143  2000/06/26 09:27:16  robertj
  34.  * Added ability to get at the PTraceStream without timestamps etc, use UINT_MAX trace level.
  35.  *
  36.  * Revision 1.142  2000/06/02 01:38:07  craigs
  37.  * Fixed typos
  38.  *
  39.  * Revision 1.141  2000/06/02 01:35:56  craigs
  40.  * Added more guards for NULL PStrings in PConfigArg handling
  41.  *
  42.  * Revision 1.140  2000/05/25 14:45:07  robertj
  43.  * Fixed detection of real argument over configured value.
  44.  *
  45.  * Revision 1.139  2000/05/25 13:47:51  robertj
  46.  * Fixed warning with GNU.
  47.  *
  48.  * Revision 1.138  2000/05/25 11:05:55  robertj
  49.  * Added PConfigArgs class so can save program arguments to config files.
  50.  *
  51.  * Revision 1.137  2000/05/05 10:08:29  robertj
  52.  * Fixed some GNU compiler warnings
  53.  *
  54.  * Revision 1.136  2000/04/28 06:58:50  robertj
  55.  * Fixed bug introduced when added Ashley Untts fix, forgot to take out old code!
  56.  *
  57.  * Revision 1.135  2000/04/27 04:19:27  robertj
  58.  * Fixed bug in restarting free running timers, thanks Ashley Unitt.
  59.  *
  60.  * Revision 1.134  2000/04/03 18:42:40  robertj
  61.  * Added function to determine if PProcess instance is initialised.
  62.  *
  63.  * Revision 1.133  2000/03/29 20:12:00  robertj
  64.  * Fixed GNU C++ warning
  65.  *
  66.  * Revision 1.132  2000/03/29 01:55:52  robertj
  67.  * Fixed infinite recursion on PProcess::Current() = NULL assertion.
  68.  *
  69.  * Revision 1.131  2000/03/02 05:43:12  robertj
  70.  * Fixed handling of NULL pointer on current thread in PTRACE output.
  71.  *
  72.  * Revision 1.130  2000/02/29 12:26:14  robertj
  73.  * Added named threads to tracing, thanks to Dave Harvey
  74.  *
  75.  * Revision 1.129  2000/02/17 11:34:28  robertj
  76.  * Changed PTRACE output to help line up text after filename output.
  77.  *
  78.  * Revision 1.128  2000/01/06 14:09:42  robertj
  79.  * Fixed problems with starting up timers,losing up to 10 seconds
  80.  *
  81.  * Revision 1.127  1999/10/19 09:21:30  robertj
  82.  * Added functions to get current trace options and level.
  83.  *
  84.  * Revision 1.126  1999/10/14 08:08:27  robertj
  85.  * Fixed problem, assuring millisecond accuracy in timestamp of trace output.
  86.  *
  87.  * Revision 1.125  1999/09/14 13:02:52  robertj
  88.  * Fixed PTRACE to PSYSTEMLOG conversion problem under Unix.
  89.  *
  90.  * Revision 1.124  1999/09/13 13:15:07  robertj
  91.  * Changed PTRACE so will output to system log in PServiceProcess applications.
  92.  *
  93.  * Revision 1.123  1999/08/22 12:54:35  robertj
  94.  * Fixed warnings about inlines on older GNU compiler
  95.  *
  96.  * Revision 1.122  1999/06/23 14:19:46  robertj
  97.  * Fixed core dump problem with SIGINT/SIGTERM terminating process.
  98.  *
  99.  * Revision 1.121  1999/06/14 07:59:38  robertj
  100.  * Enhanced tracing again to add options to trace output (timestamps etc).
  101.  *
  102.  * Revision 1.120  1999/04/26 08:06:51  robertj
  103.  * Added missing function in cooperative threading.
  104.  *
  105.  * Revision 1.119  1999/03/01 13:51:30  craigs
  106.  * Fixed ugly little bug in the cooperative multithreading that meant that threads blocked
  107.  * on timers didn't always get rescheduled.
  108.  *
  109.  * Revision 1.118  1999/02/23 10:13:31  robertj
  110.  * Changed trace to only diplay filename and not whole path.
  111.  *
  112.  * Revision 1.117  1999/02/23 07:11:27  robertj
  113.  * Improved trace facility adding trace levels and #define to remove all trace code.
  114.  *
  115.  * Revision 1.116  1998/11/30 12:45:54  robertj
  116.  * Fissioned into pchannel.cxx and pconfig.cxx
  117.  *
  118.  * Revision 1.115  1998/11/24 01:17:33  robertj
  119.  * Type discrepency between declaration and definition for PFile::SetPosition
  120.  *
  121.  * Revision 1.114  1998/11/06 02:37:53  robertj
  122.  * Fixed the fix for semaphore timeout race condition.
  123.  *
  124.  * Revision 1.113  1998/11/03 10:52:19  robertj
  125.  * Fixed bug in semaphores with timeout saying timed out when really signalled.
  126.  *
  127.  * Revision 1.112  1998/11/03 03:44:05  robertj
  128.  * Fixed missng strings on multiple parameters of same letter.
  129.  *
  130.  * Revision 1.111  1998/11/02 10:13:01  robertj
  131.  * Removed GNU warning.
  132.  *
  133.  * Revision 1.110  1998/11/01 04:56:53  robertj
  134.  * Added BOOl return value to Parse() to indicate there are parameters available.
  135.  *
  136.  * Revision 1.109  1998/10/31 14:02:20  robertj
  137.  * Removed StartImmediate capability as causes race condition in preemptive version.
  138.  *
  139.  * Revision 1.108  1998/10/31 12:47:10  robertj
  140.  * Added conditional mutex and read/write mutex thread synchronisation objects.
  141.  *
  142.  * Revision 1.107  1998/10/30 12:24:15  robertj
  143.  * Added ability to get all key values as a dictionary.
  144.  * Fixed warnings in GNU C.
  145.  *
  146.  * Revision 1.106  1998/10/30 11:22:15  robertj
  147.  * Added constructors that take strings as well as const char *'s.
  148.  *
  149.  * Revision 1.105  1998/10/30 05:25:09  robertj
  150.  * Allow user to shift past some arguments before parsing for the first time.
  151.  *
  152.  * Revision 1.104  1998/10/29 05:35:17  robertj
  153.  * Fixed porblem with GetCount() == 0 if do not call Parse() function.
  154.  *
  155.  * Revision 1.103  1998/10/28 03:26:43  robertj
  156.  * Added multi character arguments (-abc style) and options precede parameters mode.
  157.  *
  158.  * Revision 1.102  1998/10/28 00:59:49  robertj
  159.  * New improved argument parsing.
  160.  *
  161.  * Revision 1.101  1998/10/19 00:19:59  robertj
  162.  * Moved error and trace stream functions to common code.
  163.  *
  164.  * Revision 1.100  1998/10/18 14:28:45  robertj
  165.  * Renamed argv/argc to eliminate accidental usage.
  166.  *
  167.  * Revision 1.99  1998/10/13 14:06:28  robertj
  168.  * Complete rewrite of memory leak detection code.
  169.  *
  170.  * Revision 1.98  1998/09/24 07:23:54  robertj
  171.  * Moved structured fiel into separate module so don't need silly implementation file for GNU C.
  172.  *
  173.  * Revision 1.97  1998/09/23 06:22:24  robertj
  174.  * Added open source copyright license.
  175.  *
  176.  * Revision 1.96  1998/06/13 15:11:56  robertj
  177.  * Added stack check in Yield().
  178.  * Added immediate schedule of semaphore timeout thread.
  179.  *
  180.  * Revision 1.95  1998/05/30 13:28:18  robertj
  181.  * Changed memory check code so global statics are not included in leak check.
  182.  * Fixed deadlock in cooperative threading.
  183.  * Added PSyncPointAck class.
  184.  *
  185.  * Revision 1.94  1998/05/25 09:05:56  robertj
  186.  * Fixed close of channels on destruction.
  187.  *
  188.  * Revision 1.93  1998/04/07 13:33:33  robertj
  189.  * Changed startup code to support PApplication class.
  190.  *
  191.  * Revision 1.92  1998/03/29 06:16:45  robertj
  192.  * Rearranged initialisation sequence so PProcess descendent constructors can do "things".
  193.  *
  194.  * Revision 1.91  1998/03/20 03:18:17  robertj
  195.  * Added special classes for specific sepahores, PMutex and PSyncPoint.
  196.  *
  197.  * Revision 1.90  1998/02/05 13:33:12  robertj
  198.  * Fixed close of non-autodelete PIndirectChannels
  199.  *
  200.  * Revision 1.89  1998/02/03 06:19:55  robertj
  201.  * Added new function to read a block with minimum number of bytes.
  202.  *
  203.  * Revision 1.88  1998/01/26 00:47:13  robertj
  204.  * Added functions to get/set 64bit integers from a PConfig.
  205.  *
  206.  * Revision 1.87  1998/01/04 07:22:16  robertj
  207.  * Fixed bug in thread deletion not removing it from active thread list.
  208.  *
  209.  * Revision 1.86  1997/10/10 10:41:22  robertj
  210.  * Fixed problem with cooperative threading and Sleep() function returning immediately.
  211.  *
  212.  * Revision 1.85  1997/08/28 12:49:00  robertj
  213.  * Fixed possible assert on exit of application.
  214.  *
  215.  * Revision 1.84  1997/07/08 13:08:12  robertj
  216.  * DLL support.
  217.  *
  218.  * Revision 1.83  1997/04/27 05:50:15  robertj
  219.  * DLL support.
  220.  *
  221.  * Revision 1.82  1997/02/09 04:05:56  robertj
  222.  * Changed PProcess::Current() from pointer to reference.
  223.  *
  224.  * Revision 1.81  1997/02/05 11:51:42  robertj
  225.  * Changed current process function to return reference and validate objects descendancy.
  226.  *
  227.  * Revision 1.80  1996/12/21 05:54:38  robertj
  228.  * Fixed possible deadlock in timers.
  229.  *
  230.  * Revision 1.79  1996/12/05 11:44:22  craigs
  231.  * Made indirect close from different thread less likely to have
  232.  * race condition
  233.  *
  234.  * Revision 1.78  1996/11/30 12:08:42  robertj
  235.  * Removed extraneous compiler warning.
  236.  *
  237.  * Revision 1.77  1996/11/10 21:05:43  robertj
  238.  * Fixed bug of missing flush in close of indirect channel.
  239.  *
  240.  * Revision 1.76  1996/10/08 13:07:07  robertj
  241.  * Fixed bug in indirect channel being reopened double deleting subchannel.
  242.  *
  243.  * Revision 1.75  1996/09/14 13:09:37  robertj
  244.  * Major upgrade:
  245.  *   rearranged sockets to help support IPX.
  246.  *   added indirect channel class and moved all protocols to descend from it,
  247.  *   separating the protocol from the low level byte transport.
  248.  *
  249.  * Revision 1.74  1996/08/11 06:53:04  robertj
  250.  * Fixed bug in Sleep() function (nonpreemptive version).
  251.  *
  252.  * Revision 1.73  1996/07/27 04:12:09  robertj
  253.  * Fixed bug in timer thread going into busy loop instead of blocking.
  254.  *
  255.  * Revision 1.72  1996/07/15 10:36:12  robertj
  256.  * Fixed bug in timer on startup, getting LARGE times timing out prematurely.
  257.  *
  258.  * Revision 1.71  1996/06/28 13:22:43  robertj
  259.  * Rewrite of timers to make OnTimeout more thread safe.
  260.  *
  261.  * Revision 1.70  1996/06/13 13:31:05  robertj
  262.  * Rewrite of auto-delete threads, fixes Windows95 total crash.
  263.  *
  264.  * Revision 1.69  1996/06/03 10:01:31  robertj
  265.  * Fixed GNU support bug fix for the fix.
  266.  *
  267.  * Revision 1.68  1996/06/01 05:03:37  robertj
  268.  * Fixed GNU compiler having difficulty with PTimeInterval *this.
  269.  *
  270.  * Revision 1.67  1996/05/26 03:46:56  robertj
  271.  * Compatibility to GNU 2.7.x
  272.  *
  273.  * Revision 1.66  1996/05/23 23:05:07  robertj
  274.  * Fixed process filename on MSOS platforms.
  275.  *
  276.  * Revision 1.65  1996/05/23 09:56:57  robertj
  277.  * Added mutex to timer list.
  278.  *
  279.  * Revision 1.64  1996/05/18 09:18:33  robertj
  280.  * Added mutex to timer list.
  281.  *
  282.  * Revision 1.63  1996/05/09 12:19:00  robertj
  283.  * Resolved C++ problems with 64 bit PTimeInterval for Mac platform.
  284.  *
  285.  * Revision 1.62  1996/04/14 02:53:34  robertj
  286.  * Split serial and pipe channel into separate compilation units for Linux executable size reduction.
  287.  *
  288.  * Revision 1.61  1996/04/10 12:51:29  robertj
  289.  * Fixed startup race condtion in timer thread.
  290.  *
  291.  * Revision 1.60  1996/04/09 03:32:58  robertj
  292.  * Fixed bug in config GetTime() cannot use PTime(0) in western hemisphere.
  293.  *
  294.  * Revision 1.59  1996/04/02 11:29:19  robertj
  295.  * Eliminated printing of patch level in version when there isn't one.
  296.  *
  297.  * Revision 1.58  1996/03/31 09:06:14  robertj
  298.  * Fixed WriteString() so works with sockets.
  299.  * Changed PPipeSokcet argument string list to array.
  300.  *
  301.  * Revision 1.57  1996/03/16 04:51:50  robertj
  302.  * Fixed yet another bug in the scheduler.
  303.  *
  304.  * Revision 1.56  1996/03/12 11:30:50  robertj
  305.  * Moved PProcess destructor to platform dependent code.
  306.  *
  307.  * Revision 1.55  1996/03/05 14:05:51  robertj
  308.  * Fixed some more bugs in scheduling.
  309.  *
  310.  * Revision 1.54  1996/03/04 12:22:46  robertj
  311.  * Fixed threading for unix stack check and loop list start point.
  312.  *
  313.  * Revision 1.53  1996/03/03 07:39:51  robertj
  314.  * Fixed bug in thread scheduler for correct termination of "current" thread.
  315.  *
  316.  * Revision 1.52  1996/03/02 03:24:48  robertj
  317.  * Changed timer thread to update timers periodically, this allows timers to be
  318.  *    views dynamically by other threads.
  319.  * Added automatic deletion of thread object instances on thread completion.
  320.  *
  321.  * Revision 1.51  1996/02/25 11:15:27  robertj
  322.  * Added platform dependent Construct function to PProcess.
  323.  *
  324.  * Revision 1.50  1996/02/25 03:09:46  robertj
  325.  * Added consts to all GetXxxx functions in PConfig.
  326.  *
  327.  * Revision 1.49  1996/02/15 14:44:09  robertj
  328.  * Used string constructor for PTime, more "efficient".
  329.  *
  330.  * Revision 1.48  1996/02/13 12:59:30  robertj
  331.  * Changed GetTimeZone() so can specify standard/daylight time.
  332.  * Split PTime into separate module after major change to ReadFrom().
  333.  *
  334.  * Revision 1.47  1996/02/08 12:26:55  robertj
  335.  * Changed time for full support of time zones.
  336.  *
  337.  * Revision 1.46  1996/02/03 11:06:49  robertj
  338.  * Added string constructor for times, parses date/time from string.
  339.  *
  340.  * Revision 1.45  1996/01/28 14:09:39  robertj
  341.  * Fixed bug in time reading function for dates before 1980.
  342.  * Fixed bug in time reading, was out by one month.
  343.  * Added time functions to PConfig.
  344.  *
  345.  * Revision 1.44  1996/01/28 02:52:04  robertj
  346.  * Added assert into all Compare functions to assure comparison between compatible objects.
  347.  *
  348.  * Revision 1.43  1996/01/23 13:16:30  robertj
  349.  * Mac Metrowerks compiler support.
  350.  * Fixed timers so background thread not created if a windows app.
  351.  *
  352.  * Revision 1.42  1996/01/03 23:15:39  robertj
  353.  * Fixed some PTime bugs.
  354.  *
  355.  * Revision 1.41  1996/01/03 11:09:35  robertj
  356.  * Added Universal Time and Time Zones to PTime class.
  357.  *
  358.  * Revision 1.39  1995/12/23 03:40:40  robertj
  359.  * Changed version number system
  360.  *
  361.  * Revision 1.38  1995/12/10 11:41:12  robertj
  362.  * Added extra user information to processes and applications.
  363.  * Implemented timer support in text only applications with platform threads.
  364.  * Fixed bug in non-platform threads and semaphore timeouts.
  365.  *
  366.  * Revision 1.37  1995/11/21 11:50:57  robertj
  367.  * Added timeout on semaphore wait.
  368.  *
  369.  * Revision 1.36  1995/11/09 12:22:58  robertj
  370.  * Fixed bug in stream when reading an FF (get EOF).
  371.  *
  372.  * Revision 1.35  1995/07/31 12:09:25  robertj
  373.  * Added semaphore class.
  374.  * Removed PContainer from PChannel ancestor.
  375.  *
  376.  * Revision 1.34  1995/06/04 12:41:08  robertj
  377.  * Fixed bug in accessing argument strings with no argument.
  378.  *
  379.  * Revision 1.33  1995/04/25 11:30:06  robertj
  380.  * Fixed Borland compiler warnings.
  381.  *
  382.  * Revision 1.32  1995/04/22 00:51:00  robertj
  383.  * Changed file path strings to use PFilePath object.
  384.  * Changed semantics of Rename().
  385.  *
  386.  * Revision 1.31  1995/04/02 09:27:31  robertj
  387.  * Added "balloon" help.
  388.  *
  389.  * Revision 1.30  1995/04/01 08:30:58  robertj
  390.  * Fixed bug in timeout code of timers.
  391.  *
  392.  * Revision 1.29  1995/01/27 11:15:17  robertj
  393.  * Removed enum to int warning from GCC.
  394.  *
  395.  * Revision 1.28  1995/01/18  09:02:43  robertj
  396.  * Added notifier to timer.
  397.  *
  398.  * Revision 1.27  1995/01/15  04:57:15  robertj
  399.  * Implemented PTime::ReadFrom.
  400.  * Fixed flush of iostream at end of file.
  401.  *
  402.  * Revision 1.26  1995/01/11  09:45:14  robertj
  403.  * Documentation and normalisation.
  404.  *
  405.  * Revision 1.25  1995/01/10  11:44:15  robertj
  406.  * Removed PString parameter in stdarg function for GNU C++ compatibility.
  407.  *
  408.  * Revision 1.24  1995/01/09  12:31:51  robertj
  409.  * Removed unnecesary return value from I/O functions.
  410.  *
  411.  * Revision 1.23  1994/12/12  10:09:24  robertj
  412.  * Fixed flotain point configuration variable format.
  413.  *
  414.  * Revision 1.22  1994/11/28  12:38:23  robertj
  415.  * Async write functions should have const pointer.
  416.  *
  417.  * Revision 1.21  1994/10/30  11:36:58  robertj
  418.  * Fixed missing space in tine format string.
  419.  *
  420.  * Revision 1.20  1994/10/23  03:46:41  robertj
  421.  * Shortened OS error assert.
  422.  *
  423.  * Revision 1.19  1994/09/25  10:51:04  robertj
  424.  * Fixed error conversion code to use common function.
  425.  * Added pipe channel.
  426.  *
  427.  * Revision 1.18  1994/08/21  23:43:02  robertj
  428.  * Moved meta-string transmitter from PModem to PChannel.
  429.  * Added SuspendBlock state to cooperative multi-threading to fix logic fault.
  430.  * Added "force" option to Remove/Rename etc to override write protection.
  431.  * Added common entry point to convert OS error to PChannel error.
  432.  *
  433.  * Revision 1.17  1994/08/04  12:57:10  robertj
  434.  * Changed CheckBlock() to better name.
  435.  * Moved timer porcessing so is done at every Yield().
  436.  *
  437.  * Revision 1.16  1994/08/01  03:39:42  robertj
  438.  * Fixed temporary variable problem with GNU C++
  439.  *
  440.  * Revision 1.15  1994/07/27  05:58:07  robertj
  441.  * Synchronisation.
  442.  *
  443.  * Revision 1.14  1994/07/25  03:39:22  robertj
  444.  * Fixed problems with C++ temporary variables.
  445.  *
  446.  * Revision 1.13  1994/07/21  12:33:49  robertj
  447.  * Moved cooperative threads to common.
  448.  *
  449.  * Revision 1.12  1994/07/17  10:46:06  robertj
  450.  * Fixed timer bug.
  451.  * Moved handle from file to channel.
  452.  * Changed args to use container classes.
  453.  *
  454.  * Revision 1.11  1994/07/02  03:03:49  robertj
  455.  * Time interval and timer redesign.
  456.  *
  457.  * Revision 1.10  1994/06/25  11:55:15  robertj
  458.  * Unix version synchronisation.
  459.  *
  460.  * Revision 1.9  1994/04/20  12:17:44  robertj
  461.  * assert changes
  462.  *
  463.  * Revision 1.8  1994/04/01  14:05:06  robertj
  464.  * Text file streams
  465.  *
  466.  * Revision 1.7  1994/03/07  07:47:00  robertj
  467.  * Major upgrade
  468.  *
  469.  * Revision 1.6  1994/01/03  04:42:23  robertj
  470.  * Mass changes to common container classes and interactors etc etc etc.
  471.  *
  472.  * Revision 1.5  1993/12/31  06:53:02  robertj
  473.  * Made inlines optional for debugging purposes.
  474.  *
  475.  * Revision 1.4  1993/12/29  04:41:26  robertj
  476.  * Mac port.
  477.  *
  478.  * Revision 1.3  1993/11/20  17:26:28  robertj
  479.  * Removed separate osutil.h
  480.  *
  481.  * Revision 1.2  1993/08/31  03:38:02  robertj
  482.  * G++ needs explicit casts for char * / void * interchange.
  483.  *
  484.  * Revision 1.1  1993/08/27  18:17:47  robertj
  485.  * Initial revision
  486.  *
  487.  */
  489. #include <ptlib.h>
  490. #include <ptlib/svcproc.h>
  492. #include <ctype.h>
  495. #ifndef __NUCLEUS_PLUS__
  496. static ostream * PErrorStream = &cerr;
  497. #else
  498. static ostream * PErrorStream = 0L;
  499. #endif
  501. ostream & PGetErrorStream()
  502. {
  503.   return *PErrorStream;
  504. }
  507. void PSetErrorStream(ostream * s)
  508. {
  509. #ifndef __NUCLEUS_PLUS__
  510.   PErrorStream = s != NULL ? s : &cerr;
  511. #else
  512.   PErrorStream = s;
  513. #endif
  514. }
  517. ///////////////////////////////////////////////////////////////////////////////
  519. #ifndef __NUCLEUS_PLUS__
  520. static ostream * PTraceStream = &cerr;
  521. #else
  522. static ostream * PTraceStream = 0L;
  523. #endif
  524. static unsigned PTraceOptions = PTrace::FileAndLine;
  525. static unsigned PTraceLevelThreshold = 0;
  526. static unsigned PTraceBlockIndentLevel = 0;
  527. static PTimeInterval ApplicationStartTick = PTimer::Tick();
  529. void PTrace::SetStream(ostream * s)
  530. {
  531. #ifndef __NUCLEUS_PLUS__
  532.   PTraceStream = s != NULL ? s : &cerr;
  533. #else
  534.   PTraceStream = s;
  535. #endif
  536. }
  539. void PTrace::SetOptions(unsigned options)
  540. {
  541.   PTraceOptions |= options;
  542. }
  545. void PTrace::ClearOptions(unsigned options)
  546. {
  547.   PTraceOptions &= ~options;
  548. }
  551. unsigned PTrace::GetOptions()
  552. {
  553.   return PTraceOptions;
  554. }
  557. void PTrace::SetLevel(unsigned level)
  558. {
  559.   PTraceLevelThreshold = level;
  560. }
  563. unsigned PTrace::GetLevel()
  564. {
  565.   return PTraceLevelThreshold;
  566. }
  569. BOOL PTrace::CanTrace(unsigned level)
  570. {
  571.   return level <= PTraceLevelThreshold;
  572. }
  575. static PMutex & PTraceMutex()
  576. {
  577.   static PMutex mutex;
  578.   return mutex;
  579. }
  582. ostream & PTrace::Begin(unsigned level, const char * fileName, int lineNum)
  583. {
  584.   PTraceMutex().Wait();
  586.   if (level == UINT_MAX)
  587.     return *PTraceStream;
  589.   if ((PTraceOptions&SystemLogStream) != 0) {
  590.     unsigned lvl = level+PSystemLog::Warning;
  591.     if (lvl >= PSystemLog::NumLogLevels)
  592.       lvl = PSystemLog::NumLogLevels-1;
  593.     ((PSystemLog*)PTraceStream)->SetLevel((PSystemLog::Level)lvl);
  594.   }
  595.   else {
  596.     if ((PTraceOptions&DateAndTime) != 0) {
  597.       PTime now;
  598.       *PTraceStream << now.AsString("yyyy/MM/dd hh:mm:sst");
  599.     }
  601.     if ((PTraceOptions&Timestamp) != 0)
  602.       *PTraceStream << setprecision(3) << setw(10) << (PTimer::Tick()-ApplicationStartTick) << 't';
  604.     if ((PTraceOptions&Thread) != 0) {
  605.       PThread * thread = PThread::Current();
  606.       if (thread == NULL)
  607.         *PTraceStream << setw(23) << "<<unknown>>";
  608.       else {
  609.         PString name = thread->GetThreadName();
  610.         if (!name)
  611.           *PTraceStream << setw(23) << name.Left(23);
  612.         else {
  613.           name = thread->GetClass();
  614.           if ((PTraceOptions&ThreadAddress) != 0)
  615.             *PTraceStream << setw(23) << name.Left(23);
  616.           else
  617.             *PTraceStream << setw(15) << name.Left(15) << ':'
  618.                           << hex << setfill('0')
  619.                           << setw(7) << (unsigned)thread
  620.                           << dec << setfill(' ');
  621.         }
  622.       }
  623.       *PTraceStream << 't';
  624.     }
  626.     if ((PTraceOptions&ThreadAddress) != 0)
  627.       *PTraceStream << hex << setfill('0')
  628.                     << setw(7) << (unsigned)PThread::Current()
  629.                     << dec << setfill(' ') << 't';
  630.   }
  632.   if ((PTraceOptions&TraceLevel) != 0)
  633.     *PTraceStream << level << 't';
  635.   if ((PTraceOptions&FileAndLine) != 0 && fileName != NULL) {
  636.     const char * file = strrchr(fileName, '/');
  637.     if (file != NULL)
  638.       file++;
  639.     else {
  640.       file = strrchr(fileName, '\');
  641.       if (file != NULL)
  642.         file++;
  643.       else
  644.         file = fileName;
  645.     }
  647.     *PTraceStream << setw(16) << file << '(' << lineNum << ")t";
  648.   }
  650.   return *PTraceStream;
  651. }
  654. ostream & PTrace::End(ostream & s)
  655. {
  656.   if (s.rdbuf()->out_waiting() > 0) {
  657.     if ((PTraceOptions&SystemLogStream) != 0)
  658.       s.flush();
  659.     else
  660.       s << endl;
  661.   }
  663.   PTraceMutex().Signal();
  665.   return s;
  666. }
  669. PTrace::Block::Block(const char * fileName, int lineNum, const char * traceName)
  670. {
  671.   file = fileName;
  672.   line = lineNum;
  673.   name = traceName;
  675.   PTraceBlockIndentLevel += 2;
  677.   if ((PTraceOptions&Blocks) != 0) {
  678.     ostream & s = PTrace::Begin(1, file, line);
  679.     for (unsigned i = 0; i < PTraceBlockIndentLevel; i++)
  680.       s << '=';
  681.     s << "> " << name << PTrace::End;
  682.   }
  683. }
  686. PTrace::Block::~Block()
  687. {
  688.   if ((PTraceOptions&Blocks) != 0) {
  689.     ostream & s = PTrace::Begin(1, file, line);
  690.     s << '<';
  691.     for (unsigned i = 0; i < PTraceBlockIndentLevel; i++)
  692.       s << '=';
  693.     s << ' ' << name << PTrace::End;
  694.   }
  696.   PTraceBlockIndentLevel -= 2;
  697. }
  700. ///////////////////////////////////////////////////////////////////////////////
  701. // PDirectory
  703. void PDirectory::CloneContents(const PDirectory * d)
  704. {
  705.   CopyContents(*d);
  706. }
  709. ///////////////////////////////////////////////////////////////////////////////
  710. // PTimer
  712. PTimer::PTimer(long millisecs, int seconds, int minutes, int hours, int days)
  713.   : resetTime(millisecs, seconds, minutes, hours, days)
  714. {
  715.   state = Stopped;
  716.   timeoutThread = NULL;
  717.   StartRunning(TRUE);
  718. }
  721. PTimer::PTimer(const PTimeInterval & time)
  722.   : resetTime(time)
  723. {
  724.   state = Stopped;
  725.   timeoutThread = NULL;
  726.   StartRunning(TRUE);
  727. }
  730. PTimer & PTimer::operator=(DWORD milliseconds)
  731. {
  732.   resetTime = (PInt64)milliseconds;
  733.   StartRunning(oneshot);
  734.   return *this;
  735. }
  738. PTimer & PTimer::operator=(const PTimeInterval & time)
  739. {
  740.   resetTime = time;
  741.   StartRunning(oneshot);
  742.   return *this;
  743. }
  746. PTimer::~PTimer()
  747. {
  748.   PAssert(timeoutThread == NULL || PThread::Current() != timeoutThread, "Timer destroyed in OnTimeout()");
  749.   if (IsRunning())
  750.     PProcess::Current().GetTimerList()->RemoveTimer(this);
  751. }
  754. void PTimer::RunContinuous(const PTimeInterval & time)
  755. {
  756.   resetTime = time;
  757.   StartRunning(FALSE);
  758. }
  761. void PTimer::StartRunning(BOOL once)
  762. {
  763.   if (IsRunning() && timeoutThread == NULL)
  764.     PProcess::Current().GetTimerList()->RemoveTimer(this);
  766.   PTimeInterval::operator=(resetTime);
  767.   oneshot = once;
  768.   state = (*this) != 0 ? Starting : Stopped;
  770.   if (IsRunning()) {
  771.     if (timeoutThread == NULL)
  772.       PProcess::Current().GetTimerList()->AppendTimer(this);
  773. #if defined(P_PLATFORM_HAS_THREADS)
  774.     else
  775.       PProcess::Current().SignalTimerChange();
  776. #endif
  777.   }
  778. }
  781. void PTimer::Stop()
  782. {
  783.   if (IsRunning() && timeoutThread == NULL)
  784.     PProcess::Current().GetTimerList()->RemoveTimer(this);
  785.   state = Stopped;
  786.   SetInterval(0);
  787. }
  790. void PTimer::Pause()
  791. {
  792.   if (IsRunning()) {
  793.     if (timeoutThread == NULL)
  794.       PProcess::Current().GetTimerList()->RemoveTimer(this);
  795.     state = Paused;
  796.   }
  797. }
  800. void PTimer::Resume()
  801. {
  802.   if (state == Paused) {
  803.     if (timeoutThread == NULL)
  804.       PProcess::Current().GetTimerList()->AppendTimer(this);
  805.     state = Starting;
  806.   }
  807. }
  810. void PTimer::OnTimeout()
  811. {
  812.   if (!callback.IsNULL())
  813.     callback(*this, IsRunning());
  814. }
  817. BOOL PTimer::Process(const PTimeInterval & delta, PTimeInterval & minTimeLeft)
  818. {
  819.   if (state == Starting) {
  820.     state = Running;
  821.     if (resetTime < minTimeLeft)
  822.       minTimeLeft = resetTime;
  823.     return FALSE;
  824.   }
  826.   operator-=(delta);
  828.   if (milliseconds > 0) {
  829.     if (milliseconds < minTimeLeft.GetMilliSeconds())
  830.       minTimeLeft = milliseconds;
  831.     return FALSE;
  832.   }
  834.   timeoutThread = PThread::Current();
  835.   if (oneshot) {
  836.     operator=(PTimeInterval(0));
  837.     state = Stopped;
  838.   }
  839.   else {
  840.     operator=(resetTime);
  841.     if (resetTime < minTimeLeft)
  842.       minTimeLeft = resetTime;
  843.   }
  845.   return TRUE;
  846. }
  849. ///////////////////////////////////////////////////////////////////////////////
  850. // PTimerList
  852. PTimerList::PTimerList()
  853. {
  854.   DisallowDeleteObjects();
  855. }
  858. void PTimerList::AppendTimer(PTimer * timer)
  859. {
  860.   mutex.Wait();
  861.   PInternalTimerList::InsertAt(0, timer);
  862.   mutex.Signal();
  863. #if defined(P_PLATFORM_HAS_THREADS)
  864.   PProcess::Current().SignalTimerChange();
  865. #endif
  866. }
  869. void PTimerList::RemoveTimer(PTimer * timer)
  870. {
  871.   mutex.Wait();
  872.   PInternalTimerList::Remove(timer);
  873.   mutex.Signal();
  874. #if defined(P_PLATFORM_HAS_THREADS)
  875.   PProcess::Current().SignalTimerChange();
  876. #endif
  877. }
  880. PTimeInterval PTimerList::Process()
  881. {
  882.   PINDEX i;
  883.   PTimeInterval minTimeLeft = PMaxTimeInterval;
  884.   PInternalTimerList timeouts;
  885.   timeouts.DisallowDeleteObjects();
  887.   mutex.Wait();
  888.   PTimeInterval now = PTimer::Tick();
  889.   PTimeInterval sampleTime;
  890.   if (lastSample == 0)
  891.     sampleTime = 0;
  892.   else {
  893.     sampleTime = now - lastSample;
  894.     if (now < lastSample)
  895.       sampleTime += PMaxTimeInterval;
  896.   }
  897.   lastSample = now;
  899.   for (i = 0; i < GetSize(); i++)
  900.     if ((*this)[i].Process(sampleTime, minTimeLeft))
  901.       timeouts.Append(RemoveAt(i--));
  902.   mutex.Signal();
  904.   for (i = 0; i < timeouts.GetSize(); i++)
  905.     timeouts[i].OnTimeout();
  907.   mutex.Wait();
  908.   for (i = 0; i < timeouts.GetSize(); i++) {
  909.     timeouts[i].timeoutThread = NULL;
  910.     if (timeouts[i].IsRunning())
  911.       Append(timeouts.GetAt(i));
  912.   }
  913.   mutex.Signal();
  915.   return minTimeLeft;
  916. }
  919. ///////////////////////////////////////////////////////////////////////////////
  920. // PArgList
  922. PArgList::PArgList(const char * theArgStr,
  923.                    const char * theArgumentSpec,
  924.                    BOOL optionsBeforeParams)
  925. {
  926.   // get the program arguments
  927.   if (theArgStr != NULL)
  928.     SetArgs(theArgStr);
  930.   // if we got an argument spec - so process them
  931.   if (theArgumentSpec != NULL)
  932.     Parse(theArgumentSpec, optionsBeforeParams);
  933. }
  936. PArgList::PArgList(const PString & theArgStr,
  937.                    const char * argumentSpecPtr,
  938.                    BOOL optionsBeforeParams)
  939. {
  940.   // get the program arguments
  941.   SetArgs(theArgStr);
  943.   // if we got an argument spec - so process them
  944.   if (argumentSpecPtr != NULL)
  945.     Parse(argumentSpecPtr, optionsBeforeParams);
  946. }
  949. PArgList::PArgList(const PString & theArgStr,
  950.                    const PString & argumentSpecStr,
  951.                    BOOL optionsBeforeParams)
  952. {
  953.   // get the program arguments
  954.   SetArgs(theArgStr);
  956.   // if we got an argument spec - so process them
  957.   Parse(argumentSpecStr, optionsBeforeParams);
  958. }
  961. PArgList::PArgList(int theArgc, char ** theArgv,
  962.                    const char * theArgumentSpec,
  963.                    BOOL optionsBeforeParams)
  964. {
  965.   // get the program arguments
  966.   SetArgs(theArgc, theArgv);
  968.   // if we got an argument spec - so process them
  969.   if (theArgumentSpec != NULL)
  970.     Parse(theArgumentSpec, optionsBeforeParams);
  971. }
  974. PArgList::PArgList(int theArgc, char ** theArgv,
  975.                    const PString & theArgumentSpec,
  976.                    BOOL optionsBeforeParams)
  977. {
  978.   // get the program name and path
  979.   SetArgs(theArgc, theArgv);
  980.   // we got an argument spec - so process them
  981.   Parse(theArgumentSpec, optionsBeforeParams);
  982. }
  985. void PArgList::SetArgs(const PString & argStr)
  986. {
  987.   argumentArray.SetSize(0);
  989.   const char * str = argStr;
  991.   for (;;) {
  992.     while (isspace(*str)) // Skip leading whitespace
  993.       str++;
  994.     if (*str == '')
  995.       break;
  997.     PString & arg = argumentArray[argumentArray.GetSize()];
  998.     while (*str != '' && !isspace(*str)) {
  999.       switch (*str) {
  1000.         case '"' :
  1001.           str++;
  1002.           while (*str != '' && *str != '"')
  1003.             arg += *str++;
  1004.           if (*str != '')
  1005.             str++;
  1006.           break;
  1008.         case ''' :
  1009.           str++;
  1010.           while (*str != '' && *str != ''')
  1011.             arg += *str++;
  1012.           if (*str != '')
  1013.             str++;
  1014.           break;
  1016.         default :
  1017.           if (str[0] == '\' && str[1] != '')
  1018.             str++;
  1019.           arg += *str++;
  1020.       }
  1021.     }
  1022.   }
  1024.   SetArgs(argumentArray);
  1025. }
  1028. void PArgList::SetArgs(const PStringArray & theArgs)
  1029. {
  1030.   argumentArray = theArgs;
  1031.   shift = 0;
  1032.   optionLetters = "";
  1033.   optionNames.SetSize(0);
  1034.   parameterIndex.SetSize(argumentArray.GetSize());
  1035.   for (PINDEX i = 0; i < argumentArray.GetSize(); i++)
  1036.     parameterIndex[i] = i;
  1037. }
  1040. BOOL PArgList::Parse(const char * spec, BOOL optionsBeforeParams)
  1041. {
  1042.   PAssertNULL(spec);
  1044.   // Find starting point, start at shift if first Parse() call.
  1045.   PINDEX arg = optionLetters.IsEmpty() ? shift : 0;
  1047.   // If not in parse all mode, have been parsed before, and had some parameters
  1048.   // from last time, then start argument parsing somewhere along instead of start.
  1049.   if (optionsBeforeParams && !optionLetters && parameterIndex.GetSize() > 0)
  1050.     arg = parameterIndex[parameterIndex.GetSize()-1] + 1;
  1052.   // Parse the option specification
  1053.   optionLetters = "";
  1054.   optionNames.SetSize(0);
  1055.   PIntArray canHaveOptionString;
  1057.   PINDEX codeCount = 0;
  1058.   while (*spec != '') {
  1059.     if (*spec == '-')
  1060.       optionLetters += ' ';
  1061.     else
  1062.       optionLetters += *spec++;
  1063.     if (*spec == '-') {
  1064.       const char * base = ++spec;
  1065.       while (*spec != '' && *spec != '.' && *spec != ':' && *spec != ';')
  1066.         spec++;
  1067.       optionNames[codeCount] = PString(base, spec-base);
  1068.       if (*spec == '.')
  1069.         spec++;
  1070.     }
  1071.     if (*spec == ':' || *spec == ';') {
  1072.       canHaveOptionString.SetSize(codeCount+1);
  1073.       canHaveOptionString[codeCount] = *spec == ':' ? 2 : 1;
  1074.       spec++;
  1075.     }
  1076.     codeCount++;
  1077.   }
  1079.   // Clear and reset size of option information
  1080.   optionCount.SetSize(0);
  1081.   optionCount.SetSize(codeCount);
  1082.   optionString.SetSize(0);
  1083.   optionString.SetSize(codeCount);
  1085.   // Clear parameter indexes
  1086.   parameterIndex.SetSize(0);
  1087.   shift = 0;
  1089.   // Now work through the arguments and split out the options
  1090.   PINDEX param = 0;
  1091.   BOOL hadMinusMinus = FALSE;
  1092.   while (arg < argumentArray.GetSize()) {
  1093.     const PString & argStr = argumentArray[arg];
  1094.     if (hadMinusMinus || argStr[0] != '-' || argStr[1] == '') {
  1095.       // have a parameter string
  1096.       parameterIndex.SetSize(param+1);
  1097.       parameterIndex[param++] = arg;
  1098.     }
  1099.     else if (optionsBeforeParams && parameterIndex.GetSize() > 0)
  1100.       break;
  1101.     else if (argStr == "--") // ALL remaining args are parameters not options
  1102.       hadMinusMinus = TRUE;
  1103.     else if (argStr[1] == '-')
  1104.       ParseOption(optionNames.GetValuesIndex(argStr.Mid(2)), 0, arg, canHaveOptionString);
  1105.     else {
  1106.       for (PINDEX i = 1; i < argStr.GetLength(); i++)
  1107.         if (ParseOption(optionLetters.Find(argStr[i]), i+1, arg, canHaveOptionString))
  1108.           break;
  1109.     }
  1111.     arg++;
  1112.   }
  1114.   return param > 0;
  1115. }
  1118. BOOL PArgList::ParseOption(PINDEX idx, PINDEX offset, PINDEX & arg,
  1119.                            const PIntArray & canHaveOptionString)
  1120. {
  1121.   if (idx == P_MAX_INDEX) {
  1122.     UnknownOption(argumentArray[arg]);
  1123.     return FALSE;
  1124.   }
  1126.   optionCount[idx]++;
  1127.   if (canHaveOptionString[idx] == 0)
  1128.     return FALSE;
  1130.   if (!optionString[idx])
  1131.     optionString[idx] += 'n';
  1133.   if (offset != 0 &&
  1134.         (canHaveOptionString[idx] == 1 || argumentArray[arg][offset] != '')) {
  1135.     optionString[idx] += argumentArray[arg].Mid(offset);
  1136.     return TRUE;
  1137.   }
  1139.   if (++arg >= argumentArray.GetSize())
  1140.     return FALSE;
  1142.   optionString[idx] += argumentArray[arg];
  1143.   return TRUE;
  1144. }
  1147. PINDEX PArgList::GetOptionCount(char option) const
  1148. {
  1149.   return GetOptionCountByIndex(optionLetters.Find(option));
  1150. }
  1153. PINDEX PArgList::GetOptionCount(const char * option) const
  1154. {
  1155.   return GetOptionCountByIndex(optionNames.GetValuesIndex(PString(option)));
  1156. }
  1159. PINDEX PArgList::GetOptionCount(const PString & option) const
  1160. {
  1161.   return GetOptionCountByIndex(optionNames.GetValuesIndex(option));
  1162. }
  1165. PINDEX PArgList::GetOptionCountByIndex(PINDEX idx) const
  1166. {
  1167.   if (idx < optionCount.GetSize())
  1168.     return optionCount[idx];
  1170.   return 0;
  1171. }
  1174. PString PArgList::GetOptionString(char option, const char * dflt) const
  1175. {
  1176.   return GetOptionStringByIndex(optionLetters.Find(option), dflt);
  1177. }
  1180. PString PArgList::GetOptionString(const char * option, const char * dflt) const
  1181. {
  1182.   return GetOptionStringByIndex(optionNames.GetValuesIndex(PString(option)), dflt);
  1183. }
  1186. PString PArgList::GetOptionString(const PString & option, const char * dflt) const
  1187. {
  1188.   return GetOptionStringByIndex(optionNames.GetValuesIndex(option), dflt);
  1189. }
  1192. PString PArgList::GetOptionStringByIndex(PINDEX idx, const char * dflt) const
  1193. {
  1194.   if (idx < optionString.GetSize() && optionString.GetAt(idx) != NULL)
  1195.     return optionString[idx];
  1197.   if (dflt != NULL)
  1198.     return dflt;
  1200.   return PString();
  1201. }
  1204. PString PArgList::GetParameter(PINDEX num) const
  1205. {
  1206.   int idx = shift+(int)num;
  1207.   if (idx >= 0 && idx < (int)parameterIndex.GetSize())
  1208.     return argumentArray[parameterIndex[idx]];
  1210.   IllegalArgumentIndex(idx);
  1211.   return PString();
  1212. }
  1215. void PArgList::Shift(int sh) 
  1216. {
  1217.   shift += sh;
  1218.   if (shift < 0)
  1219.     shift = 0;
  1220.   else if (shift >= (int)parameterIndex.GetSize())
  1221.     shift = parameterIndex.GetSize() - 1;
  1222. }
  1225. void PArgList::IllegalArgumentIndex(PINDEX idx) const
  1226. {
  1227.   PError << "attempt to access undefined argument at index "
  1228.          << idx << endl;
  1229. }
  1230.  
  1232. void PArgList::UnknownOption(const PString & option) const
  1233. {
  1234.   PError << "unknown option "" << option << ""n";
  1235. }
  1238. void PArgList::MissingArgument(const PString & option) const
  1239. {
  1240.   PError << "option "" << option << "" requires argumentn";
  1241. }
  1244. ///////////////////////////////////////////////////////////////////////////////
  1245. // PConfigArgs
  1247. PConfigArgs::PConfigArgs(const PArgList & args)
  1248.   : PArgList(args),
  1249.     sectionName(config.GetDefaultSection()),
  1250.     negationPrefix("no-")
  1251. {
  1252. }
  1255. PINDEX PConfigArgs::GetOptionCount(char option) const
  1256. {
  1257.   PINDEX count;
  1258.   if ((count = PArgList::GetOptionCount(option)) > 0)
  1259.     return count;
  1261.   PString stropt = CharToString(option);
  1262.   if (stropt.IsEmpty())
  1263.     return 0;
  1265.   return GetOptionCount(stropt);
  1266. }
  1269. PINDEX PConfigArgs::GetOptionCount(const char * option) const
  1270. {
  1271.   return GetOptionCount(PString(option));
  1272. }
  1275. PINDEX PConfigArgs::GetOptionCount(const PString & option) const
  1276. {
  1277.   // if specified on the command line, use that option
  1278.   PINDEX count = PArgList::GetOptionCount(option);
  1279.   if (count > 0)
  1280.     return count;
  1282.   // if user has specified "no-option", then ignore config file
  1283.   if (PArgList::GetOptionCount(negationPrefix + option) > 0)
  1284.     return 0;
  1286.   return config.HasKey(sectionName, option) ? 1 : 0;
  1287. }
  1290. PString PConfigArgs::GetOptionString(char option, const char * dflt) const
  1291. {
  1292.   if (PArgList::GetOptionCount(option) > 0)
  1293.     return PArgList::GetOptionString(option, dflt);
  1295.   PString stropt = CharToString(option);
  1296.   if (stropt.IsEmpty()) {
  1297.     if (dflt != NULL)
  1298.       return dflt;
  1299.     return PString();
  1300.   }
  1302.   return GetOptionString(stropt, dflt);
  1303. }
  1306. PString PConfigArgs::GetOptionString(const char * option, const char * dflt) const
  1307. {
  1308.   return GetOptionString(PString(option), dflt);
  1309. }
  1312. PString PConfigArgs::GetOptionString(const PString & option, const char * dflt) const
  1313. {
  1314.   // if specified on the command line, use that option
  1315.   if (PArgList::GetOptionCount(option) > 0)
  1316.     return PArgList::GetOptionString(option, dflt);
  1318.   // if user has specified "no-option", then ignore config file
  1319.   if (PArgList::HasOption(negationPrefix + option)) {
  1320.     if (dflt != NULL)
  1321.       return dflt;
  1322.     return PString();
  1323.   }
  1325.   return config.GetString(sectionName, option, dflt != NULL ? dflt : "");
  1326. }
  1329. void PConfigArgs::Save(const PString & saveOptionName)
  1330. {
  1331.   if (PArgList::GetOptionCount(saveOptionName) == 0)
  1332.     return;
  1334.   config.DeleteSection(sectionName);
  1336.   for (PINDEX i = 0; i < optionCount.GetSize(); i++) {
  1337.     PString optionName = optionNames[i];
  1338.     if (optionCount[i] > 0 && optionName != saveOptionName) {
  1339.       if (optionString.GetAt(i) != NULL)
  1340.         config.SetString(sectionName, optionName, optionString[i]);
  1341.       else
  1342.         config.SetBoolean(sectionName, optionName, TRUE);
  1343.     }
  1344.   }
  1345. }
  1348. PString PConfigArgs::CharToString(char ch) const
  1349. {
  1350.   PINDEX index = optionLetters.Find(ch);
  1351.   if (index == P_MAX_INDEX)
  1352.     return PString();
  1354.   if (optionNames.GetAt(index) == NULL)
  1355.     return PString();
  1357.   return optionNames[index];
  1358. }
  1361. ///////////////////////////////////////////////////////////////////////////////
  1362. // PProcess
  1364. static PProcess * PProcessInstance;
  1365. int PProcess::p_argc;
  1366. char ** PProcess::p_argv;
  1367. char ** PProcess::p_envp;
  1369. #ifndef P_PLATFORM_HAS_THREADS
  1370. static BOOL PProcessTerminating = FALSE;
  1371. #endif
  1374. PProcess::PProcess(const char * manuf, const char * name,
  1375.                            WORD major, WORD minor, CodeStatus stat, WORD build)
  1376.   : manufacturer(manuf), productName(name)
  1377. {
  1378.   PProcessInstance = this;
  1379.   terminationValue = 0;
  1381.   majorVersion = major;
  1382.   minorVersion = minor;
  1383.   status = stat;
  1384.   buildNumber = build;
  1386.   if (p_argv != 0 && p_argc > 0) {
  1387.     arguments.SetArgs(p_argc-1, p_argv+1);
  1389.     executableFile = PString(p_argv[0]);
  1390.     if (!PFile::Exists(executableFile))
  1391.       executableFile += ".exe";
  1393.     if (productName.IsEmpty())
  1394.       productName = executableFile.GetTitle().ToLower();
  1395.   }
  1397.   InitialiseProcessThread();
  1399.   Construct();
  1400. }
  1403. int PProcess::_main(void *)
  1404. {
  1405.   Main();
  1406.   return terminationValue;
  1407. }
  1410. void PProcess::PreInitialise(int c, char ** v, char ** e)
  1411. {
  1412.   p_argc = c;
  1413.   p_argv = v;
  1414.   p_envp = e;
  1415. }
  1418. PProcess & PProcess::Current()
  1419. {
  1420.   if (PProcessInstance == NULL) {
  1421.     cerr << "Catastrophic failure, PProcess::Current() = NULL!!n";
  1422. #if defined(_MSC_VER) && defined(_DEBUG)
  1423.     __asm int 3;
  1424. #endif
  1425.     _exit(1);
  1426.   }
  1427.   return *PProcessInstance;
  1428. }
  1431. BOOL PProcess::IsInitialised()
  1432. {
  1433.   return PProcessInstance != NULL;
  1434. }
  1437. PObject::Comparison PProcess::Compare(const PObject & obj) const
  1438. {
  1439.   PAssert(obj.IsDescendant(PProcess::Class()), PInvalidCast);
  1440.   return productName.Compare(((const PProcess &)obj).productName);
  1441. }
  1444. void PProcess::Terminate()
  1445. {
  1446. #ifdef _WINDLL
  1447.   FatalExit(terminationValue);
  1448. #else
  1449. #ifndef P_PLATFORM_HAS_THREADS
  1450.   // Can only terminate process from the processes thread
  1451.   if (currentThread == this)
  1452.     exit(terminationValue);
  1453.   else
  1454.     PProcessTerminating = TRUE;
  1455. #else
  1456.   exit(terminationValue);
  1457. #endif
  1458. #endif
  1459. }
  1462. PString PProcess::GetThreadName() const
  1463. {
  1464.   return GetName(); 
  1465. }
  1466.  
  1467.  
  1468. void PProcess::SetThreadName(const PString & /*name*/)
  1469. {
  1470. }
  1473. PString PProcess::GetVersion(BOOL full) const
  1474. {
  1475.   const char * const statusLetter[NumCodeStatuses] =
  1476.     { "alpha", "beta", "pl" };
  1477.   return psprintf(full && buildNumber != 0 ? "%u.%u%s%u" : "%u.%u",
  1478.                 majorVersion, minorVersion, statusLetter[status], buildNumber);
  1479. }
  1482. ///////////////////////////////////////////////////////////////////////////////
  1483. // PThread
  1485. void PThread::PrintOn(ostream & strm) const
  1486. {
  1487.   PString name = GetThreadName();
  1488.   if (name.IsEmpty())
  1489.     name.sprintf("%s<%08x>", GetClass(), (int)this);
  1490.   strm << name;
  1491. }
  1494. PString PThread::GetThreadName() const
  1495. {
  1496.   return threadName; 
  1497. }
  1498.  
  1499.  
  1500. void PThread::SetThreadName(const PString & name)
  1501. {
  1502.   threadName = name; 
  1503. }
  1506. #ifndef P_PLATFORM_HAS_THREADS
  1508. void PThread::InitialiseProcessThread()
  1509. {
  1510.   basePriority = NormalPriority;  // User settable priority
  1511.   dynamicPriority = 0;            // Only thing running
  1512.   suspendCount = 0;               // Not suspended (would not be a good idea)
  1513.   ClearBlock();                   // No I/O blocking function
  1514.   status = Running;               // Thread is already running
  1515.   stackBase = NULL;
  1516.   link = this;
  1517.   ((PProcess*)this)->currentThread = this;
  1518. }
  1521. PThread::PThread(PINDEX stackSize,
  1522.                  AutoDeleteFlag deletion,
  1523.                  Priority priorityLevel,
  1524.                  const PString & name)
  1525.   : threadName(name)
  1526. {
  1527.   autoDelete = deletion == AutoDeleteThread;
  1528.   basePriority = priorityLevel;   // Threads user settable priority level
  1529.   dynamicPriority = 0;            // Run immediately
  1530.   suspendCount = 1;
  1532.   AllocateStack(stackSize);
  1533.   PAssert(stackBase != NULL, "Insufficient near heap for thread");
  1535.   status = Terminated; // Set to this so Restart() works
  1536.   Restart();
  1537. }
  1540. void PThread::Restart()
  1541. {
  1542.   if (status != Terminated) // Is already running
  1543.     return;
  1545.   ClearBlock();             // No I/O blocking function
  1547.   PThread * current = Current();
  1548.   link = current->link;
  1549.   current->link = this;
  1551.   status = Starting;
  1552. }
  1555. void PThread::Terminate()
  1556. {
  1557.   if (link == this || status == Terminated)
  1558.     return;   // Is only thread or already terminated
  1560.   if (status == Running) {
  1561.     status = Terminating;
  1562.     Yield(); // Never returns from here
  1563.   }
  1565.   PThread * prev = PThread::Current();
  1566.   while (prev->link != this)
  1567.     prev = prev->link;
  1568.   prev->link = link;   // Unlink it from the list
  1569.   status = Terminated;
  1570. }
  1573. void PThread::WaitForTermination() const
  1574. {
  1575.   while (!IsTerminated())
  1576.     Yield();
  1577. }
  1580. BOOL PThread::WaitForTermination(const PTimeInterval & maxWait) const
  1581. {
  1582.   PTimer timeout = maxWait;
  1583.   while (!IsTerminated()) {
  1584.     if (timeout == 0)
  1585.       return FALSE;
  1586.     Yield();
  1587.   }
  1589.   return TRUE;
  1590. }
  1593. void PThread::Suspend(BOOL susp)
  1594. {
  1595.   // Suspend/Resume the thread
  1596.   if (susp)
  1597.     suspendCount++;
  1598.   else
  1599.     suspendCount--;
  1601.   switch (status) {
  1602.     case Running : // Suspending itself, yield to next thread
  1603.       if (IsSuspended()) {
  1604.         status = Suspended;
  1605.         Yield();
  1606.       }
  1607.       break;
  1609.     case Waiting :
  1610.       if (IsSuspended())
  1611.         status = Suspended;
  1612.       break;
  1614.     case BlockedIO :
  1615.       if (IsSuspended())
  1616.         status = SuspendedBlockIO;
  1617.       break;
  1619.     case BlockedSem :
  1620.       if (IsSuspended())
  1621.         status = SuspendedBlockSem;
  1622.       break;
  1624.     case Suspended :
  1625.       if (!IsSuspended())
  1626.         status = Waiting;
  1627.       break;
  1629.     case SuspendedBlockIO :
  1630.       if (!IsSuspended())
  1631.         status = BlockedIO;
  1632.       break;
  1634.     case SuspendedBlockSem :
  1635.       if (!IsSuspended())
  1636.         status = BlockedSem;
  1637.       break;
  1639.     default :
  1640.       break;
  1641.   }
  1642. }
  1645. void PThread::Sleep(const PTimeInterval & time)
  1646. {
  1647.   sleepTimer = time;
  1648.   if (time == PMaxTimeInterval)
  1649.     sleepTimer.Pause();
  1651.   switch (status) {
  1652.     case Running : // Suspending itself, yield to next thread
  1653.       status = Sleeping;
  1654.       Yield();
  1655.       break;
  1657.     case Waiting :
  1658.     case Suspended :
  1659.       status = Sleeping;
  1660.       break;
  1662.     default :
  1663.       break;
  1664.   }
  1665. }
  1668. void PThread::BeginThread()
  1669. {
  1670.   if (IsSuspended()) { // Begins suspended
  1671.     status = Suspended;
  1672.     Yield();
  1673.   }
  1674.   else
  1675.     status = Running;
  1677.   Main();
  1679.   status = Terminating;
  1680.   Yield(); // Never returns from here
  1681. }
  1684. void PThread::Yield()
  1685. {
  1686.   PThread * current = PProcessInstance->currentThread;
  1687.   if (current == PProcessInstance) {
  1688.     PProcessInstance->GetTimerList()->Process();
  1689.     if (current->link == current)
  1690.       return;
  1691.   }
  1692.   else {
  1693.     char stackUsed;
  1694.     if (&stackUsed < current->stackBase) {
  1695.       char * buf = (char *)malloc(1000);
  1696.       sprintf(buf, "Stack overflow!n"
  1697.                    "n"
  1698.                    "Thread: 0x%08x - %sn"
  1699.                    "Stack top  : 0x%08xn"
  1700.                    "Stack base : 0x%08xn"
  1701.                    "Stack frame: 0x%08xn"
  1702.                    "n",
  1703.               (int)current, current->GetClass(),
  1704.               (int)current->stackTop,
  1705.               (int)current->stackBase,
  1706.               (int)&stackUsed);
  1707.       PAssertAlways(buf);
  1708.       PError << "Aborting." << endl;
  1709.       _exit(1);
  1710.     }
  1711.   }
  1713.   if (current->status == Running && current->basePriority == HighestPriority)
  1714.     return;
  1716.   do {
  1717.     if (current->status == Running)
  1718.       current->status = Waiting;
  1720.     static const int dynamicLevel[NumPriorities] = { -1, 3, 1, 0, 0 };
  1721.     current->dynamicPriority = dynamicLevel[current->basePriority];
  1723.     PThread * next = NULL; // Next thread to be scheduled
  1724.     PThread * prev = current; // Need the thread in the previous link
  1725.     PThread * start = current;  // Need thread in list that is the "start"
  1726.     PThread * thread = current->link;
  1727.     BOOL pass = 0;
  1728.     BOOL canUseLowest = TRUE;
  1730.     for (;;) {
  1731.       if (PProcessTerminating) {
  1732.         next = PProcessInstance;
  1733.         next->status = Running;
  1734.         break;
  1735.       }
  1737.       switch (thread->status) {
  1738.         case Waiting :
  1739.           if (thread->dynamicPriority == 0) {
  1740.             next = thread;
  1741.             next->status = Running;
  1742.           }
  1743.           else if (thread->dynamicPriority > 0) {
  1744.             thread->dynamicPriority--;
  1745.             canUseLowest = FALSE;
  1746.           }
  1747.           else if (pass > 1 && canUseLowest)
  1748.             thread->dynamicPriority++;
  1749.           break;
  1751.         case Sleeping :
  1752.           if (thread->sleepTimer == 0) {
  1753.             if (thread->IsSuspended())
  1754.               thread->status = Suspended;
  1755.             else {
  1756.               thread->status = Running;
  1757.               next = thread;
  1758.             }
  1759.           }
  1760.           break;
  1762.         case BlockedIO :
  1763.           if (thread->IsNoLongerBlocked()) {
  1764.             if (PProcessTerminating)
  1765.               next = PProcessInstance;
  1766.             else {
  1767.               thread->ClearBlock();
  1768.               next = thread;
  1769.             }
  1770.             next->status = Running;
  1771.           }
  1772.           break;
  1774.         case BlockedSem :
  1775.         case SuspendedBlockSem :
  1776.           if (thread->blockingSemaphore->timeout == 0) {
  1777.             thread->blockingSemaphore->PSemaphore::Signal();
  1778.             thread->blockingSemaphore->timeout = 0;
  1779.             if (thread->status == Waiting) {
  1780.               next = thread;
  1781.               next->status = Running;
  1782.             }
  1783.           }
  1784.           break;
  1786.         case Starting :
  1787.           if (!thread->IsSuspended())
  1788.             next = thread;
  1789.           break;
  1791.         case Terminating :
  1792.           if (thread == current)         // Cannot self terminate
  1793.             next = PProcessInstance;     // So switch to process thread first
  1794.           else {
  1795.             prev->link = thread->link;   // Unlink it from the list
  1796.             if (thread == start)         // If unlinking the "start" thread
  1797.               start = prev;              //    then we better make it still in list
  1798.             thread->status = Terminated; // Flag thread as terminated
  1799.             if (thread->autoDelete)
  1800.               delete thread;             // Destroy if auto-delete
  1801.             thread = prev;
  1802.           }
  1803.           break;
  1805.         default :
  1806.           break;
  1807.       }
  1809.       if (next != NULL)  // Have a thread to run
  1810.         break;
  1812.       // Need to have previous thread so can unlink a terminating thread
  1813.       prev = thread;
  1814.       thread = thread->link;
  1815.       if (thread == start) {
  1816.         pass++;
  1817.         if (pass > 3) // Everything is blocked
  1818.           PProcessInstance->OperatingSystemYield();
  1819.       }
  1820.     }
  1822.     PProcessInstance->currentThread = next;
  1824.     next->SwitchContext(current);
  1826.     // Could get here with a self terminating thread, so go around again if all
  1827.     // we did was switch stacks, and do not actually have a running thread.
  1828.   } while (PProcessInstance->currentThread->status != Running);
  1830.   if (PProcessTerminating) {
  1831.     PProcessTerminating = FALSE;
  1832.     if (PProcessInstance->IsDescendant(PServiceProcess::Class()))
  1833.       ((PServiceProcess *)PProcessInstance)->OnStop();
  1834.     exit(PProcessInstance->terminationValue);
  1835.   }
  1836. }
  1839. #endif
  1842. ///////////////////////////////////////////////////////////////////////////////
  1843. // PSemaphore
  1845. #ifndef P_PLATFORM_HAS_THREADS
  1847. PSemaphore::PSemaphore(unsigned initial, unsigned maxCount)
  1848. {
  1849.   PAssert(maxCount > 0, "Invalid semaphore maximum.");
  1850.   if (initial > maxCount)
  1851.     initial = maxCount;
  1852.   currentCount = initial;
  1853.   maximumCount = maxCount;
  1854. }
  1857. PSemaphore::~PSemaphore()
  1858. {
  1859.   PAssert(blockedThreads.IsEmpty(),
  1860.                         "Semaphore destroyed while still has blocked threads");
  1861. }
  1864. void PSemaphore::Wait()
  1865. {
  1866.   Wait(PMaxTimeInterval);
  1867. }
  1870. BOOL PSemaphore::Wait(const PTimeInterval & time)
  1871. {
  1872.   if (currentCount > 0)
  1873.     currentCount--;
  1874.   else {
  1875.     PThread * thread = PThread::Current();
  1876.     blockedThreads.Enqueue(thread);
  1877.     thread->blockingSemaphore = this;
  1878.     thread->status = PThread::BlockedSem;
  1879.     timeout = time;
  1880.     if (time == PMaxTimeInterval)
  1881.       timeout.Pause();
  1882.     PThread::Yield();
  1883.     if (timeout == 0)
  1884.       return FALSE;
  1885.   }
  1886.   return TRUE;
  1887. }
  1890. void PSemaphore::Signal()
  1891. {
  1892.   if (blockedThreads.GetSize() > 0) {
  1893.     PThread * thread = blockedThreads.Dequeue();
  1894.     switch (thread->status) {
  1895.       case PThread::BlockedSem :
  1896.         thread->status = PThread::Waiting;
  1897.         break;
  1898.       case PThread::SuspendedBlockSem :
  1899.         thread->status = PThread::Suspended;
  1900.         break;
  1901.       default:
  1902.         PAssertAlways("Semaphore unblock of thread that is not blocked");
  1903.     }
  1904.     thread->sleepTimer = 0;
  1905.     timeout = PMaxTimeInterval;
  1906.     timeout.Pause();
  1907.   }
  1908.   else if (currentCount < maximumCount)
  1909.     currentCount++;
  1910. }
  1913. BOOL PSemaphore::WillBlock() const
  1914. {
  1915.   return currentCount == 0;
  1916. }
  1919. PMutex::PMutex()
  1920.   : PSemaphore(1, 1)
  1921. {
  1922. }
  1925. PSyncPoint::PSyncPoint()
  1926.   : PSemaphore(0, 1)
  1927. {
  1928. }
  1931. #endif
  1933. void PSyncPointAck::Signal()
  1934. {
  1935.   PSyncPoint::Signal();
  1936.   ack.Wait();
  1937. }
  1940. void PSyncPointAck::Signal(const PTimeInterval & wait)
  1941. {
  1942.   PSyncPoint::Signal();
  1943.   ack.Wait(wait);
  1944. }
  1947. void PSyncPointAck::Acknowledge()
  1948. {
  1949.   ack.Signal();
  1950. }
  1953. void PCondMutex::WaitCondition()
  1954. {
  1955.   for (;;) {
  1956.     Wait();
  1957.     if (Condition())
  1958.       return;
  1959.     PMutex::Signal();
  1960.     OnWait();
  1961.     syncPoint.Wait();
  1962.   }
  1963. }
  1966. void PCondMutex::Signal()
  1967. {
  1968.   if (Condition())
  1969.     syncPoint.Signal();
  1970.   PMutex::Signal();
  1971. }
  1974. void PCondMutex::OnWait()
  1975. {
  1976.   // Do nothing
  1977. }
  1980. PIntCondMutex::PIntCondMutex(int val, int targ, Operation op)
  1981. {
  1982.   value = val;
  1983.   target = targ;
  1984.   operation = op;
  1985. }
  1988. void PIntCondMutex::PrintOn(ostream & strm) const
  1989. {
  1990.   strm << '(' << value;
  1991.   switch (operation) {
  1992.     case LT :
  1993.       strm << " < ";
  1994.     case LE :
  1995.       strm << " <= ";
  1996.     case GE :
  1997.       strm << " >= ";
  1998.     case GT :
  1999.       strm << " > ";
  2000.     default:
  2001.       strm << " == ";
  2002.   }
  2003.   strm << target << ')';
  2004. }
  2007. BOOL PIntCondMutex::Condition()
  2008. {
  2009.   switch (operation) {
  2010.     case LT :
  2011.       return value < target;
  2012.     case LE :
  2013.       return value <= target;
  2014.     case GE :
  2015.       return value >= target;
  2016.     case GT :
  2017.       return value > target;
  2018.     default :
  2019.       break;
  2020.   }
  2021.   return value == target;
  2022. }
  2025. PIntCondMutex & PIntCondMutex::operator=(int newval)
  2026. {
  2027.   Wait();
  2028.   value = newval;
  2029.   Signal();
  2030.   return *this;
  2031. }
  2034. PIntCondMutex & PIntCondMutex::operator++()
  2035. {
  2036.   Wait();
  2037.   value++;
  2038.   Signal();
  2039.   return *this;
  2040. }
  2043. PIntCondMutex & PIntCondMutex::operator+=(int inc)
  2044. {
  2045.   Wait();
  2046.   value += inc;
  2047.   Signal();
  2048.   return *this;
  2049. }
  2052. PIntCondMutex & PIntCondMutex::operator--()
  2053. {
  2054.   Wait();
  2055.   value--;
  2056.   Signal();
  2057.   return *this;
  2058. }
  2061. PIntCondMutex & PIntCondMutex::operator-=(int dec)
  2062. {
  2063.   Wait();
  2064.   value -= dec;
  2065.   Signal();
  2066.   return *this;
  2067. }
  2070. void PReadWriteMutex::StartRead()
  2071. {
  2072.   starvationPreventer.Wait();
  2073.   starvationPreventer.Signal();
  2074.   ++readers;
  2075. }
  2078. void PReadWriteMutex::EndRead()
  2079. {
  2080.   --readers;
  2081. }
  2084. void PReadWriteMutex::StartWrite()
  2085. {
  2086.   starvationPreventer.Wait();
  2087.   readers.WaitCondition();
  2088. }
  2091. void PReadWriteMutex::EndWrite()
  2092. {
  2093.   starvationPreventer.Signal();
  2094.   readers.Signal();
  2095. }
  2098. // End Of File ///////////////////////////////////////////////////////////////