src/ptlib/msos/msdos.cxx

   1 /*
   2  * msdos.cxx
   3  *
   4  * General class implementation for MS-DOS
   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$
  30  * Revision 1.13  1998/09/24 03:30:50  robertj
  31  * Added open software license.
  32  *
  33  * Revision 1.12  1996/01/28 02:55:32  robertj
  34  * WIN16 support.
  35  *
  36  * Revision 1.11  1995/08/24 12:41:00  robertj
  37  * Changed PChannel so not a PContainer.
  38  *
  39  * Revision 1.10  1995/06/17 00:59:21  robertj
  40  * Moved PPipeChannel::Execute from common dos/windows to individual files.
  41  *
  42  * Revision 1.9  1995/04/01 08:06:03  robertj
  43  * Fixed yield for straight DOS and QUICKWIN systems.
  44  *
  45  * Revision 1.8  1995/03/12 05:00:05  robertj
  46  * Re-organisation of DOS/WIN16 and WIN32 platforms to maximise common code.
  47  * Used built-in equate for WIN32 API (_WIN32).
  48  *
  49  * Revision 1.7  1994/12/13  11:53:44  robertj
  50  * Added missing PConfig Construct() function for pure DOS.
  51  *
  52  * Revision 1.6  1994/10/30  11:25:36  robertj
  53  * Fixed DOS version of configuration files.
  54  *
  55  * Revision 1.5  1994/08/22  00:18:02  robertj
  56  * Added dummy socket function.
  57  *
  58  * Revision 1.4  1994/07/27  06:00:10  robertj
  59  * Backup
  60  *
  61  * Revision 1.3  1994/07/17  11:01:04  robertj
  62  * Ehancements, implementation, bug fixes etc.
  63  *
  64  * Revision 1.2  1994/07/02  03:18:09  robertj
  65  * Multi-threading implementation.
  66  *
  67  * Revision 1.1  1994/06/25  12:13:01  robertj
  68  * Initial revision
  69  */
  70
  71 #include "ptlib.h"
  72
  73 #include <bios.h>
  74 #include <fcntl.h>
  75
  76
  77 ///////////////////////////////////////////////////////////////////////////////
  78 // PTime
  79
  80 PString PTime::GetTimeSeparator()
  81 {
  82   return "";
  83 }
  84
  85
  86 BOOL PTime::GetTimeAMPM()
  87 {
  88   return FALSE;
  89 }
  90
  91
  92 PString PTime::GetTimeAM()
  93 {
  94   return "am";
  95 }
  96
  97
  98 PString PTime::GetTimePM()
  99 {
 100   return "pm";
 101 }
 102
 103
 104 PString PTime::GetDayName(Weekdays dayOfWeek, NameType type)
 105 {
 106   static const char * const weekdays[] = {
 107     "Sunday", "Monday", "Tuesday", "Wednesday",
 108     "Thursday", "Friday", "Saturday"
 109   };
 110   static const char * const abbrev_weekdays[] = {
 111     "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
 112   };
 113   return (type != FullName ? abbrev_weekdays : weekdays)[dayOfWeek];
 114 }
 115
 116
 117 PString PTime::GetDateSeparator()
 118 {
 119   return "-";
 120 }
 121
 122
 123 PString PTime::GetMonthName(Months month, NameType type)
 124 {
 125   static const char * const months[] = { "",
 126     "January", "February", "March", "April", "May", "June",
 127     "July", "August", "September", "October", "November", "December"
 128   };
 129   static const char * const abbrev_months[] = {
 130     "Jan", "Feb", "Mar", "Apr", "May", "Jun",
 131     "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
 132   };
 133   return (type != FullName ? abbrev_months : months)[month];
 134 }
 135
 136
 137 PTime::DateOrder PTime::GetDateOrder()
 138 {
 139   return DayMonthYear;
 140 }
 141
 142
 143 long PTime::GetTimeZone() const
 144 {
 145   return 0;
 146 }
 147
 148
 149 PString PTime::GetTimeZoneString(TimeZoneType type) const
 150 {
 151   return "";
 152 }
 153
 154
 155
 156 ///////////////////////////////////////////////////////////////////////////////
 157 // PSerialChannel
 158
 159 void PSerialChannel::Construct()
 160 {
 161   biosParm = 0xe3; // 9600 baud, no parity, 1 stop bit, 8 data bits
 162 }
 163
 164
 165 PString PSerialChannel::GetName() const
 166 {
 167   if (IsOpen())
 168     return psprintf("COM%i", os_handle+1);
 169
 170   return PString();
 171 }
 172
 173
 174 BOOL PSerialChannel::Read(void * buf, PINDEX len)
 175 {
 176   char * b = (char *)buf;
 177   while (len > 0) {
 178     int c = ReadChar();
 179     if (c >= 0) {
 180       *b++ = (char)c;
 181       len--;
 182     }
 183   }
 184   return len == 0;
 185 }
 186
 187
 188 BOOL PSerialChannel::Write(const void * buf, PINDEX len)
 189 {
 190   const char * b = (const char *)buf;
 191   while (len-- > 0) {
 192     if (!WriteChar(*b++))
 193       return FALSE;
 194   }
 195   return TRUE;
 196 }
 197
 198
 199 BOOL PSerialChannel::Close()
 200 {
 201   if (!IsOpen())
 202     return FALSE;
 203
 204   os_handle = -1;
 205   return TRUE;
 206 }
 207
 208
 209 BOOL PSerialChannel::SetCommsParam(DWORD speed, BYTE data, Parity parity,
 210                      BYTE stop, FlowControl inputFlow, FlowControl outputFlow)
 211 {
 212   switch (speed) {
 213     case 0 :
 214       break;
 215     case 110 :
 216       biosParm &= 0x1f;
 217       break;
 218     case 150 :
 219       biosParm &= 0x1f;
 220       biosParm |= 0x20;
 221       break;
 222     case 300 :
 223       biosParm &= 0x1f;
 224       biosParm |= 0x40;
 225       break;
 226     case 600 :
 227       biosParm &= 0x1f;
 228       biosParm |= 0x60;
 229       break;
 230     case 1200 :
 231       biosParm &= 0x1f;
 232       biosParm |= 0x80;
 233       break;
 234     case 2400 :
 235       biosParm &= 0x1f;
 236       biosParm |= 0xa0;
 237       break;
 238     case 4800 :
 239       biosParm &= 0x1f;
 240       biosParm |= 0xc0;
 241       break;
 242     case 9600 :
 243       biosParm &= 0x1f;
 244       biosParm |= 0xe0;
 245       break;
 246     default :
 247       return FALSE;
 248   }
 249
 250   switch (data) {
 251     case 0 :
 252       break;
 253     case 5 :
 254       biosParm &= 0xfc;
 255       break;
 256     case 6 :
 257       biosParm &= 0xfc;
 258       biosParm |= 1;
 259       break;
 260     case 7 :
 261       biosParm &= 0xfc;
 262       biosParm |= 2;
 263       break;
 264     case 8 :
 265       biosParm &= 0xfc;
 266       biosParm |= 3;
 267       break;
 268     default :
 269       return FALSE;
 270   }
 271
 272   switch (parity) {
 273     case DefaultParity :
 274       break;
 275     case NoParity :
 276       biosParm &= 0xe7;
 277       break;
 278     case OddParity :
 279       biosParm &= 0xe7;
 280       biosParm |= 8;
 281       break;
 282     case EvenParity :
 283       biosParm &= 0xe7;
 284       biosParm |= 0x10;
 285       break;
 286     default :
 287       return FALSE;
 288   }
 289
 290   switch (stop) {
 291     case 0 :
 292       break;
 293     case 1 :
 294       biosParm &= ~4;
 295       break;
 296     case 2 :
 297       biosParm |= 4;
 298       break;
 299     default :
 300       return FALSE;
 301   }
 302
 303   if (outputFlow != DefaultFlowControl || inputFlow != DefaultFlowControl)
 304     return FALSE;
 305
 306   _bios_serialcom(_COM_INIT, os_handle, biosParm);
 307   return TRUE;
 308 }
 309
 310 BOOL PSerialChannel::Open(const PString & port, DWORD speed, BYTE data,
 311        Parity parity, BYTE stop, FlowControl inputFlow, FlowControl outputFlow)
 312 {
 313   Close();
 314
 315   os_handle = -1;
 316   if (PCaselessString("COM") != port.Left(3) &&
 317                                               port[3] >= '1' && port[3] <= '4')
 318     return FALSE;
 319   os_handle = port[3] - '1';
 320   return SetCommsParam(speed, data, parity, stop, inputFlow, outputFlow);
 321 }
 322
 323
 324 BOOL PSerialChannel::SetSpeed(DWORD speed)
 325 {
 326   return SetCommsParam(speed,
 327                  0, DefaultParity, 0, DefaultFlowControl, DefaultFlowControl);
 328 }
 329
 330
 331 DWORD PSerialChannel::GetSpeed() const
 332 {
 333   static int speed[8] = { 110, 150, 300, 600, 1200, 2400, 4800, 9600 };
 334   return speed[biosParm>>5];
 335 }
 336
 337
 338 BOOL PSerialChannel::SetDataBits(BYTE data)
 339 {
 340   return SetCommsParam(0,
 341               data, DefaultParity, 0, DefaultFlowControl, DefaultFlowControl);
 342 }
 343
 344
 345 BYTE PSerialChannel::GetDataBits() const
 346 {
 347   return (BYTE)((biosParm&3)+5);
 348 }
 349
 350
 351 BOOL PSerialChannel::SetParity(Parity parity)
 352 {
 353   return SetCommsParam(0,0, parity, 0, DefaultFlowControl, DefaultFlowControl);
 354 }
 355
 356
 357 PSerialChannel::Parity PSerialChannel::GetParity() const
 358 {
 359   return (biosParm&8) == 0 ? NoParity :
 360                                 (biosParm&0x10) == 0 ? OddParity : EvenParity;
 361 }
 362
 363
 364 BOOL PSerialChannel::SetStopBits(BYTE stop)
 365 {
 366   return SetCommsParam(0,
 367                0, DefaultParity, stop, DefaultFlowControl, DefaultFlowControl);
 368 }
 369
 370
 371 BYTE PSerialChannel::GetStopBits() const
 372 {
 373   return (BYTE)(((biosParm&4)>>3)+1);
 374 }
 375
 376
 377 BOOL PSerialChannel::SetInputFlowControl(FlowControl flowControl)
 378 {
 379   return SetCommsParam(0,0, DefaultParity, 0, flowControl, DefaultFlowControl);
 380 }
 381
 382
 383 PSerialChannel::FlowControl PSerialChannel::GetInputFlowControl() const
 384 {
 385   return RtsCts;
 386 }
 387
 388
 389 BOOL PSerialChannel::SetOutputFlowControl(FlowControl flowControl)
 390 {
 391   return SetCommsParam(0,0, DefaultParity, 0, DefaultFlowControl, flowControl);
 392 }
 393
 394
 395 PSerialChannel::FlowControl PSerialChannel::GetOutputFlowControl() const
 396 {
 397   return RtsCts;
 398 }
 399
 400
 401 void PSerialChannel::SetDTR(BOOL state)
 402 {
 403   if (!IsOpen())
 404     return;
 405
 406 }
 407
 408
 409 void PSerialChannel::SetRTS(BOOL state)
 410 {
 411   if (!IsOpen())
 412     return;
 413
 414 }
 415
 416
 417 void PSerialChannel::SetBreak(BOOL state)
 418 {
 419   if (!IsOpen())
 420     return;
 421
 422   int s = state;
 423 }
 424
 425
 426 BOOL PSerialChannel::GetCTS()
 427 {
 428   if (!IsOpen())
 429     return FALSE;
 430
 431   return (_bios_serialcom(_COM_STATUS, os_handle, 0)&0x8010) == 0x10;
 432 }
 433
 434
 435 BOOL PSerialChannel::GetDSR()
 436 {
 437   if (!IsOpen())
 438     return FALSE;
 439
 440   return (_bios_serialcom(_COM_STATUS, os_handle, 0)&0x8020) == 0x20;
 441 }
 442
 443
 444 BOOL PSerialChannel::GetDCD()
 445 {
 446   if (!IsOpen())
 447     return FALSE;
 448
 449   return (_bios_serialcom(_COM_STATUS, os_handle, 0)&0x8080) == 0x80;
 450 }
 451
 452
 453 BOOL PSerialChannel::GetRing()
 454 {
 455   if (!IsOpen())
 456     return FALSE;
 457
 458   return (_bios_serialcom(_COM_STATUS, os_handle, 0)&0x8040) == 0x40;
 459 }
 460
 461
 462 PStringList PSerialChannel::GetPortNames()
 463 {
 464   static char buf[] = "COM ";
 465   PStringList ports;
 466   for (char p = '1'; p <= '4'; p++) {
 467     if (*(WORD *)(0x00400000+p-'1') != 0) {
 468       buf[3] = p;
 469       ports.Append(new PString(buf));
 470     }
 471   }
 472   return ports;
 473 }
 474
 475
 476 ///////////////////////////////////////////////////////////////////////////////
 477 // PPipeChannel
 478
 479 BOOL PPipeChannel::Execute()
 480 {
 481   if (hasRun)
 482     return FALSE;
 483
 484   flush();
 485   if (os_handle >= 0) {
 486     _close(os_handle);
 487     os_handle = -1;
 488   }
 489
 490   if (!ConvertOSError(system(subProgName)))
 491     return FALSE;
 492
 493   if (!fromChild.IsEmpty()) {
 494     os_handle = _open(fromChild, _O_RDONLY);
 495     if (!ConvertOSError(os_handle))
 496       return FALSE;
 497   }
 498
 499   return TRUE;
 500 }
 501
 502
 503 ///////////////////////////////////////////////////////////////////////////////
 504 // Configuration files
 505
 506 void PConfig::Construct(Source src)
 507 {
 508   switch (src) {
 509     case Application :
 510       PFilePath appFile = PProcess::Current()->GetFile();
 511       location = appFile.GetVolume() +
 512                               appFile.GetPath() + appFile.GetTitle() + ".INI";
 513   }
 514 }
 515
 516
 517 void PConfig::Construct(const PFilePath & file)
 518 {
 519   location = file;
 520 }
 521
 522
 523 PStringList PConfig::GetSections()
 524 {
 525   PStringList sections;
 526
 527   if (!location.IsEmpty()) {
 528     PAssertAlways(PUnimplementedFunction);
 529   }
 530
 531   return sections;
 532 }
 533
 534
 535 PStringList PConfig::GetKeys(const PString &) const
 536 {
 537   PStringList keys;
 538
 539   if (location.IsEmpty()) {
 540     char ** ptr = _environ;
 541     while (*ptr != NULL) {
 542       PString buf = *ptr++;
 543       keys.AppendString(buf.Left(buf.Find('=')));
 544     }
 545   }
 546   else {
 547     PAssertAlways(PUnimplementedFunction);
 548   }
 549
 550   return keys;
 551 }
 552
 553
 554 void PConfig::DeleteSection(const PString &)
 555 {
 556   if (location.IsEmpty())
 557     return;
 558
 559   PAssertAlways(PUnimplementedFunction);
 560 }
 561
 562
 563 void PConfig::DeleteKey(const PString &, const PString & key)
 564 {
 565   if (location.IsEmpty()) {
 566     PAssert(key.Find('=') == P_MAX_INDEX, PInvalidParameter);
 567     _putenv(key + "=");
 568   }
 569   else
 570     PAssertAlways(PUnimplementedFunction);
 571 }
 572
 573
 574 PString PConfig::GetString(const PString &,
 575                                           const PString & key, const PString & dflt)
 576 {
 577   PString str;
 578
 579   if (location.IsEmpty()) {
 580     PAssert(key.Find('=') == P_MAX_INDEX, PInvalidParameter);
 581     char * env = getenv(key);
 582     if (env != NULL)
 583       str = env;
 584     else
 585       str = dflt;
 586   }
 587   else {
 588     PAssertAlways(PUnimplementedFunction);
 589   }
 590   return str;
 591 }
 592
 593
 594 void PConfig::SetString(const PString &, const PString & key, const PString & value)
 595 {
 596   if (location.IsEmpty()) {
 597     PAssert(key.Find('=') == P_MAX_INDEX, PInvalidParameter);
 598     _putenv(key + "=" + value);
 599   }
 600   else
 601     PAssertAlways(PUnimplementedFunction);
 602 }
 603
 604
 605
 606 ///////////////////////////////////////////////////////////////////////////////
 607 // Threads
 608
 609 void PThread::SwitchContext(PThread * from)
 610 {
 611   if (setjmp(from->context) != 0) // Are being reactivated from previous yield
 612     return;
 613
 614   if (status == Starting) {
 615     if (setjmp(context) != 0) {
 616       status = Running;
 617       Main();
 618       Terminate(); // Never returns from here
 619     }
 620     context[7] = (int)stackTop-16;  // Change the stack pointer in jmp_buf
 621   }
 622
 623   longjmp(context, TRUE);
 624   PAssertAlways("longjmp failed"); // Should never get here
 625 }
 626
 627
 628
 629 ///////////////////////////////////////////////////////////////////////////////
 630 // PDynaLink
 631
 632 PDynaLink::PDynaLink()
 633 {
 634   PAssertAlways(PUnimplementedFunction);
 635 }
 636
 637
 638 PDynaLink::PDynaLink(const PString &)
 639 {
 640   PAssertAlways(PUnimplementedFunction);
 641 }
 642
 643
 644 PDynaLink::~PDynaLink()
 645 {
 646 }
 647
 648
 649 BOOL PDynaLink::Open(const PString & name)
 650 {
 651   PAssertAlways(PUnimplementedFunction);
 652   return FALSE;
 653 }
 654
 655
 656 void PDynaLink::Close()
 657 {
 658 }
 659
 660
 661 BOOL PDynaLink::IsLoaded() const
 662 {
 663   return FALSE;
 664 }
 665
 666
 667 BOOL PDynaLink::GetFunction(PINDEX index, Function & func)
 668 {
 669   return FALSE;
 670 }
 671
 672
 673 BOOL PDynaLink::GetFunction(const PString & name, Function & func)
 674 {
 675   return FALSE;
 676 }
 677
 678
 679
 680 // End Of File ///////////////////////////////////////////////////////////////