cde/programs/dtwm/WmResCvt.c

   1 /*
   2  * CDE - Common Desktop Environment
   3  *
   4  * Copyright (c) 1993-2012, The Open Group. All rights reserved.
   5  *
   6  * These libraries and programs are free software; you can
   7  * redistribute them and/or modify them under the terms of the GNU
   8  * Lesser General Public License as published by the Free Software
   9  * Foundation; either version 2 of the License, or (at your option)
  10  * any later version.
  11  *
  12  * These libraries and programs are distributed in the hope that
  13  * they will be useful, but WITHOUT ANY WARRANTY; without even the
  14  * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  15  * PURPOSE. See the GNU Lesser General Public License for more
  16  * details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with these librararies and programs; if not, write
  20  * to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
  21  * Floor, Boston, MA 02110-1301 USA
  22  */
  23 /*
  24  * (c) Copyright 1989, 1990, 1991, 1992, 1993, 1994 OPEN SOFTWARE FOUNDATION, INC.
  25  * ALL RIGHTS RESERVED
  26 */
  27 /*
  28  * Motif Release 1.2.4
  29 */
  30 #ifdef REV_INFO
  31 #ifndef lint
  32 static char rcsid[] = "$XConsortium: WmResCvt.c /main/4 1995/11/01 11:49:54 rswiston $"
  33 #endif
  34 #endif
  35 /*
  36  * (c) Copyright 1987, 1988, 1989, 1990 HEWLETT-PACKARD COMPANY */
  37
  38 /*
  39  * Included Files:
  40  */
  41
  42 #include "WmGlobal.h"
  43 #include "WmResNames.h"
  44 #include <ctype.h>
  45 #include <stdio.h>
  46
  47 #ifndef NO_MULTIBYTE
  48 #include <stdlib.h>
  49 #endif
  50
  51 #ifndef MOTIF_ONE_DOT_ONE
  52 #include <Xm/XmosP.h>
  53 #endif
  54
  55 /*
  56  * include extern functions
  57  */
  58
  59 #include "WmResParse.h"
  60
  61 /*
  62  * Function Declarations:
  63  */
  64
  65 unsigned char *NextToken ();
  66 long           DecStrToL ();
  67
  68 #include "WmResCvt.h"
  69
  70
  71
  72 \f
  73 /*************************************<->*************************************
  74  *
  75  *  AddWmResourceConverters (args)
  76  *
  77  *
  78  *  Description:
  79  *  -----------
  80  *  This function adds resource type converters for mwm specific resource
  81  *  types to the X Toolkit collection.
  82  *
  83  *
  84  *  Inputs:
  85  *  ------
  86  *  XXinput = ...
  87  *
  88  *  XXinput = ...
  89  *
  90  *
  91  *  Outputs:
  92  *  -------
  93  *  XXOutput = ...
  94  *
  95  *
  96  *  Comments:
  97  *  --------
  98  *  XXComments ...
  99  *
 100  *************************************<->***********************************/
 101
 102 void AddWmResourceConverters (void)
 103 {
 104 #ifdef WSM
 105     XtAppAddConverter (wmGD.mwmAppContext, XtRString, WmRAbsentMapBehavior,
 106         (XtConverter)WmCvtStringToAMBehavior, NULL, 0);
 107 #endif /* WSM */
 108     XtAppAddConverter (wmGD.mwmAppContext, XtRString, WmRCFocusPolicy,
 109         (XtConverter)WmCvtStringToCFocus, NULL, 0);
 110     XtAppAddConverter (wmGD.mwmAppContext, XtRString, WmRClientDecor,
 111         (XtConverter)WmCvtStringToCDecor, NULL, 0);
 112     XtAppAddConverter (wmGD.mwmAppContext, XtRString, WmRClientFunction,
 113         (XtConverter)WmCvtStringToCFunc, NULL, 0);
 114     XtAppAddConverter (wmGD.mwmAppContext, XtRString, WmRFrameStyle,
 115         (XtConverter)WmCvtStringToFrameStyle, NULL, 0);
 116     XtAppAddConverter (wmGD.mwmAppContext, XtRString, WmRIconDecor,
 117         (XtConverter)WmCvtStringToIDecor, NULL, 0);
 118     XtAppAddConverter (wmGD.mwmAppContext, XtRString, WmRIconPlacement,
 119         (XtConverter)WmCvtStringToIPlace, NULL, 0);
 120     XtAppAddConverter (wmGD.mwmAppContext, XtRString, WmRKFocusPolicy,
 121         (XtConverter)WmCvtStringToKFocus, NULL, 0);
 122     XtAppAddConverter (wmGD.mwmAppContext, XtRString, WmRSize,
 123         (XtConverter)WmCvtStringToSize, NULL, 0);
 124     XtAppAddConverter (wmGD.mwmAppContext, XtRString, WmRShowFeedback,
 125         (XtConverter)WmCvtStringToShowFeedback, NULL, 0);
 126     XtAppAddConverter (wmGD.mwmAppContext, XtRString, WmRUsePPosition,
 127         (XtConverter)WmCvtStringToUsePPosition, NULL, 0);
 128
 129 } /* END OF FUNCTION AddWmResourceConverters */
 130
 131 #ifdef WSM
 132 \f
 133 /*************************************<->*************************************
 134  *
 135  *  WmCvtStringToAMBehavior (args, numArgs, fromVal, toVal)
 136  *
 137  *
 138  *  Description:
 139  *  -----------
 140  *  This function converts a string to an absent map behavior description.
 141  *
 142  *
 143  *  Inputs:
 144  *  ------
 145  *  args = additional XrmValue arguments to the converter - NULL here
 146  *
 147  *  numArgs = number of XrmValue arguments - 0 here
 148  *
 149  *  fromVal = resource value to convert
 150  *
 151  *
 152  *  Outputs:
 153  *  -------
 154  *  toVal = descriptor to use to return converted value
 155  *
 156  *************************************<->***********************************/
 157
 158 void WmCvtStringToAMBehavior (XrmValue *args, Cardinal numArgs, XrmValue *fromVal, XrmValue *toVal)
 159 {
 160     unsigned char      *pch = (unsigned char *) (fromVal->addr);
 161     unsigned char      *pchNext;
 162     int        len;
 163     static int cval;
 164     Boolean    fHit = False;
 165
 166 /*
 167  * Absent map behavior policies:
 168  */
 169 #define AMAP_BEHAVIOR_ADD_STR           (unsigned char *)"add"
 170 #define AMAP_BEHAVIOR_MOVE_STR          (unsigned char *)"move"
 171 #define AMAP_BEHAVIOR_IGNORE_STR        (unsigned char *)"ignore"
 172
 173     /*
 174      * Convert the absent map behavior policy resource value:
 175      */
 176
 177     if (*pch && NextToken (pch, &len, &pchNext))
 178     {
 179         if ((*pch == 'A') || (*pch == 'a'))
 180         {
 181             if (StringsAreEqual (pch, AMAP_BEHAVIOR_ADD_STR, len))
 182             {
 183                 cval = AMAP_BEHAVIOR_ADD;
 184                 fHit = True;
 185             }
 186         }
 187
 188         else if ((*pch == 'M') || (*pch == 'm'))
 189         {
 190             if (StringsAreEqual (pch, AMAP_BEHAVIOR_MOVE_STR, len))
 191             {
 192                 cval = AMAP_BEHAVIOR_MOVE;
 193                 fHit = True;
 194             }
 195         }
 196
 197         else if ((*pch == 'I') || (*pch == 'i'))
 198         {
 199             if (StringsAreEqual (pch, AMAP_BEHAVIOR_IGNORE_STR, len))
 200             {
 201                 cval = AMAP_BEHAVIOR_IGNORE;
 202                 fHit = True;
 203             }
 204         }
 205     }
 206
 207     if (!fHit)
 208     {
 209         cval =  AMAP_BEHAVIOR_ADD;
 210     }
 211
 212
 213     (*toVal).size = sizeof (int);
 214     (*toVal).addr = (caddr_t)&cval;
 215
 216
 217 } /* END OF FUNCTION WmCvtStringToAMBehavior */
 218 #endif /* WSM */
 219
 220 \f
 221 /*************************************<->*************************************
 222  *
 223  *  WmCvtStringToCFocus (args, numArgs, fromVal, toVal)
 224  *
 225  *
 226  *  Description:
 227  *  -----------
 228  *  This function converts a string to a colormap focus policy description.
 229  *
 230  *
 231  *  Inputs:
 232  *  ------
 233  *  args = additional XrmValue arguments to the converter - NULL here
 234  *
 235  *  numArgs = number of XrmValue arguments - 0 here
 236  *
 237  *  fromVal = resource value to convert
 238  *
 239  *
 240  *  Outputs:
 241  *  -------
 242  *  toVal = descriptor to use to return converted value
 243  *
 244  *************************************<->***********************************/
 245
 246 void WmCvtStringToCFocus (XrmValue *args, Cardinal numArgs, XrmValue *fromVal, XrmValue *toVal)
 247 {
 248     unsigned char      *pch = (unsigned char *) (fromVal->addr);
 249     unsigned char      *pchNext;
 250     int        len;
 251     static int cval;
 252     Boolean    fHit = False;
 253
 254 /*
 255  * Colormap focus policies:
 256  */
 257
 258 #define CMAP_FOCUS_EXPLICIT_STR         (unsigned char *)"explicit"
 259 #define CMAP_FOCUS_KEYBOARD_STR         (unsigned char *)"keyboard"
 260 #define CMAP_FOCUS_POINTER_STR          (unsigned char *)"pointer"
 261
 262
 263     /*
 264      * Convert the colormap focus policy resource value:
 265      */
 266
 267     if (*pch && NextToken (pch, &len, &pchNext))
 268     {
 269         if ((*pch == 'E') || (*pch == 'e'))
 270         {
 271             if (StringsAreEqual (pch, CMAP_FOCUS_EXPLICIT_STR, len))
 272             {
 273                 cval = CMAP_FOCUS_EXPLICIT;
 274                 fHit = True;
 275             }
 276         }
 277
 278         else if ((*pch == 'K') || (*pch == 'k'))
 279         {
 280             if (StringsAreEqual (pch, CMAP_FOCUS_KEYBOARD_STR, len))
 281             {
 282                 cval = CMAP_FOCUS_KEYBOARD;
 283                 fHit = True;
 284             }
 285         }
 286
 287         else if ((*pch == 'P') || (*pch == 'p'))
 288         {
 289             if (StringsAreEqual (pch, CMAP_FOCUS_POINTER_STR, len))
 290             {
 291                 cval = CMAP_FOCUS_POINTER;
 292                 fHit = True;
 293             }
 294         }
 295     }
 296
 297     if (!fHit)
 298     {
 299         cval =  CMAP_FOCUS_KEYBOARD;
 300     }
 301
 302
 303     (*toVal).size = sizeof (int);
 304     (*toVal).addr = (caddr_t)&cval;
 305
 306
 307 } /* END OF FUNCTION WmCvtStringToCFocus */
 308
 309
 310 \f
 311 /*************************************<->*************************************
 312  *
 313  *  WmCvtStringToCDecor (args, numArgs, fromVal, toVal)
 314  *
 315  *
 316  *  Description:
 317  *  -----------
 318  *  This function converts a string to a mwm client window frame decoration
 319  *  description.
 320  *
 321  *
 322  *  Inputs:
 323  *  ------
 324  *  args = NULL (don't care)
 325  *
 326  *  numArgs = 0 (don't care)
 327  *
 328  *  fromVal = resource value to convert
 329  *
 330  *
 331  *  Outputs:
 332  *  -------
 333  *  toVal = descriptor to use to return converted value
 334  *
 335  *
 336  *  Comments:
 337  *  --------
 338  *  o Accepts the following syntax:
 339  *
 340  *    CDecor ::= [sign] decor_spec [decor_spec ...]
 341  *
 342  *    sign ::= ['+' | '-']
 343  *
 344  *    decor_spec ::= [sign] decor_name
 345  *
 346  *    decor_name ::=  "all" | "none" | "title" | "titlebar" |
 347  *                     "menu" | "minimize" | "maximize" | "resize"
 348  *
 349  *************************************<->***********************************/
 350
 351 void WmCvtStringToCDecor (XrmValue *args, Cardinal numArgs, XrmValue *fromVal, XrmValue *toVal)
 352 {
 353     unsigned char      *pch = (unsigned char *) (fromVal->addr);
 354     unsigned char      *pchNext;
 355     int        len;
 356     static int cval;
 357     Boolean    fHit = False;
 358     Boolean    fAddNext = True;
 359 /*
 360  * Client decoration parts:
 361  */
 362
 363 #define WM_DECOR_ALL_STR                (unsigned char *)"all"
 364 #define WM_DECOR_NONE_STR               (unsigned char *)"none"
 365 #define WM_DECOR_BORDER_STR             (unsigned char *)"border"
 366 #define WM_DECOR_RESIZEH_STR            (unsigned char *)"resizeh"
 367 #define WM_DECOR_TITLE_STR              (unsigned char *)"title"
 368 #define WM_DECOR_TITLEBAR_STR           (unsigned char *)"titlebar"
 369 #define WM_DECOR_MINIMIZE_STR           (unsigned char *)"minimize"
 370 #define WM_DECOR_MAXIMIZE_STR           (unsigned char *)"maximize"
 371 #define WM_DECOR_MENU_STR               (unsigned char *)"menu"
 372 #define WM_DECOR_RESIZE_STR             (unsigned char *)"resize"
 373
 374     /*
 375      * Check first token. If '-' we subtract from all decoration.
 376      * Otherwise, we start with no decoration and add things in.
 377      */
 378     if (*pch &&
 379         (NextToken (pch, &len, &pchNext)) &&
 380         (*pch == '-'))
 381     {
 382         cval = WM_DECOR_ALL;
 383         fHit = True;
 384     }
 385     else
 386     {
 387         cval = WM_DECOR_NONE;
 388     }
 389
 390
 391     while (*pch && NextToken(pch, &len, &pchNext))
 392     {
 393            /*
 394             * Strip off "sign" if prepended to another token, and process
 395             * that token the next time through.
 396             */
 397
 398         if (*pch == '+')
 399         {
 400             if (len != 1)
 401             {
 402                 pchNext = pch + 1;
 403             }
 404             fAddNext = TRUE;
 405         }
 406
 407         else if (*pch == '-')
 408         {
 409             if (len != 1)
 410             {
 411                 pchNext = pch + 1;
 412             }
 413             fAddNext = FALSE;
 414         }
 415
 416         else if ((*pch == 'A') || (*pch == 'a'))
 417         {
 418             if (StringsAreEqual(pch, WM_DECOR_ALL_STR,len))
 419             {
 420                 cval = fAddNext ? (cval | WM_DECOR_ALL) :
 421                                  (cval & ~WM_DECOR_ALL);
 422                 fHit = True;
 423             }
 424         }
 425
 426         else if ((*pch == 'N') || (*pch == 'n'))
 427         {
 428             if (StringsAreEqual(pch, WM_DECOR_NONE_STR,len))
 429             {
 430                 /* don't bother adding or subtracting nothing */
 431                 fHit = True;
 432             }
 433         }
 434
 435         else if ((*pch == 'T') || (*pch == 't'))
 436         {
 437             if (StringsAreEqual(pch, WM_DECOR_TITLE_STR,len))
 438             {
 439                 cval = fAddNext ? (cval | WM_DECOR_TITLE) :
 440                                   (cval & ~WM_DECOR_TITLEBAR);
 441                 fHit = True;
 442             }
 443             else if (StringsAreEqual(pch, WM_DECOR_TITLEBAR_STR,len))
 444             {
 445                 cval = fAddNext ? (cval | WM_DECOR_TITLEBAR) :
 446                                   (cval & ~WM_DECOR_TITLEBAR);
 447                 fHit = True;
 448             }
 449         }
 450
 451         else if ((*pch == 'M') || (*pch == 'm'))
 452         {
 453             if (StringsAreEqual(pch, WM_DECOR_MINIMIZE_STR,len))
 454             {
 455                 cval = fAddNext ? (cval | WM_DECOR_MINIMIZE) :
 456                                   (cval & ~MWM_DECOR_MINIMIZE);
 457                 fHit = True;
 458             }
 459             else if (StringsAreEqual(pch, WM_DECOR_MAXIMIZE_STR,len))
 460             {
 461                 cval = fAddNext ? (cval | WM_DECOR_MAXIMIZE) :
 462                                   (cval & ~MWM_DECOR_MAXIMIZE);
 463                 fHit = True;
 464             }
 465             else if (StringsAreEqual(pch, WM_DECOR_MENU_STR,len))
 466             {
 467                 cval = fAddNext ? (cval | WM_DECOR_SYSTEM) :
 468                                   (cval & ~MWM_DECOR_MENU);
 469                 fHit = True;
 470             }
 471         }
 472
 473         else if ((*pch == 'R') || (*pch == 'r'))
 474         {
 475             if (StringsAreEqual(pch, WM_DECOR_RESIZE_STR,len) ||
 476                 StringsAreEqual(pch, WM_DECOR_RESIZEH_STR,len))
 477             {
 478                 cval = fAddNext ? (cval | WM_DECOR_RESIZEH) :
 479                                   (cval & ~MWM_DECOR_RESIZEH);
 480                 fHit = True;
 481             }
 482         }
 483
 484         else if ((*pch == 'B') || (*pch == 'b'))
 485         {
 486             if (StringsAreEqual(pch, WM_DECOR_BORDER_STR,len))
 487             {
 488                 cval = fAddNext ? (cval | WM_DECOR_BORDER) :
 489                                   (cval & ~WM_DECOR_BORDER);
 490                 fHit = True;
 491             }
 492         }
 493
 494         pch = pchNext;
 495     }
 496
 497     if (!fHit) cval =  WM_DECOR_ALL;
 498
 499     (*toVal).size = sizeof (int);
 500     (*toVal).addr = (caddr_t) &cval;
 501
 502 } /* END OF FUNCTION WmCvtStringToCDecor */
 503
 504
 505 \f
 506 /*************************************<->*************************************
 507  *
 508  *  WmCvtStringToCFunc (args, numArgs, fromVal, toVal)
 509  *
 510  *
 511  *  Description:
 512  *  -----------
 513  *  This function converts a string to a mwm client-applicable function
 514  *  description.
 515  *
 516  *
 517  *  Inputs:
 518  *  ------
 519  *  args = NULL (don't care)
 520  *
 521  *  numArgs = 0 (don't care)
 522  *
 523  *  fromVal = resource value to convert
 524  *
 525  *
 526  *  Outputs:
 527  *  -------
 528  *  toVal = descriptor to use to return converted value
 529  *
 530  *
 531  *  Comments:
 532  *  --------
 533  *  o Accepts the following syntax:
 534  *
 535  *    CFunc ::= [sign] func_spec [func_spec ...]
 536  *
 537  *    sign ::= ['+' | '-']
 538  *
 539  *    func_spec ::= [sign] func_name
 540  *
 541  *    func_name ::=  "all" | "none" | "resize" | "move" | "minimize" |
 542  *                   "maximize" | "close"
 543  *
 544  *************************************<->***********************************/
 545
 546 void WmCvtStringToCFunc (XrmValue *args, Cardinal numArgs, XrmValue *fromVal, XrmValue *toVal)
 547 {
 548     unsigned char      *pch = (unsigned char *) (fromVal->addr);
 549     unsigned char      *pchNext;
 550     int        len;
 551     static int cval;
 552     Boolean    fHit = False;
 553     Boolean    fAddNext = True;
 554
 555 /*
 556  * Client-applicable functions:
 557  */
 558
 559 #define WM_FUNC_ALL_STR                 (unsigned char *)"all"
 560 #define WM_FUNC_NONE_STR                (unsigned char *)"none"
 561 #define WM_FUNC_RESIZE_STR              (unsigned char *)"resize"
 562 #define WM_FUNC_MOVE_STR                (unsigned char *)"move"
 563 #define WM_FUNC_MINIMIZE_STR            (unsigned char *)"minimize"
 564 #define WM_FUNC_MAXIMIZE_STR            (unsigned char *)"maximize"
 565 #define WM_FUNC_CLOSE_STR               (unsigned char *)"close"
 566
 567     /*
 568      * Check first token. If '-' we subtract from all functions.
 569      * Otherwise, we start with no functions and add things in.
 570      */
 571
 572     if (*pch &&
 573         (NextToken (pch, &len, &pchNext)) &&
 574         (*pch == '-'))
 575     {
 576         cval = WM_FUNC_ALL;
 577         fHit = True;
 578     }
 579     else
 580     {
 581         cval = WM_FUNC_NONE;
 582     }
 583
 584
 585     while (*pch && NextToken(pch, &len, &pchNext))
 586     {
 587            /*
 588             * Strip off "sign" if prepended to another token, and process
 589             * that token the next time through.
 590             */
 591
 592         if (*pch == '+')
 593         {
 594             if (len != 1)
 595             {
 596                 pchNext = pch + 1;
 597             }
 598             fAddNext = TRUE;
 599         }
 600
 601         else if (*pch == '-')
 602         {
 603             if (len != 1)
 604             {
 605                 pchNext = pch + 1;
 606             }
 607             fAddNext = FALSE;
 608         }
 609
 610         else if ((*pch == 'A') || (*pch == 'a'))
 611         {
 612             if (StringsAreEqual(pch, WM_FUNC_ALL_STR,len))
 613             {
 614                 cval = fAddNext ? (cval | WM_FUNC_ALL) :
 615                                   (cval & ~WM_FUNC_ALL);
 616                 fHit = True;
 617             }
 618         }
 619
 620         else if ((*pch == 'N') || (*pch == 'n'))
 621         {
 622             if (StringsAreEqual(pch, WM_FUNC_NONE_STR,len))
 623             {
 624                 /* don't bother adding or subtracting nothing */
 625                 fHit = True;
 626             }
 627         }
 628
 629         else if ((*pch == 'R') || (*pch == 'r'))
 630         {
 631             if (StringsAreEqual(pch, WM_FUNC_RESIZE_STR,len))
 632             {
 633                 cval = fAddNext ? (cval | MWM_FUNC_RESIZE) :
 634                                   (cval & ~MWM_FUNC_RESIZE);
 635                 fHit = True;
 636             }
 637         }
 638
 639         else if ((*pch == 'M') || (*pch == 'm'))
 640         {
 641             if (StringsAreEqual(pch, WM_FUNC_MINIMIZE_STR,len))
 642             {
 643                 cval = fAddNext ? (cval | MWM_FUNC_MINIMIZE) :
 644                                   (cval & ~MWM_FUNC_MINIMIZE);
 645                 fHit = True;
 646             }
 647             else if (StringsAreEqual(pch, WM_FUNC_MAXIMIZE_STR,len))
 648             {
 649                 cval = fAddNext ? (cval | MWM_FUNC_MAXIMIZE) :
 650                                   (cval & ~MWM_FUNC_MAXIMIZE);
 651                 fHit = True;
 652             }
 653             else if (StringsAreEqual(pch, WM_FUNC_MOVE_STR,len))
 654             {
 655                 cval = fAddNext ? (cval | MWM_FUNC_MOVE) :
 656                                   (cval & ~MWM_FUNC_MOVE);
 657                 fHit = True;
 658             }
 659         }
 660
 661         else if ((*pch == 'C') || (*pch == 'c'))
 662         {
 663             if (StringsAreEqual(pch, WM_FUNC_CLOSE_STR,len))
 664             {
 665                 cval = fAddNext ? (cval | MWM_FUNC_CLOSE) :
 666                                   (cval & ~MWM_FUNC_CLOSE);
 667                 fHit = True;
 668             }
 669         }
 670
 671         pch = pchNext;
 672     }
 673
 674     if (!fHit) cval =  WM_FUNC_ALL;
 675
 676     (*toVal).size = sizeof (int);
 677     (*toVal).addr = (caddr_t) &cval;
 678
 679 } /* END OF FUNCTION WmCvtStringToCFunc */
 680
 681 \f
 682 /*************************************<->*************************************
 683  *
 684  *  WmCvtStringToFrameStyle (args, numArgs, fromVal, toVal)
 685  *
 686  *
 687  *  Description:
 688  *  -----------
 689  *  This function converts a string to a frame style description.
 690  *
 691  *
 692  *  Inputs:
 693  *  ------
 694  *  args = NULL (don't care)
 695  *
 696  *  numArgs = 0 (don't care)
 697  *
 698  *  fromVal = resource value to convert
 699  *
 700  *
 701  *  Outputs:
 702  *  -------
 703  *  toVal = descriptor to use to return converted value
 704  *
 705  *************************************<->***********************************/
 706
 707 void WmCvtStringToFrameStyle (XrmValue *args, Cardinal numArgs, XrmValue *fromVal, XrmValue *toVal)
 708 {
 709     unsigned char      *pch = (unsigned char *) (fromVal->addr);
 710     unsigned char      *pchNext;
 711     int        len;
 712     static FrameStyle frameStyle;
 713     Boolean    fHit = False;
 714
 715
 716 #define FRAME_STYLE_RECESSED_STR        (unsigned char *)"recessed"
 717 #define FRAME_STYLE_SLAB_STR            (unsigned char *)"slab"
 718
 719     /*
 720      * Convert the resource value:
 721      */
 722
 723     if (*pch && NextToken (pch, &len, &pchNext))
 724     {
 725         if ((*pch == 'R') || (*pch == 'r'))
 726         {
 727             if (StringsAreEqual (pch, FRAME_STYLE_RECESSED_STR, len))
 728             {
 729                 frameStyle = WmRECESSED;
 730                 fHit = True;
 731             }
 732         }
 733         else if (StringsAreEqual (pch, FRAME_STYLE_SLAB_STR, len))
 734         {
 735             frameStyle = WmSLAB;
 736             fHit = True;
 737         }
 738     }
 739
 740     if (!fHit)
 741     {
 742         frameStyle = WmRECESSED;
 743     }
 744
 745     (*toVal).size = sizeof (FrameStyle);
 746     (*toVal).addr = (caddr_t)&frameStyle;
 747
 748
 749 } /* END OF FUNCTION WmCvtStringToFrameStyle */
 750
 751
 752 \f
 753 /*************************************<->*************************************
 754  *
 755  *  WmCvtStringToIDecor (args, numArgs, fromVal, toVal)
 756  *
 757  *
 758  *  Description:
 759  *  -----------
 760  *  This function converts a string to an icon decoration description.
 761  *
 762  *
 763  *  Inputs:
 764  *  ------
 765  *  args = NULL (don't care)
 766  *
 767  *  numArgs = 0 (don't care)
 768  *
 769  *  fromVal = resource value to convert
 770  *
 771  *
 772  *  Outputs:
 773  *  -------
 774  *  toVal = descriptor to use to return converted value
 775  *
 776  *************************************<->***********************************/
 777
 778 void WmCvtStringToIDecor (XrmValue *args, Cardinal numArgs, XrmValue *fromVal, XrmValue *toVal)
 779 {
 780     unsigned char       *pch = (unsigned char *) (fromVal->addr);
 781     unsigned char       *pchNext;
 782     int         len;
 783     static int cval;
 784     Boolean     fHit = False;
 785
 786 /*
 787  * Icon decoration parts:
 788  */
 789
 790 #define ICON_DECOR_IMAGE_STR            (unsigned char *)"image"
 791 #define ICON_DECOR_LABEL_STR            (unsigned char *)"label"
 792 #define ICON_DECOR_ACTIVE_LABEL_STR     (unsigned char *)"activelabel"
 793
 794
 795     /*
 796      * Convert the icon decoration resource value:
 797      */
 798
 799     cval = 0;
 800
 801     while (*pch && NextToken (pch, &len, &pchNext))
 802     {
 803         if ((*pch == 'A') || (*pch == 'a'))
 804         {
 805             if (StringsAreEqual (pch, ICON_DECOR_ACTIVE_LABEL_STR, len))
 806             {
 807                 cval |= ICON_ACTIVE_LABEL_PART;
 808                 fHit = True;
 809             }
 810         }
 811
 812         else if ((*pch == 'I') || (*pch == 'i'))
 813         {
 814             if (StringsAreEqual (pch, ICON_DECOR_IMAGE_STR, len))
 815             {
 816                 cval |= ICON_IMAGE_PART;
 817                 fHit = True;
 818             }
 819         }
 820
 821         else if ((*pch == 'L') || (*pch == 'l'))
 822         {
 823             if (StringsAreEqual (pch, ICON_DECOR_LABEL_STR, len))
 824             {
 825                 cval |= ICON_LABEL_PART;
 826                 fHit = True;
 827             }
 828         }
 829
 830         pch = pchNext;
 831     }
 832
 833     /*
 834      * If we didn't match anything or only have the active label
 835      * (which is just a modifier) then give 'em the whole ball of wax.
 836      */
 837     if (!fHit || cval == ICON_ACTIVE_LABEL_PART)
 838     {
 839         cval =  ICON_LABEL_PART | ICON_IMAGE_PART | ICON_ACTIVE_LABEL_PART;
 840     }
 841
 842
 843     (*toVal).size = sizeof (int);
 844     (*toVal).addr = (caddr_t) &cval;
 845
 846 } /* END OF FUNCTION WmCvtStringToIDecor */
 847
 848
 849 \f
 850 /*************************************<->*************************************
 851  *
 852  *  WmCvtStringToIPlace (args, numArgs, fromVal, toVal)
 853  *
 854  *
 855  *  Description:
 856  *  -----------
 857  *  This function converts a string to an icon placement scheme description.
 858  *
 859  *
 860  *  Inputs:
 861  *  ------
 862  *  args = NULL (don't care)
 863  *
 864  *  numArgs = 0 (don't care)
 865  *
 866  *  fromVal = resource value to convert
 867  *
 868  *
 869  *  Outputs:
 870  *  -------
 871  *  toVal = descriptor to use to return converted value
 872  *
 873  *************************************<->***********************************/
 874
 875 void WmCvtStringToIPlace (XrmValue *args, Cardinal numArgs, XrmValue *fromVal, XrmValue *toVal)
 876 {
 877     unsigned char       *pch = (unsigned char *) (fromVal->addr);
 878     unsigned char       *pchNext;
 879     int         len;
 880     static int cval;
 881     Boolean     fPrimarySet = False;
 882     Boolean     fSecondarySet = False;
 883
 884 /*
 885  * Icon placement layout values:
 886  */
 887
 888 #define ICON_PLACE_BOTTOM_STR           (unsigned char *)"bottom"
 889 #define ICON_PLACE_LEFT_STR             (unsigned char *)"left"
 890 #define ICON_PLACE_RIGHT_STR            (unsigned char *)"right"
 891 #define ICON_PLACE_TOP_STR              (unsigned char *)"top"
 892 #define ICON_PLACE_TIGHT_STR            (unsigned char *)"tight"
 893
 894
 895     /*
 896      * Convert the icon placement resource value:
 897      */
 898
 899     cval = 0;
 900
 901     while (*pch && NextToken (pch, &len, &pchNext))
 902     {
 903         if ((*pch == 'B') || (*pch == 'b'))
 904         {
 905             if (StringsAreEqual (pch, ICON_PLACE_BOTTOM_STR, len))
 906             {
 907                 if (!fPrimarySet)
 908                 {
 909                     cval |= ICON_PLACE_BOTTOM_PRIMARY;
 910                     fPrimarySet = True;
 911                 }
 912                 else if (!fSecondarySet)
 913                 {
 914                     if (!(cval &
 915                       (ICON_PLACE_BOTTOM_PRIMARY | ICON_PLACE_TOP_PRIMARY)))
 916                     {
 917                         cval |= ICON_PLACE_BOTTOM_SECONDARY;
 918                         fSecondarySet = True;
 919                     }
 920                 }
 921             }
 922         }
 923         else if ((*pch == 'L') || (*pch == 'l'))
 924         {
 925             if (StringsAreEqual (pch, ICON_PLACE_LEFT_STR, len))
 926             {
 927                 if (!fPrimarySet)
 928                 {
 929                     cval |= ICON_PLACE_LEFT_PRIMARY;
 930                     fPrimarySet = True;
 931                 }
 932                 else if (!fSecondarySet)
 933                 {
 934                     if (!(cval &
 935                         (ICON_PLACE_LEFT_PRIMARY | ICON_PLACE_RIGHT_PRIMARY)))
 936                     {
 937                         cval |= ICON_PLACE_LEFT_SECONDARY;
 938                         fSecondarySet = True;
 939                     }
 940                 }
 941             }
 942         }
 943
 944         else if ((*pch == 'R') || (*pch == 'r'))
 945         {
 946             if (StringsAreEqual (pch, ICON_PLACE_RIGHT_STR, len))
 947             {
 948                 if (!fPrimarySet)
 949                 {
 950                     cval |= ICON_PLACE_RIGHT_PRIMARY;
 951                     fPrimarySet = True;
 952                 }
 953                 else if (!fSecondarySet)
 954                 {
 955                     if (!(cval &
 956                         (ICON_PLACE_RIGHT_PRIMARY | ICON_PLACE_LEFT_PRIMARY)))
 957                     {
 958                         cval |= ICON_PLACE_RIGHT_SECONDARY;
 959                         fSecondarySet = True;
 960                     }
 961                 }
 962             }
 963         }
 964
 965         else if ((*pch == 'T') || (*pch == 't'))
 966         {
 967             if (StringsAreEqual (pch, ICON_PLACE_TOP_STR, len))
 968             {
 969                 if (!fPrimarySet)
 970                 {
 971                     cval |= ICON_PLACE_TOP_PRIMARY;
 972                     fPrimarySet = True;
 973                 }
 974                 else if (!fSecondarySet)
 975                 {
 976                     if (!(cval &
 977                         (ICON_PLACE_TOP_PRIMARY | ICON_PLACE_BOTTOM_PRIMARY)))
 978                     {
 979                         cval |= ICON_PLACE_TOP_SECONDARY;
 980                         fSecondarySet = True;
 981                     }
 982                 }
 983             }
 984
 985             else if (StringsAreEqual (pch, ICON_PLACE_TIGHT_STR, len))
 986             {
 987                 cval |= ICON_PLACE_TIGHT;
 988             }
 989         }
 990
 991         pch = pchNext;
 992     }
 993
 994     if (!fPrimarySet)
 995     {
 996         cval =  ICON_PLACE_LEFT_PRIMARY;
 997     }
 998     if (!fSecondarySet)
 999     {
1000         if (cval & (ICON_PLACE_LEFT_PRIMARY | ICON_PLACE_RIGHT_PRIMARY))
1001         {
1002             cval |= ICON_PLACE_BOTTOM_SECONDARY;
1003         }
1004         else
1005         {
1006             cval |= ICON_PLACE_LEFT_SECONDARY;
1007         }
1008     }
1009
1010
1011     (*toVal).size = sizeof (int);
1012     (*toVal).addr = (caddr_t) &cval;
1013
1014 } /* END OF FUNCTION WmCvtStringToIPlace */
1015
1016
1017 \f
1018 /*************************************<->*************************************
1019  *
1020  *  WmCvtStringToKFocus (args, numArgs, fromVal, toVal)
1021  *
1022  *
1023  *  Description:
1024  *  -----------
1025  *  This function converts a string to a keyboard focus policy description.
1026  *
1027  *
1028  *  Inputs:
1029  *  ------
1030  *  args = NULL (don't care)
1031  *
1032  *  numArgs = 0 (don't care)
1033  *
1034  *  fromVal = resource value to convert
1035  *
1036  *
1037  *  Outputs:
1038  *  -------
1039  *  toVal = descriptor to use to return converted value
1040  *
1041  *************************************<->***********************************/
1042
1043 void WmCvtStringToKFocus (XrmValue *args, Cardinal numArgs, XrmValue *fromVal, XrmValue *toVal)
1044 {
1045     unsigned char      *pch = (unsigned char *) (fromVal->addr);
1046     unsigned char      *pchNext;
1047     int        len;
1048     static int cval;
1049     Boolean    fHit = False;
1050
1051 /*
1052  * Keyboard focus policies:
1053  */
1054
1055 #define KEYBOARD_FOCUS_EXPLICIT_STR             (unsigned char *)"explicit"
1056 #define KEYBOARD_FOCUS_POINTER_STR              (unsigned char *)"pointer"
1057
1058
1059     /*
1060      * Convert the keyboard focus policy resource value:
1061      */
1062
1063     if (*pch && NextToken (pch, &len, &pchNext))
1064     {
1065         if ((*pch == 'E') || (*pch == 'e'))
1066         {
1067             if (StringsAreEqual (pch, KEYBOARD_FOCUS_EXPLICIT_STR, len))
1068             {
1069                 cval = KEYBOARD_FOCUS_EXPLICIT;
1070                 fHit = True;
1071             }
1072         }
1073
1074         else if ((*pch == 'P') || (*pch == 'p'))
1075         {
1076             if (StringsAreEqual (pch, KEYBOARD_FOCUS_POINTER_STR, len))
1077             {
1078                 cval = KEYBOARD_FOCUS_POINTER;
1079                 fHit = True;
1080             }
1081         }
1082     }
1083
1084     if (!fHit)
1085     {
1086         cval =  KEYBOARD_FOCUS_EXPLICIT;
1087     }
1088
1089
1090     (*toVal).size = sizeof (int);
1091     (*toVal).addr = (caddr_t)&cval;
1092
1093
1094 } /* END OF FUNCTION WmCvtStringToKFocus */
1095
1096
1097 \f
1098 /*************************************<->*************************************
1099  *
1100  *  WmCvtStringToSize (args, numArgs, fromVal, toVal)
1101  *
1102  *
1103  *  Description:
1104  *  -----------
1105  *  This function converts a string to a size description (<width>x<height>).
1106  *
1107  *
1108  *  Inputs:
1109  *  ------
1110  *  args = NULL (don't care)
1111  *
1112  *  numArgs = 0 (don't care)
1113  *
1114  *  fromVal = resource value to convert
1115  *
1116  *
1117  *  Outputs:
1118  *  -------
1119  *  toVal = descriptor to use to return converted value
1120  *
1121  *************************************<->***********************************/
1122
1123 void WmCvtStringToSize (XrmValue *args, Cardinal numArgs, XrmValue *fromVal, XrmValue *toVal)
1124 {
1125     unsigned char  *pch = (unsigned char *) (fromVal->addr);
1126     unsigned char  *pchNext;
1127     static WHSize cval;
1128     int        len;
1129
1130 /*
1131  * Convenience values for WmSize:
1132  */
1133
1134 #define VERTICAL_STR    (unsigned char *)"vertical"
1135 #define HORIZONTAL_STR  (unsigned char *)"horizontal"
1136
1137
1138     /*
1139      * Convert the size resource value.  The syntax is "<width>[xX]<height>"
1140      * OR it is the string 'vertical' or 'horizontal'.  It's kinda neat that
1141      * BIGSIZE is a legal Dimension so that we get vertical and horizontal
1142      * for free.
1143      */
1144
1145     cval.width = 0;
1146     cval.height = 0;
1147
1148     if (*pch)
1149     {
1150         cval.width = (int) DecStrToL (pch, &pchNext);
1151         if (!((cval.width == 0) && (pchNext == pch)))
1152         {
1153             /*
1154              * Width was converted.
1155              * Check for a delimiter (must be 'x' or 'X'):
1156              */
1157
1158             pch = pchNext;
1159             if (*pch && ((*pch == 'x') || (*pch == 'X')))
1160             {
1161                 /*
1162                  * Delimiter found now get the height:
1163                  */
1164
1165                 pch++;
1166                 cval.height = (int) DecStrToL (pch, &pchNext);
1167             }
1168         }
1169         else
1170         {
1171             if (*pch && NextToken (pch, &len, &pchNext))
1172             {
1173                 if ((*pch == 'V') || (*pch == 'v'))
1174                 {
1175                     if (StringsAreEqual (pch, VERTICAL_STR, len))
1176                     {
1177                         cval.height = BIGSIZE;
1178                     }
1179                 }
1180                 else if ((*pch == 'H') || (*pch == 'h'))
1181                 {
1182                     if (StringsAreEqual (pch, HORIZONTAL_STR, len))
1183                     {
1184                         cval.width = BIGSIZE;
1185                     }
1186                 }
1187             }
1188         }
1189     }
1190
1191     /* !!! check for the maximum maximum sizes !!! */
1192
1193     (*toVal).size = sizeof (WHSize);
1194     (*toVal).addr = (caddr_t)&cval;
1195
1196
1197 } /* END OF FUNCTION WmCvtStringToSize */
1198
1199 \f
1200 /*************************************<->*************************************
1201  *
1202  *  WmCvtStringToShowFeedback (args, numArgs, fromVal, toVal)
1203  *
1204  *
1205  *  Description:
1206  *  -----------
1207  *  This function converts a string to a value for the showFeedback flag set.
1208  *
1209  *
1210  *  Inputs:
1211  *  ------
1212  *  args = NULL (don't care)
1213  *
1214  *  numArgs = 0 (don't care)
1215  *
1216  *  fromVal = resource value to convert
1217  *
1218  *
1219  *  Outputs:
1220  *  -------
1221  *  toVal = descriptor to use to return converted value
1222  *
1223  *************************************<->***********************************/
1224
1225 void WmCvtStringToShowFeedback (XrmValue *args, Cardinal numArgs, XrmValue *fromVal, XrmValue *toVal)
1226 {
1227     unsigned char       *pch = (unsigned char *) (fromVal->addr);
1228     unsigned char       *pchNext;
1229     int         len;
1230     static int cval;
1231     Boolean     fHit = False;
1232     Boolean    fAddNext = True;
1233
1234 /*
1235  * Names of feedback options
1236  */
1237
1238 #define SHOW_FB_ALL_STR         (unsigned char *)"all"
1239 #define SHOW_FB_BEHAVIOR_STR    (unsigned char *)"behavior"
1240 #define SHOW_FB_KILL_STR        (unsigned char *)"kill"
1241 #define SHOW_FB_MOVE_STR        (unsigned char *)"move"
1242 #define SHOW_FB_NONE_STR        (unsigned char *)"none"
1243 #define SHOW_FB_PLACEMENT_STR   (unsigned char *)"placement"
1244 #define SHOW_FB_QUIT_STR        (unsigned char *)"quit"
1245 #define SHOW_FB_RESIZE_STR      (unsigned char *)"resize"
1246 #define SHOW_FB_RESTART_STR     (unsigned char *)"restart"
1247
1248     /*
1249      * Check first token. If '-' we subtract from all functions.
1250      * Otherwise, we start with no functions and add things in.
1251      */
1252
1253     if (*pch &&
1254         (NextToken (pch, &len, &pchNext)) &&
1255         (*pch == '-'))
1256     {
1257         cval = WM_SHOW_FB_DEFAULT;
1258         fHit = True;
1259     }
1260     else
1261     {
1262         cval = WM_SHOW_FB_NONE;
1263     }
1264
1265
1266     /*
1267      * Convert the feedback option resource value:
1268      */
1269
1270
1271     while (*pch && NextToken (pch, &len, &pchNext))
1272     {
1273            /*
1274             * Strip off "sign" if prepended to another token, and process
1275             * that token the next time through.
1276             */
1277
1278         if (*pch == '+')
1279         {
1280             if (len != 1)
1281             {
1282                 pchNext = pch + 1;
1283             }
1284             fAddNext = TRUE;
1285         }
1286
1287         else if (*pch == '-')
1288         {
1289             if (len != 1)
1290             {
1291                 pchNext = pch + 1;
1292             }
1293             fAddNext = FALSE;
1294         }
1295
1296         if ((*pch == 'A') || (*pch == 'a'))
1297         {
1298             if (StringsAreEqual (pch, SHOW_FB_ALL_STR, len))
1299             {
1300                 cval = fAddNext ? (cval | WM_SHOW_FB_ALL) :
1301                                   (cval & ~WM_SHOW_FB_ALL);
1302                 fHit = True;
1303             }
1304         }
1305
1306         else if ((*pch == 'B') || (*pch == 'b'))
1307         {
1308             if (StringsAreEqual (pch, SHOW_FB_BEHAVIOR_STR, len))
1309             {
1310                 cval = fAddNext ? (cval | WM_SHOW_FB_BEHAVIOR) :
1311                                   (cval & ~WM_SHOW_FB_BEHAVIOR);
1312                 fHit = True;
1313             }
1314         }
1315
1316         else if ((*pch == 'K') || (*pch == 'k'))
1317         {
1318             if (StringsAreEqual (pch, SHOW_FB_KILL_STR, len))
1319             {
1320                 cval = fAddNext ? (cval | WM_SHOW_FB_KILL) :
1321                                   (cval & ~WM_SHOW_FB_KILL);
1322                 fHit = True;
1323             }
1324         }
1325
1326         else if ((*pch == 'M') || (*pch == 'm'))
1327         {
1328             if (StringsAreEqual (pch, SHOW_FB_MOVE_STR, len))
1329             {
1330                 cval = fAddNext ? (cval | WM_SHOW_FB_MOVE) :
1331                                   (cval & ~WM_SHOW_FB_MOVE);
1332                 fHit = True;
1333             }
1334         }
1335
1336         else if ((*pch == 'N') || (*pch == 'n'))
1337         {
1338             if (StringsAreEqual (pch, SHOW_FB_NONE_STR, len))
1339             {
1340                 /* don't bother adding or subtracting nothing */
1341                 fHit = True;
1342             }
1343         }
1344
1345         else if ((*pch == 'P') || (*pch == 'p'))
1346         {
1347             if (StringsAreEqual (pch, SHOW_FB_PLACEMENT_STR, len))
1348             {
1349                 cval = fAddNext ? (cval | WM_SHOW_FB_PLACEMENT) :
1350                                   (cval & ~WM_SHOW_FB_PLACEMENT);
1351                 fHit = True;
1352             }
1353         }
1354
1355         else if ((*pch == 'Q') || (*pch == 'q'))
1356         {
1357             if (StringsAreEqual (pch, SHOW_FB_QUIT_STR, len))
1358             {
1359                 cval = fAddNext ? (cval | WM_SHOW_FB_QUIT) :
1360                                   (cval & ~WM_SHOW_FB_QUIT);
1361                 fHit = True;
1362             }
1363         }
1364
1365         else if ((*pch == 'R') || (*pch == 'r'))
1366         {
1367             if (StringsAreEqual (pch, SHOW_FB_RESIZE_STR, len))
1368             {
1369                 cval = fAddNext ? (cval | WM_SHOW_FB_RESIZE) :
1370                                   (cval & ~WM_SHOW_FB_RESIZE);
1371                 fHit = True;
1372             }
1373             else if (StringsAreEqual (pch, SHOW_FB_RESTART_STR, len))
1374             {
1375                 cval = fAddNext ? (cval | WM_SHOW_FB_RESTART) :
1376                                   (cval & ~WM_SHOW_FB_RESTART);
1377                 fHit = True;
1378             }
1379         }
1380         pch = pchNext;
1381     }
1382
1383
1384
1385     /*
1386      * If we didn't match anything then set to default.
1387      */
1388     if (!fHit)
1389     {
1390         cval =  WM_SHOW_FB_DEFAULT;
1391     }
1392
1393
1394     (*toVal).size = sizeof (int);
1395     (*toVal).addr = (caddr_t) &cval;
1396
1397 } /* END OF FUNCTION WmCvtStringToShowFeedback */
1398
1399
1400 \f
1401 /*************************************<->*************************************
1402  *
1403  *  WmCvtStringToUsePPosition (args, numArgs, fromVal, toVal)
1404  *
1405  *
1406  *  Description:
1407  *  -----------
1408  *  This function converts a string to a keyboard focus policy description.
1409  *
1410  *
1411  *  Inputs:
1412  *  ------
1413  *  args = NULL (don't care)
1414  *
1415  *  numArgs = 0 (don't care)
1416  *
1417  *  fromVal = resource value to convert
1418  *
1419  *
1420  *  Outputs:
1421  *  -------
1422  *  toVal = descriptor to use to return converted value
1423  *
1424  *************************************<->***********************************/
1425
1426 void WmCvtStringToUsePPosition (XrmValue *args, Cardinal numArgs, XrmValue *fromVal, XrmValue *toVal)
1427 {
1428     unsigned char      *pch = (unsigned char *) (fromVal->addr);
1429     unsigned char      *pchNext;
1430     int        len;
1431     static int cval;
1432     Boolean    fHit = False;
1433
1434
1435 #define USE_PPOSITION_NONZERO_STR       (unsigned char *)"nonzero"
1436 #define USE_PPOSITION_ON_STR            (unsigned char *)"on"
1437 #define USE_PPOSITION_OFF_STR           (unsigned char *)"off"
1438
1439     /*
1440      * Convert the use PPosition resource value:
1441      */
1442
1443     if (*pch && NextToken (pch, &len, &pchNext))
1444     {
1445         if ((*pch == 'N') || (*pch == 'n'))
1446         {
1447             if (StringsAreEqual (pch, USE_PPOSITION_NONZERO_STR, len))
1448             {
1449                 cval = USE_PPOSITION_NONZERO;
1450                 fHit = True;
1451             }
1452         }
1453         else if (StringsAreEqual (pch, USE_PPOSITION_OFF_STR, len))
1454         {
1455             cval = USE_PPOSITION_OFF;
1456             fHit = True;
1457         }
1458         else if (StringsAreEqual (pch, USE_PPOSITION_ON_STR, len))
1459         {
1460             cval = USE_PPOSITION_ON;
1461             fHit = True;
1462         }
1463     }
1464
1465     if (!fHit)
1466     {
1467         cval =  USE_PPOSITION_NONZERO;
1468     }
1469
1470     (*toVal).size = sizeof (int);
1471     (*toVal).addr = (caddr_t)&cval;
1472
1473
1474 } /* END OF FUNCTION WmCvtStringToUsePPosition */
1475
1476 \f
1477 /*************************************<->*************************************
1478  *
1479  *  NextToken (pchIn, pLen, ppchNext)
1480  *
1481  *
1482  *  Description:
1483  *  -----------
1484  *  XXDescription ...
1485  *
1486  *
1487  *  Inputs:
1488  *  ------
1489  *  pchIn = pointer to start of next token
1490  *
1491  *
1492  *  Outputs:
1493  *  -------
1494  *  pLen  =    pointer to integer containing number of characters in next token
1495  *  ppchNext = address of pointer to following token
1496  *
1497  *  Return =   next token or NULL
1498  *
1499  *
1500  *  Comments:
1501  *  --------
1502  *  None.
1503  *
1504  *************************************<->***********************************/
1505
1506 unsigned char *NextToken (unsigned char *pchIn, int *pLen,
1507         unsigned char **ppchNext)
1508 {
1509     unsigned char *pchR = pchIn;
1510     register int   i;
1511
1512 #ifndef NO_MULTIBYTE
1513     register int   chlen;
1514
1515     for (i = 0;
1516          ((chlen = mblen((char *)pchIn, MB_CUR_MAX)) > 0) && (pchIn[0] != '\0');
1517          i++)
1518     /* find end of word: requires singlebyte whitespace terminator */
1519     {
1520         if ((chlen == 1) && isspace (*pchIn))
1521         {
1522             break;
1523         }
1524         pchIn += chlen;
1525     }
1526
1527 #else
1528     for (i = 0; *pchIn && !isspace (*pchIn); i++, pchIn++)
1529     /* find end of word */
1530     {
1531     }
1532 #endif
1533
1534     /* skip to next word */
1535     ScanWhitespace (&pchIn);
1536
1537     *ppchNext = pchIn;
1538     *pLen = i;
1539     if (i)
1540     {
1541         return(pchR);
1542     }
1543     else
1544     {
1545        return(NULL);
1546     }
1547
1548 } /* END OF FUNCTION NextToken */
1549
1550
1551 \f
1552 /*************************************<->*************************************
1553  *
1554  *  StringsAreEqual (pch1, pch2, len)
1555  *
1556  *
1557  *  Description:
1558  *  -----------
1559  *  XXDescription ...
1560  *
1561  *
1562  *  Inputs:
1563  *  ------
1564  *  pch1 =
1565  *  pch2 =
1566  *  len  =
1567  *
1568  *
1569  *  Outputs:
1570  *  -------
1571  *  Return = (Boolean) True iff strings match (case insensitive)
1572  *
1573  *
1574  *  Comments:
1575  *  --------
1576  *  None.
1577  *
1578  *************************************<->***********************************/
1579
1580 Boolean StringsAreEqual (unsigned char *pch1, unsigned char *pch2, int len)
1581 {
1582 #ifndef NO_MULTIBYTE
1583     int       chlen1;
1584     int       chlen2;
1585     wchar_t   wch1;
1586     wchar_t   wch2;
1587
1588     while (len  &&
1589            ((chlen1 = mbtowc (&wch1, (char *) pch1, MB_CUR_MAX)) > 0) &&
1590            ((chlen2 = mbtowc (&wch2, (char *) pch2, MB_CUR_MAX)) == chlen1) )
1591     {
1592         if (chlen1 == 1)
1593         /* singlebyte characters -- make case insensitive */
1594         {
1595             if ((isupper (*pch1) ? tolower(*pch1) : *pch1) !=
1596                 (isupper (*pch2) ? tolower(*pch2) : *pch2))
1597             {
1598                 break;
1599             }
1600         }
1601         else
1602         /* multibyte characters */
1603         {
1604             if (wch1 != wch2)
1605             {
1606                 break;
1607             }
1608         }
1609         pch1 += chlen1;
1610         pch2 += chlen2;
1611         len--;
1612     }
1613
1614 #else
1615     while (len  && *pch1 && *pch2 &&
1616            ((isupper (*pch1) ? tolower(*pch1++) : *pch1++) ==
1617             (isupper (*pch2) ? tolower(*pch2++) : *pch2++)))
1618     {
1619         len--;
1620     }
1621 #endif
1622
1623     return (len == 0);
1624
1625 } /* END OF StringsAreEqual */
1626
1627 \f
1628 /*************************************<->*************************************
1629  *
1630  *  long
1631  *  DecStrToL (str, ptr)
1632  *
1633  *
1634  *  Description:
1635  *  -----------
1636  *  Converts a decimal string to a long.
1637  *
1638  *
1639  *  Inputs:
1640  *  ------
1641  *  str = character string
1642  *
1643  *
1644  *  Outputs:
1645  *  -------
1646  *  *ptr = pointer to character terminating str or str
1647  *  Return = long value
1648  *
1649  *
1650  *  Comments:
1651  *  --------
1652  *  Leading whitespace is ignored.
1653  *  Returns long value with *ptr pointing at character terminating the decimal
1654  *    string.
1655  *  Returns 0 with *ptr == str if no integer can be formed.
1656  *
1657  *************************************<->***********************************/
1658
1659 long DecStrToL (unsigned char *str, unsigned char **ptr)
1660 {
1661     long  val = 0;
1662
1663     *ptr = str;
1664 #ifndef NO_MULTIBYTE
1665     while ((mblen ((char *)str, MB_CUR_MAX) == 1) && isspace (*str))
1666 #else
1667     while (isspace (*str))
1668 #endif
1669     /* Ignore leading whitespace */
1670     {
1671         str++;
1672     }
1673
1674     /* If we can start, we will reset *ptr */
1675 #ifndef NO_MULTIBYTE
1676     if ((mblen ((char *)str, MB_CUR_MAX) == 1) && isdigit (*str))
1677     {
1678         while ((mblen ((char *)str, MB_CUR_MAX) == 1) && isdigit (*str))
1679 #else
1680     if (isdigit (*str))
1681     {
1682         while (isdigit (*str))
1683 #endif
1684         {
1685             val = val * 10 + (*str - '0');
1686             str++;
1687         }
1688
1689         *ptr = str;
1690     }
1691
1692     return (val);
1693
1694 } /* END OF FUNCTION DecStrToL */
1695