cde/programs/dtappbuilder/src/libAButil/util_convert.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 /*
  25  *      $XConsortium: util_convert.c /main/4 1995/11/06 18:53:08 rswiston $
  26  *
  27  * @(#)util_convert.c   1.25 23 Oct 1994        cde_app_builder/src/
  28  *
  29  *      RESTRICTED CONFIDENTIAL INFORMATION:
  30  *
  31  *      The information in this document is subject to special
  32  *      restrictions in a confidential disclosure agreement between
  33  *      HP, IBM, Sun, USL, SCO and Univel.  Do not distribute this
  34  *      document outside HP, IBM, Sun, USL, SCO, or Univel without
  35  *      Sun's specific written approval.  This document and all copies
  36  *      and derivative works thereof must be returned or destroyed at
  37  *      Sun's request.
  38  *
  39  *      Copyright 1993 Sun Microsystems, Inc.  All rights reserved.
  40  *
  41  */
  42
  43
  44 /*
  45  *  util_convert.c - general utilities for converting to/from AB types
  46  */
  47 #include <ctype.h>
  48 #include <stdlib.h>
  49 #include <string.h>
  50 #include <assert.h>
  51 #include <sys/param.h>
  52 #include <ab_private/util.h>
  53 #include <ab/util_types.h>
  54 #include <ab_private/istr.h>
  55
  56 #define ARRAY_SIZE(array)       (sizeof(array)/sizeof(array[0]))
  57
  58 /*************************************************************************
  59 **                                                                      **
  60 **              Type/String Conversion                                  **
  61 **                                                                      **
  62 **************************************************************************/
  63
  64 static STRING
  65 convert_int_to_string(int value,
  66         ISTRING *table, int num_values, ISTRING default_value)
  67 {
  68         if ((value < 0) || (value >= num_values))
  69         {
  70                 return istr_string(default_value);
  71         }
  72         return istr_string(table[value]);
  73 }
  74
  75 static int
  76 convert_string_to_int(STRING s_value,
  77         ISTRING *table, int num_values, int default_value)
  78 {
  79         int     i;
  80         int     int_value= default_value;
  81         ISTRING is_value= istr_create(s_value);
  82         if (s_value == NULL)
  83         {
  84                 istr_destroy(is_value);
  85                 return int_value;
  86         }
  87         for (i= 0; i < num_values; ++i)
  88         {
  89                 if (istr_equal(table[i], is_value))
  90                 {
  91                         int_value= i;
  92                         break;
  93                 }
  94         }
  95         istr_destroy(is_value);
  96         return int_value;
  97 }
  98
  99 static int
 100 convert_fill_table(ISTRING *table, int num_values, ISTRING value)
 101 {
 102         int     i;
 103         for (i= 0; i < num_values; ++i)
 104         {
 105                 table[i]= value;
 106         }
 107         return 0;
 108 }
 109
 110
 111 /*************************************************************************
 112 **                                                                      **
 113 **              AB_BUILTIN_ACTION                                       **
 114 **                                                                      **
 115 **************************************************************************/
 116
 117 static BOOL     builtin_action_table_inited= FALSE;
 118 static ISTRING  builtin_action_table[AB_BUILTIN_ACTION_NUM_VALUES]= {NULL};
 119
 120 #define check_builtin_action_table_init() \
 121         (builtin_action_table_inited? 0:builtin_action_table_init())
 122
 123 static int
 124 builtin_action_table_init()
 125 {
 126 #define bat builtin_action_table
 127         builtin_action_table_inited= TRUE;
 128         convert_fill_table(builtin_action_table,
 129                                         AB_BUILTIN_ACTION_NUM_VALUES,
 130                                         istr_const("?when?"));
 131
 132         bat[AB_STDACT_UNDEF]=            istr_const("Undef");
 133         bat[AB_STDACT_DISABLE]=          istr_const("Disable");
 134         bat[AB_STDACT_ENABLE]=           istr_const("Enable");
 135         bat[AB_STDACT_HIDE]=             istr_const("Hide");
 136         bat[AB_STDACT_SET_LABEL]=        istr_const("SetLabel");
 137         bat[AB_STDACT_SET_TEXT]=         istr_const("SetText");
 138         bat[AB_STDACT_SET_VALUE]=        istr_const("SetValue");
 139         bat[AB_STDACT_SHOW]=             istr_const("Show");
 140
 141         return 0;
 142 #undef bat
 143 }
 144
 145
 146 AB_BUILTIN_ACTION
 147 util_string_to_builtin_action(STRING action)
 148 {
 149         return (AB_BUILTIN_ACTION)convert_string_to_int(action,
 150                         builtin_action_table, AB_BUILTIN_ACTION_NUM_VALUES,
 151                         AB_STDACT_UNDEF);
 152 }
 153
 154
 155 STRING
 156 util_builtin_action_to_string(AB_BUILTIN_ACTION action)
 157 {
 158         check_builtin_action_table_init();
 159         return convert_int_to_string(action,
 160                 builtin_action_table, AB_BUILTIN_ACTION_NUM_VALUES,
 161                 istr_const("?action?"));
 162 }
 163
 164 /*************************************************************************
 165 **                                                                      **
 166 **              AB_OBJECT_TYPE                                          **
 167 **                                                                      **
 168 **************************************************************************/
 169 /*
 170  * REMIND: move type conversion stuff to guide
 171  */
 172 static BOOL     obj_type_table_inited= FALSE;
 173 static ISTRING obj_type_table[AB_OBJECT_TYPE_NUM_VALUES+1]= {NULL};
 174
 175 #define check_obj_type_table_init() \
 176         (obj_type_table_inited? 0:obj_type_table_init())
 177
 178 static int
 179 obj_type_table_init()
 180 {
 181 #define ott obj_type_table
 182     obj_type_table_inited= TRUE;
 183     convert_fill_table(obj_type_table,
 184         AB_OBJECT_TYPE_NUM_VALUES, istr_const("?type?"));
 185
 186     ott[AB_TYPE_ACTION]=        istr_const(":action");
 187     ott[AB_TYPE_ACTION_LIST]=   istr_const(":action-list");
 188     ott[AB_TYPE_BASE_WINDOW]=   istr_const(":base-window");
 189     ott[AB_TYPE_BUTTON]=        istr_const(":button");
 190     ott[AB_TYPE_CHOICE]=        istr_const(":choice");
 191     ott[AB_TYPE_COMBO_BOX]=     istr_const(":combobox");
 192     ott[AB_TYPE_FILE_CHOOSER]=  istr_const(":file-chooser");
 193     ott[AB_TYPE_MESSAGE]=       istr_const(":message");
 194     ott[AB_TYPE_CONTAINER]=     istr_const(":container");
 195     ott[AB_TYPE_DIALOG]=        istr_const(":dialog");
 196     ott[AB_TYPE_DRAWING_AREA]=  istr_const(":drawing-area");
 197     ott[AB_TYPE_FILE]=          istr_const(":file");
 198     ott[AB_TYPE_MODULE]=        istr_const(":module");
 199     ott[AB_TYPE_ITEM]=          istr_const(":item");
 200     ott[AB_TYPE_LABEL]=         istr_const(":label");
 201     ott[AB_TYPE_LAYERS]=        istr_const(":layers");
 202     ott[AB_TYPE_LIST]=          istr_const(":list");
 203     ott[AB_TYPE_MENU]=          istr_const(":menu");
 204     ott[AB_TYPE_PROJECT]=       istr_const(":project");
 205     ott[AB_TYPE_SEPARATOR]=     istr_const(":separator");
 206     ott[AB_TYPE_SPIN_BOX]=      istr_const(":spinbox");
 207     ott[AB_TYPE_SCALE]=         istr_const(":scale");
 208     ott[AB_TYPE_TERM_PANE]=     istr_const(":term-pane");
 209     ott[AB_TYPE_TEXT_FIELD]=    istr_const(":text-field");
 210     ott[AB_TYPE_TEXT_PANE]=     istr_const(":text-pane");
 211     ott[AB_TYPE_UNKNOWN]=       istr_const(":unknown-type");
 212
 213     return 0;
 214 #undef ott
 215 }
 216
 217 AB_OBJECT_TYPE
 218 util_string_to_object_type(STRING string_type)
 219 {
 220         check_obj_type_table_init();
 221         return (AB_OBJECT_TYPE)convert_string_to_int(
 222                 string_type,
 223                 obj_type_table, AB_OBJECT_TYPE_NUM_VALUES, AB_TYPE_UNKNOWN);
 224 }
 225
 226
 227 STRING
 228 util_object_type_to_string(AB_OBJECT_TYPE type)
 229 {
 230         check_obj_type_table_init();
 231         return convert_int_to_string(type,
 232                 obj_type_table, AB_OBJECT_TYPE_NUM_VALUES,
 233                 istr_const("?type?"));
 234 }
 235
 236 /*****************************************************************
 237 **                                                              **
 238 **              AB_OBJECT_TYPE - for browser                    **
 239 **                                                              **
 240 ******************************************************************/
 241 /*
 242  * REMIND: move type conversion stuff to guide
 243  */
 244 static BOOL     browser_obj_type_table_inited= FALSE;
 245 static ISTRING browser_obj_type_table[AB_OBJECT_TYPE_NUM_VALUES+1]= {NULL};
 246
 247 #define check_browser_obj_type_table_init() \
 248         (browser_obj_type_table_inited? 0:browser_obj_type_table_init())
 249
 250 static int
 251 browser_obj_type_table_init()
 252 {
 253 #define bott browser_obj_type_table
 254     browser_obj_type_table_inited= TRUE;
 255     convert_fill_table(browser_obj_type_table,
 256         AB_OBJECT_TYPE_NUM_VALUES, istr_const("?type?"));
 257
 258     bott[AB_TYPE_ACTION]=       istr_const("ACTION");
 259     bott[AB_TYPE_ACTION_LIST]=  istr_const("ACTION-LIST");
 260     bott[AB_TYPE_BASE_WINDOW]=  istr_const("BASE-WINDOW");
 261     bott[AB_TYPE_BUTTON]=       istr_const("BUTTON");
 262     bott[AB_TYPE_CHOICE]=       istr_const("CHOICE");
 263     bott[AB_TYPE_COMBO_BOX]=    istr_const("COMBO-BOX");
 264     bott[AB_TYPE_FILE_CHOOSER]= istr_const("file-chooser");
 265     bott[AB_TYPE_MESSAGE]=      istr_const("message");
 266     bott[AB_TYPE_CONTAINER]=    istr_const("CONTAINER");
 267     bott[AB_TYPE_DIALOG]=       istr_const("DIALOG");
 268     bott[AB_TYPE_DRAWING_AREA]= istr_const("DRAWING-AREA");
 269     bott[AB_TYPE_MODULE]=       istr_const("MODULE");
 270     bott[AB_TYPE_ITEM]=         istr_const("ITEM");
 271     bott[AB_TYPE_LABEL]=        istr_const("LABEL");
 272     bott[AB_TYPE_LAYERS]=       istr_const("LAYERS");
 273     bott[AB_TYPE_LIST]=         istr_const("LIST");
 274     bott[AB_TYPE_MENU]=         istr_const("MENU");
 275     bott[AB_TYPE_PROJECT]=      istr_const("PROJECT");
 276     bott[AB_TYPE_SEPARATOR]=    istr_const("SEPARATOR");
 277     bott[AB_TYPE_SPIN_BOX]=     istr_const("SPIN-BOX");
 278     bott[AB_TYPE_SCALE]=        istr_const("SCALE");
 279     bott[AB_TYPE_TERM_PANE]=    istr_const("TERM-PANE");
 280     bott[AB_TYPE_TEXT_FIELD]=   istr_const("TEXT-FIELD");
 281     bott[AB_TYPE_TEXT_PANE]=    istr_const("TEXT-PANE");
 282     bott[AB_TYPE_UNKNOWN]=      istr_const("UNKNOWN-TYPE");
 283
 284     return 0;
 285 #undef bott
 286 }
 287
 288 AB_OBJECT_TYPE
 289 util_browser_string_to_object_type(STRING string_type)
 290 {
 291         check_browser_obj_type_table_init();
 292         return (AB_OBJECT_TYPE)convert_string_to_int(
 293                 string_type,
 294                 browser_obj_type_table, AB_OBJECT_TYPE_NUM_VALUES, AB_TYPE_UNKNOWN);
 295 }
 296
 297
 298 STRING
 299 util_object_type_to_browser_string(AB_OBJECT_TYPE type)
 300 {
 301         check_browser_obj_type_table_init();
 302         return convert_int_to_string(type,
 303                 browser_obj_type_table, AB_OBJECT_TYPE_NUM_VALUES,
 304                 istr_const("?type?"));
 305 }
 306
 307 /*************************************************************************
 308 **                                                                      **
 309 **              AB_WHEN                                                 **
 310 **                                                                      **
 311 **************************************************************************/
 312 /*
 313  * REMIND: move when stuff to libguide
 314  */
 315 static ISTRING  when_table[AB_WHEN_NUM_VALUES];
 316 static BOOL     when_table_inited= FALSE;
 317
 318 static int
 319 when_table_init()
 320 {
 321 #define wt when_table
 322         int     i= 0;
 323
 324         when_table_inited= TRUE;
 325         convert_fill_table(when_table, AB_WHEN_NUM_VALUES,
 326                         istr_const("?when?"));
 327
 328         wt[AB_WHEN_ACTION1]=            istr_const("Action1Activated");
 329         wt[AB_WHEN_ACTION2]=            istr_const("Action2Activated");
 330         wt[AB_WHEN_ACTION3]=            istr_const("Action3Activated");
 331         wt[AB_WHEN_ACTIVATED]=          istr_const("Activate");
 332         wt[AB_WHEN_AFTER_CREATED]=      istr_const("AfterCreate");
 333         wt[AB_WHEN_AFTER_RESIZED]=      istr_const("AfterResize");
 334         wt[AB_WHEN_BEFORE_POST_MENU]=   istr_const("BeforePostMenu");
 335         wt[AB_WHEN_BEFORE_TEXT_CHANGED]=istr_const("BeforeTextChanged");
 336         wt[AB_WHEN_CANCEL]=             istr_const("CancelActivated");
 337         wt[AB_WHEN_DESTROYED]=          istr_const("Destroy");
 338         wt[AB_WHEN_DRAGGED]=            istr_const("Dragged");
 339         wt[AB_WHEN_DRAGGED_FROM]=       istr_const("DraggedFrom");
 340         wt[AB_WHEN_DOUBLE_CLICKED_ON]=  istr_const("DoubleClick");
 341         wt[AB_WHEN_DROPPED_ON]=         istr_const("DroppedOn");
 342         wt[AB_WHEN_HIDDEN]=             istr_const("Hidden");
 343         wt[AB_WHEN_ITEM_SELECTED]=      istr_const("ItemSelected");
 344         wt[AB_WHEN_OK]=                 istr_const("OkActivated");
 345         wt[AB_WHEN_REPAINT_NEEDED]=     istr_const("NeedRepaint");
 346         wt[AB_WHEN_POPPED_DOWN]=        istr_const("Popdown");
 347         wt[AB_WHEN_POPPED_UP]=          istr_const("Popup");
 348         wt[AB_WHEN_SESSION_RESTORE]=    istr_const("SessionRestore");
 349         wt[AB_WHEN_SESSION_SAVE]=       istr_const("SessionSave");
 350         wt[AB_WHEN_SHOWN]=              istr_const("Shown");
 351         wt[AB_WHEN_TEXT_CHANGED]=       istr_const("TextChanged");
 352         wt[AB_WHEN_TOOLTALK_DO_COMMAND]=istr_const("ToolTalkDoCommand");
 353         wt[AB_WHEN_TOOLTALK_GET_STATUS]=istr_const("ToolTalkGetStatus");
 354         wt[AB_WHEN_TOOLTALK_PAUSE_RESUME]=istr_const("ToolTalkPauseResume");
 355         wt[AB_WHEN_TOOLTALK_QUIT]=istr_const("ToolTalkQuit");
 356         wt[AB_WHEN_VALUE_CHANGED]=istr_const("ValueChanged");
 357         wt[AB_WHEN_UNDEF]=              istr_const("Undef");
 358
 359         return 0;
 360 #undef wt
 361 }
 362
 363 #define check_when_table_init() \
 364                 if (!when_table_inited) {when_table_init();}
 365
 366
 367 AB_WHEN
 368 util_string_to_when(STRING when_string)
 369 {
 370         check_when_table_init();
 371         return (AB_WHEN)convert_string_to_int(
 372                 when_string,
 373                 when_table, AB_WHEN_NUM_VALUES, AB_WHEN_UNDEF);
 374 }
 375
 376
 377 STRING
 378 util_when_to_string(AB_WHEN when)
 379 {
 380         check_when_table_init();
 381         return convert_int_to_string(when,
 382                 when_table, AB_WHEN_NUM_VALUES, istr_const("?when?"));
 383 }
 384
 385 /******************* AB_ALIGNMENT **************************************/
 386
 387 static ISTRING  align_tab[AB_ALIGNMENT_NUM_VALUES];
 388 static BOOL     align_tab_inited= FALSE;
 389 #define align_tab_check_init() (align_tab_inited? 0:align_tab_init())
 390
 391 static int
 392 align_tab_init()
 393 {
 394 #define at align_tab
 395     align_tab_inited= TRUE;
 396     convert_fill_table(at, ARRAY_SIZE(at), istr_const(NULL));
 397
 398     at[AB_ALIGN_TOP]=           istr_const(":top");
 399     at[AB_ALIGN_LEFT]=          istr_const(":left");
 400     at[AB_ALIGN_RIGHT]=         istr_const(":right");
 401     at[AB_ALIGN_BOTTOM]=        istr_const(":bottom");
 402     at[AB_ALIGN_CENTER]=        istr_const(":centers");
 403     at[AB_ALIGN_LABELS]=        istr_const(":labels");
 404
 405     return 0;
 406 #undef at
 407 }
 408
 409 AB_ALIGNMENT
 410 util_string_to_alignment(STRING align_string)
 411 {
 412     align_tab_check_init();
 413     return (AB_ALIGNMENT)convert_string_to_int(align_string,
 414                 align_tab, ARRAY_SIZE(align_tab), -1);
 415 }
 416
 417 STRING
 418 util_alignment_to_string(AB_ALIGNMENT align)
 419 {
 420     align_tab_check_init();
 421     return convert_int_to_string(align,
 422                 align_tab, ARRAY_SIZE(align_tab), istr_const(NULL));
 423 }
 424
 425 /******************* AB_LABEL_TYPE **************************************/
 426 static ISTRING  label_type_tab[AB_LABEL_TYPE_NUM_VALUES];
 427 static BOOL     label_type_tab_inited= FALSE;
 428 #define label_type_tab_check_init() \
 429                 (label_type_tab_inited? 0:label_type_tab_init())
 430
 431 static int
 432 label_type_tab_init()
 433 {
 434 #define ltt label_type_tab
 435         label_type_tab_inited= TRUE;
 436
 437         ltt[AB_LABEL_ARROW_DOWN]= istr_const(":arrow-down");
 438         ltt[AB_LABEL_ARROW_LEFT]= istr_const(":arrow-left");
 439         ltt[AB_LABEL_ARROW_RIGHT]= istr_const(":arrow-right");
 440         ltt[AB_LABEL_ARROW_UP]= istr_const(":arrow_up");
 441         ltt[AB_LABEL_DRAWN]= istr_const(":drawn");
 442         ltt[AB_LABEL_GLYPH]= istr_const(":glyph");
 443         ltt[AB_LABEL_STRING]= istr_const(":string");
 444
 445         return 0;
 446 #undef ltt
 447 }
 448
 449 AB_LABEL_TYPE
 450 util_string_to_label_type(STRING type_string)
 451 {
 452         label_type_tab_check_init();
 453         return (AB_LABEL_TYPE)convert_string_to_int(type_string,
 454                 label_type_tab, ARRAY_SIZE(label_type_tab), -1);
 455 }
 456
 457 STRING
 458 util_label_type_to_string(AB_LABEL_TYPE label_type)
 459 {
 460     label_type_tab_check_init();
 461     return convert_int_to_string(label_type,
 462                 label_type_tab, ARRAY_SIZE(label_type_tab), NULL);
 463 }
 464
 465 /******************* AB_BUTTON_TYPE **************************************/
 466 static ISTRING  button_type_tab[AB_BUTTON_TYPE_NUM_VALUES];
 467 static BOOL     button_type_tab_inited= FALSE;
 468 #define button_type_tab_check_init() \
 469                 (button_type_tab_inited? 0:button_type_tab_init())
 470
 471 static int
 472 button_type_tab_init()
 473 {
 474 #define btt button_type_tab
 475     button_type_tab_inited= TRUE;
 476
 477     btt[AB_BUT_PUSH]= istr_const(":normal");
 478
 479     return 0;
 480 #undef btt
 481 }
 482
 483 AB_BUTTON_TYPE
 484 util_string_to_button_type(STRING type_string)
 485 {
 486     button_type_tab_check_init();
 487     return (AB_BUTTON_TYPE)convert_string_to_int(type_string,
 488                 button_type_tab, ARRAY_SIZE(button_type_tab), -1);
 489 }
 490
 491 STRING
 492 util_button_type_to_string(AB_BUTTON_TYPE type)
 493 {
 494     button_type_tab_check_init();
 495     return convert_int_to_string(type,
 496                 button_type_tab, ARRAY_SIZE(button_type_tab), NULL);
 497 }
 498
 499
 500 /******************* AB_ARG_CLASS **************************************/
 501 static ISTRING  arg_class_tab[AB_ARG_CLASS_NUM_VALUES];
 502 static BOOL     arg_class_tab_inited= FALSE;
 503 #define arg_class_tab_check_init() \
 504                 (arg_class_tab_inited? 0:arg_class_tab_init())
 505
 506 static int
 507 arg_class_tab_init()
 508 {
 509 #define att arg_class_tab
 510     arg_class_tab_inited= TRUE;
 511
 512     att[AB_ARG_CLASS_UNDEF]=            istr_const(":undef");
 513     att[AB_ARG_CLASS_ACCELERATOR]=      istr_const(":attachment");
 514     att[AB_ARG_CLASS_COLOR]=            istr_const(":color");
 515     att[AB_ARG_CLASS_GEOMETRY]=         istr_const(":geometry");
 516     att[AB_ARG_CLASS_GLYPH]=            istr_const(":value");
 517     att[AB_ARG_CLASS_NON_GLYPH_LABEL]=  istr_const(":label-alignment");
 518     att[AB_ARG_CLASS_OTHER_STRING]=     istr_const(":label-glyph");
 519     att[AB_ARG_CLASS_OTHER]=            istr_const(":other");
 520     att[AB_ARG_CLASS_OTHER]=            istr_const(":other");
 521
 522     return 0;
 523 #undef att
 524 }
 525
 526 AB_ARG_CLASS
 527 util_string_to_arg_class(STRING arg_class_string)
 528 {
 529     arg_class_tab_check_init();
 530     return (AB_ARG_CLASS)convert_string_to_int(arg_class_string,
 531                 arg_class_tab, ARRAY_SIZE(arg_class_tab), -1);
 532 }
 533
 534 STRING
 535 util_arg_class_to_string(AB_ARG_CLASS arg_class)
 536 {
 537     arg_class_tab_check_init();
 538     return convert_int_to_string(arg_class,
 539                 arg_class_tab, ARRAY_SIZE(arg_class_tab), NULL);
 540 }
 541
 542
 543 AB_ARG_CLASS_FLAGS
 544 util_arg_class_to_flag(AB_ARG_CLASS arg_class)
 545 {
 546     AB_ARG_CLASS_FLAGS  class_flag = AB_ARG_CLASS_FLAGS_NONE;
 547
 548     if ((arg_class < 1) || (arg_class > AB_ARG_CLASS_NUM_VALUES))
 549     {
 550         return (AB_ARG_CLASS_FLAGS)0;
 551     }
 552     class_flag = (AB_ARG_CLASS_FLAGS)(0x01<<(((unsigned)arg_class)-1));
 553
 554     assert(arg_class == util_flag_to_arg_class(class_flag));
 555     return class_flag;
 556 }
 557
 558
 559 AB_ARG_CLASS
 560 util_flag_to_arg_class(AB_ARG_CLASS_FLAGS arg_class_flag)
 561 {
 562     int                 i = 0;
 563     AB_ARG_CLASS        arg_class = AB_ARG_CLASS_UNDEF;
 564
 565     for (i = 1; i < AB_ARG_CLASS_NUM_VALUES; ++i)
 566     {
 567         if ((arg_class_flag & 0x01) != 0)
 568         {
 569             break;
 570         }
 571         arg_class_flag >>= 1;
 572     }
 573     if (i < AB_ARG_CLASS_NUM_VALUES)
 574     {
 575         arg_class = (AB_ARG_CLASS)i;
 576     }
 577
 578     return arg_class;
 579 }
 580
 581
 582 /******************* AB_ARG_TYPE **************************************/
 583 static ISTRING  arg_type_tab[AB_ARG_TYPE_NUM_VALUES];
 584 static BOOL     arg_type_tab_inited= FALSE;
 585 #define arg_type_tab_check_init() (arg_type_tab_inited? 0:arg_type_tab_init())
 586
 587 static int
 588 arg_type_tab_init()
 589 {
 590 #define att arg_type_tab
 591     arg_type_tab_inited= TRUE;
 592
 593     att[AB_ARG_BOOLEAN]=        istr_const(":boolean");
 594     att[AB_ARG_CALLBACK]=       istr_const(":callback");
 595     att[AB_ARG_FLOAT]=          istr_const(":float");
 596     att[AB_ARG_INT]=            istr_const(":integer");
 597     att[AB_ARG_LITERAL]=        istr_const(":literal");
 598     att[AB_ARG_STRING]=         istr_const(":string");
 599     att[AB_ARG_VOID_PTR]=       istr_const(":void");
 600
 601     return 0;
 602 #undef att
 603 }
 604
 605 AB_ARG_TYPE
 606 util_string_to_arg_type(STRING arg_type_string)
 607 {
 608     arg_type_tab_check_init();
 609     return (AB_ARG_TYPE)convert_string_to_int(arg_type_string,
 610                 arg_type_tab, ARRAY_SIZE(arg_type_tab), -1);
 611 }
 612
 613 STRING
 614 util_arg_type_to_string(AB_ARG_TYPE arg_type)
 615 {
 616     arg_type_tab_check_init();
 617     return convert_int_to_string(arg_type,
 618                 arg_type_tab, ARRAY_SIZE(arg_type_tab), NULL);
 619 }
 620
 621 /******************* AB_TEXT_TYPE **************************************/
 622 AB_TEXT_TYPE
 623 util_string_to_text_type(STRING s_text_type)
 624 {
 625         return AB_TEXT_ALPHANUMERIC;
 626 }
 627
 628 STRING
 629 util_text_type_to_string(AB_TEXT_TYPE tt)
 630 {
 631         return "text-type-not-implemented";
 632 }
 633
 634 /******************* AB_CHOICE_TYPE **************************************/
 635 AB_CHOICE_TYPE
 636 util_string_to_choice_type(STRING s_choice_type)
 637 {
 638         return AB_CHOICE_EXCLUSIVE;
 639 }
 640
 641 STRING
 642 util_choice_type_to_string(AB_CHOICE_TYPE choice_type)
 643 {
 644         return ":choice-type-not-implemented";
 645 }
 646
 647 /******************* AB_ORIENTATION **************************************/
 648 AB_ORIENTATION
 649 util_string_to_orientation(STRING s_orient)
 650 {
 651         return AB_ORIENT_HORIZONTAL;
 652 }
 653
 654 STRING
 655 util_orientation_to_string(AB_ORIENTATION orient)
 656 {
 657         return "orientation-not-implemented";
 658 }
 659
 660 /******************* AB_MENU_TYPE **************************************/
 661 AB_MENU_TYPE
 662 util_string_to_menu_type(STRING s_menu_type)
 663 {
 664         return AB_MENU_PULLDOWN;
 665 }
 666
 667 STRING
 668 util_menu_type_to_string(AB_MENU_TYPE type)
 669 {
 670         return "menu-type-not-implemented";
 671 }
 672
 673 /******************* AB_GROUP_TYPE **************************************/
 674 AB_GROUP_TYPE
 675 util_string_to_group_type(STRING s_group)
 676 {
 677         return AB_GROUP_IGNORE;
 678 }
 679
 680 STRING
 681 util_group_type_to_string(AB_GROUP_TYPE group)
 682 {
 683         return "group-type-not-implemented";
 684 }
 685
 686 /******************* AB_OBJECT_STATE **************************************/
 687 AB_OBJECT_STATE
 688 util_string_to_object_state(STRING s_state)
 689 {
 690         return AB_STATE_ACTIVE;
 691 }
 692
 693 STRING
 694 util_object_state_to_string(AB_OBJECT_STATE state)
 695 {
 696         return "object-state-not-implemented";
 697 }
 698
 699 /******************* AB_CONTAINER_TYPE **************************************/
 700
 701 static ISTRING  container_tab[AB_CONTAINER_TYPE_NUM_VALUES];
 702 static BOOL     container_tab_inited= FALSE;
 703 #define container_tab_check_init() (container_tab_inited? 0:container_tab_init())
 704
 705 static int
 706 container_tab_init()
 707 {
 708 #define cont container_tab
 709     container_tab_inited= TRUE;
 710     convert_fill_table(cont, ARRAY_SIZE(cont), istr_const(NULL));
 711
 712     cont[AB_CONT_ABSOLUTE]= istr_const(":absolute");
 713     cont[AB_CONT_GROUP]= istr_const(":group");
 714     cont[AB_CONT_MAIN_WINDOW]= istr_const(":main_window");
 715     cont[AB_CONT_MENU_BAR]= istr_const(":menu_bar");
 716     cont[AB_CONT_PANED]= istr_const(":paned");
 717     cont[AB_CONT_RELATIVE]= istr_const(":relative");
 718     cont[AB_CONT_SCROLLED_WINDOW]= istr_const(":scrolled_window");
 719     cont[AB_CONT_ROW_COLUMN]= istr_const(":row_column");
 720     return 0;
 721 #undef cont
 722 }
 723
 724 AB_CONTAINER_TYPE
 725 util_string_to_container_type(STRING container_string)
 726 {
 727     container_tab_check_init();
 728     return
 729 (AB_CONTAINER_TYPE)convert_string_to_int(container_string,
 730                 container_tab, ARRAY_SIZE(container_tab),
 731 -1);
 732 }
 733
 734 STRING
 735 util_container_type_to_string(AB_CONTAINER_TYPE type)
 736 {
 737     container_tab_check_init();
 738     return convert_int_to_string(type,
 739                 container_tab, ARRAY_SIZE(container_tab), istr_const(NULL));
 740 }
 741
 742
 743 /******************* AB_ITEM_TYPE **************************************/
 744
 745 static ISTRING  item_tab[AB_ITEM_TYPE_NUM_VALUES];
 746 static BOOL     item_tab_inited= FALSE;
 747 #define item_tab_check_init() (item_tab_inited? 0:item_tab_init())
 748
 749 static int
 750 item_tab_init()
 751 {
 752 #define it item_tab
 753     item_tab_inited= TRUE;
 754     convert_fill_table(it, ARRAY_SIZE(it), istr_const(NULL));
 755
 756     it[AB_ITEM_FOR_CHOICE]= istr_const(":choice_item");
 757     it[AB_ITEM_FOR_LIST]= istr_const(":list_item");
 758     it[AB_ITEM_FOR_MENU]= istr_const(":menu_item");
 759     return 0;
 760 #undef it
 761 }
 762
 763 AB_ITEM_TYPE
 764 util_string_to_item_type(STRING item_string)
 765 {
 766     item_tab_check_init();
 767     return
 768 (AB_ITEM_TYPE)convert_string_to_int(item_string,
 769                 item_tab, ARRAY_SIZE(item_tab), -1);
 770 }
 771
 772 STRING
 773 util_item_type_to_string(AB_ITEM_TYPE type)
 774 {
 775     item_tab_check_init();
 776     return convert_int_to_string(type,
 777                 item_tab, ARRAY_SIZE(item_tab), istr_const(NULL));
 778 }
 779
 780 /******************* AB_LABEL_ALIGN_TYPE **************************************/
 781
 782 /*
 783 static ISTRING  lalign_tab[AB_LABEL_ALIGN_TYPE_NUM_VALUES];
 784 static BOOL     lalign_tab_inited= FALSE;
 785 #define lalign_tab_check_init() (lalign_tab_inited? 0:lalign_tab_init())
 786
 787 static int
 788 lalign_tab_init()
 789 {
 790 #define lat lalign_tab
 791     lalign_tab_inited= TRUE;
 792     convert_fill_table(lat, ARRAY_SIZE(lat), istr_const(NULL));
 793
 794     lat[AB_LABEL_ALIGN_RIGHT]= istr_const(":right");
 795     lat[AB_LABEL_ALIGN_CENTER]= istr_const(":center");
 796     lat[AB_LABEL_ALIGN_LEFT]= istr_const(":left");
 797     return 0;
 798 #undef lat
 799 }
 800
 801 AB_LABEL_ALIGN_TYPE
 802 ab_string_to_label_align_type(STRING lalign_string)
 803 {
 804     lalign_tab_check_init();
 805     return
 806 (AB_LABEL_ALIGN_TYPE)convert_string_to_int(lalign_string,
 807                 lalign_tab, ARRAY_SIZE(lalign_tab), -1);
 808 }
 809
 810 STRING
 811 ab_label_align_type_to_string(AB_LABEL_ALIGN_TYPE type)
 812 {
 813     lalign_tab_check_init();
 814     return convert_int_to_string(type,
 815                 lalign_tab, ARRAY_SIZE(lalign_tab), istr_const(NULL));
 816 }
 817 */
 818
 819
 820 STRING
 821 util_cvt_bool_to_string(BOOL bool_value, STRING buf, int buf_size)
 822 {
 823     if (buf_size < 1)
 824     {
 825         goto epilogue;
 826     }
 827
 828     if (bool_value)
 829     {
 830         strncpy(buf, "True", buf_size);
 831     }
 832     else
 833     {
 834         strncpy(buf, "False", buf_size);
 835     }
 836     buf[buf_size-1]= 0;
 837
 838 epilogue:
 839     return buf;
 840 }
 841
 842
 843 /*
 844  * returns identifier-legal string that can be used for file names,
 845  * et cetera.
 846  */
 847 STRING
 848 util_os_type_to_ident(AB_OS_TYPE osType)
 849 {
 850     STRING      typeString = NULL;
 851
 852     switch (osType)
 853     {
 854         case AB_OS_AIX: typeString = "aix"; break;
 855         case AB_OS_HPUX: typeString = "hpux"; break;
 856         case AB_OS_SUNOS: typeString = "sunos"; break;
 857         case AB_OS_UXP: typeString = "uxp"; break;
 858         case AB_OS_OSF1: typeString = "osf1"; break;
 859
 860 #ifdef USL
 861         /*
 862          * The USL specific changes were made ifdef USL due to time constraint
 863          * They should be removed in the next release
 864          */
 865         case AB_OS_UNIXWARE: typeString = "unixware"; break;
 866 #endif
 867     }
 868
 869     return typeString;
 870 }
 871
 872
 873 /*
 874  * Returns a nicely formatted OS name (even on not-so-nice OSes!)
 875  */
 876 STRING
 877 util_os_type_to_string(AB_OS_TYPE osType)
 878 {
 879     STRING      nameString = NULL;
 880
 881     switch (osType)
 882     {
 883         case AB_OS_AIX: nameString = "AIX"; break;
 884         case AB_OS_HPUX: nameString = "HP-UX"; break;
 885         case AB_OS_SUNOS: nameString = "SunOS"; break;
 886         case AB_OS_UXP: nameString = "UXP"; break;
 887         case AB_OS_OSF1: nameString = "OSF/1"; break;
 888     }
 889
 890     return nameString;
 891 }
 892