auto/mk-src.in

   1 #
   2 # mk-src.in -- Input file for the Perl program to automatically
   3 #              generate interface code.
   4 #
   5 # This file is part of The New Aspell
   6 # Copyright (C) 2001-2005 by Kevin Atkinson under the GNU LGPL
   7 # license version 2.0 or 2.1.  You should have received a copy of the
   8 # LGPL license along with this library if you did not you can find it
   9 # at http://www.gnu.org/.
  10
  11 =head1 mk-src.in
  12
  13 The format of mk-src.in is as follows:
  14
  15   The following characters are literals: { } / '\ ' \n = >
  16
  17   <items>
  18   <items> := (<item>\n)+
  19   <items> := <category>:\ <name> {\n<details>\n} | <<tab>><details>
  20   <details> := <options>\n /\n <items>
  21   <options> := (<option>\n)*
  22   <option> := <key> [=> <value>]
  23
  24   <<tab>> means everything should be indented by one tab
  25
  26 See MkSrc::Info for a description of the categories and options
  27
  28 =cut
  29
  30
  31 group: type id
  32 {
  33 /
  34 union: type id
  35         treat as object
  36         /
  37         unsigned int: num
  38                 default => 0
  39         array 4 char: str
  40         cxx constructor:
  41                 /
  42                 string: str
  43 }
  44 methods: destructible
  45         /
  46         destructor
  47
  48 #       int: ref count
  49 #               default => 0
  50 #
  51 #       method: ref count
  52 #               desc => Returns a pointer to an int which may be used
  53 #                       for reference counting. It will default to 0.
  54 #                       This integer is not used by the actual library
  55 #                       but may be used my some of the front ends.
  56 #               c only
  57 #               c impl => return &ths->ref_count;
  58 #               /
  59 #               int pointer
  60
  61 methods: copyable
  62         /
  63         destructible methods
  64
  65 #       type id: type id
  66 #
  67 #       method: type id
  68 #               desc => Two objects of the same pointer type may be
  69 #                       assigned to each other only if their type ids
  70 #                       are the same.
  71 #               cxx impl => return type_id_.num
  72 #               /
  73 #               unsigned int
  74 #
  75 #       int: copyable
  76 #               default => 2
  77 #
  78 #       method: copyable
  79 #               desc => Returns 0 if this object can not be copied,
  80 #                       1 if it may be copied, 2 if it should be
  81 #                       copied.  Used by some of the front ends to
  82 #                       determine if a deep or shallow copy should be
  83 #                       made.
  84 #               cxx impl => return copyable_
  85 #               /
  86 #               int
  87
  88         method: clone
  89                 const
  90                 /
  91                 $
  92
  93         method: assign
  94                 /
  95                 void
  96                 const $: other
  97
  98 methods: can have error
  99         /
 100         cxx member: err
 101                 headers => copy ptr, error
 102                 what => CopyPtr<Error> err_
 103
 104         method: error number
 105                 const
 106                 c only
 107                 c impl => return ths->err_ == 0 ? 0 : 1;
 108                 /
 109                 unsigned int
 110
 111         method: error message
 112                 const
 113                 c only
 114                 c impl => return ths->err_ ? ths->err_->mesg : "";
 115                 /
 116                 string
 117
 118         method: error
 119                 const
 120                 c only
 121                 c impl => return ths->err_;
 122                 /
 123                 const error
 124
 125 methods: mutable container
 126         c impl headers => posib err
 127         /
 128         public: mutable container
 129         method: add
 130                 /
 131                 bool
 132                 string: to_add
 133
 134         method: remove
 135                 /
 136                 bool
 137                 string: to_rem
 138
 139         method: clear
 140                 /
 141                 void
 142
 143         method: to mutable container
 144                 c only
 145                 c impl => return ths;
 146                 /
 147                 mutable container
 148
 149 group: mutable container
 150 {
 151 /
 152 class: mutable container
 153         /
 154         mutable container methods
 155 }
 156 methods: list
 157
 158         strip => 1
 159         /
 160         method: empty
 161                 const
 162                 /
 163                 bool
 164
 165         method: size
 166                 const
 167                 /
 168                 unsigned int
 169
 170         method: elements
 171                 const
 172                 /
 173                 $ enumeration
 174
 175 methods: enumeration
 176
 177         strip => 1
 178
 179         /
 180         method: at end
 181                 const
 182                 /
 183                 bool
 184
 185         method: next
 186                 /
 187                 const $
 188
 189 group: key info
 190 {
 191 /
 192 enum: key info type
 193         prefix => key info
 194         /
 195         string
 196         int
 197         bool
 198         list
 199
 200 struct: key info
 201         desc => The Key Info object is used for holding information
 202                 about a valid key.
 203         /
 204         string: name
 205                 desc => The name of the key.
 206         key info type: type
 207                 desc => The key type.
 208         string: def
 209                 desc => The default value of the key.
 210         string: desc
 211                 desc => A brief description of the key or NULL if internal value.
 212         int: flags
 213         int: other data
 214 }
 215 group: config
 216 {
 217 no native
 218 /
 219 class: key info enumeration
 220         /
 221         enumeration methods
 222         copyable methods
 223
 224 class: config
 225         c impl headers => error
 226         /
 227         constructor
 228
 229         copyable methods
 230
 231         can have error methods
 232
 233         method: set extra
 234                 desc => Sets extra keys which this config class should
 235                         accept. begin and end are expected to point to
 236                         the beginning and ending of an array of Aspell
 237                         Key Info.
 238                 /
 239                 void
 240                 const key info: begin
 241                 const key info: end
 242
 243         method: keyinfo
 244                 posib err
 245                 desc => Returns the KeyInfo object for the
 246                         corresponding key or returns NULL and sets
 247                         error_num to PERROR_UNKNOWN_KEY if the key is
 248                         not valid. The pointer returned is valid for
 249                         the lifetime of the object.
 250                 /
 251                 const key info
 252                 string: key
 253
 254         method: possible elements
 255                 desc => Returns a newly allocated enumeration of all
 256                         the possible objects this config class uses.
 257                 /
 258                 key info enumeration
 259                 int: include extra
 260
 261         method: get default
 262                 posib err
 263                 desc => Returns the default value for given key which
 264                         may involve substituting variables, thus it is
 265                         not the same as keyinfo(key)->def returns NULL
 266                         and sets error_num to PERROR_UNKNOWN_KEY if
 267                         the key is not valid. Uses the temporary
 268                         string.
 269                 /
 270                 string obj
 271                 string: key
 272
 273         method: elements
 274                 desc => Returns a newly allocated enumeration of all
 275                         the key/value pairs. This DOES not include ones
 276                         which are set to their default values.
 277                 /
 278                 string pair enumeration
 279
 280         method: replace
 281                 posib err
 282                 desc => Inserts an item, if the item already exists it
 283                         will be replaced. Returns TRUE if it succeeded
 284                         or FALSE on error. If the key is not valid it
 285                         sets error_num to PERROR_UNKNOWN_KEY, if the
 286                         value is not valid it will set error_num to
 287                         PERROR_BAD_VALUE, if the value can not be
 288                         changed it sets error_num to
 289                         PERROR_CANT_CHANGE_VALUE, and if the value is
 290                         a list and you are trying to set its directory,
 291                         it sets error_num to PERROR_LIST_SET
 292                 /
 293                 void
 294                 string: key
 295                 string: value
 296
 297         method: remove
 298                 posib err
 299                 desc => Remove a key and returns TRUE if it exists
 300                         otherwise return FALSE. This effectively sets
 301                         the key to its default value. Calling replace
 302                         with a value of "<default>" will also call
 303                         remove. If the key does not exist then it sets
 304                         error_num to 0 or PERROR_NOT, if the key is
 305                         not valid then it sets error_num to
 306                         PERROR_UNKNOWN_KEY, if the value can not be
 307                         changed then it sets error_num to
 308                         PERROR_CANT_CHANGE_VALUE
 309                 /
 310                 void
 311                 string: key
 312
 313         method: have
 314                 const
 315                 /
 316                 bool
 317                 string: key
 318
 319         method: retrieve
 320                 posib err
 321                 desc => Returns NULL on error.
 322                 /
 323                 string obj
 324                 string: key
 325
 326         method: retrieve list
 327                 posib err
 328                 /
 329                 void
 330                 string: key
 331                 mutable container: lst
 332
 333         method: retrieve bool
 334                 posib err
 335                 desc => In "ths" Aspell configuration, search for a
 336                         character string matching "key" string.
 337                         If "key" is found then return 1 else return 0.
 338                         If error encountered, then return -1.
 339                 /
 340                 bool
 341                 string: key
 342
 343         method: retrieve int
 344                 posib err
 345                 desc => In "ths" Aspell configuration, search for an
 346                         integer value matching "key" string.
 347                         Return -1 on error.
 348                 /
 349                 unsigned int
 350                 string: key
 351
 352 #       method: read_in_settings
 353 #               posib err
 354 #               /
 355 #               bool
 356
 357 #       method: settings_read_in
 358 #               /
 359 #               bool
 360 }
 361 group: error
 362 {
 363 /
 364 struct: error
 365         /
 366         string: mesg
 367         const error info: err
 368         method: is a
 369                 const
 370                 /
 371                 bool
 372                 const error info: e
 373
 374 struct: error info
 375         /
 376         const error info: isa
 377         string: mesg
 378         unsigned int: num parms
 379         array 3 string: parms
 380 }
 381 group: can have error
 382 {
 383 /
 384 class: can have error
 385         c impl headers => error
 386         /
 387         cxx constructor:
 388                 cxx impl => : err_(e) {}
 389                 /
 390                 error: e
 391         can have error methods
 392                 prefix =>
 393         destructible methods
 394 }
 395 group: errors
 396 {
 397 /
 398 errors:
 399         /
 400         other
 401         operation not supported
 402                 mesg => Operation Not Supported: %what
 403                 parms => what
 404                 /
 405                 cant copy
 406                 unimplemented method
 407                         mesg => The method "%what" is unimplemented in "%where".
 408                         parms => where
 409         file
 410                 mesg => %file:
 411                 parms => file
 412                 /
 413                 cant open file
 414                         mesg => The file "%file" can not be opened
 415                         /
 416                         cant read file
 417                                 mesg => The file "%file" can not be opened for reading.
 418                         cant write file
 419                                 mesg => The file "%file" can not be opened for writing.
 420                 invalid name
 421                         mesg => The file name "%file" is invalid.
 422                 bad file format
 423                         mesg => The file "%file" is not in the proper format.
 424         dir
 425                 parms => dir
 426                 /
 427                 cant read dir
 428                         mesg => The directory "%dir" can not be opened for reading.
 429
 430         config
 431                 parms => key
 432                 /
 433                 unknown key
 434                         mesg => The key "%key" is unknown.
 435                 cant change value
 436                         mesg => The value for option "%key" can not be changed.
 437                 bad key
 438                         mesg => The key "%key" is not %accepted and is thus invalid.
 439                         parms => accepted
 440                 bad value
 441                         mesg => The value "%value" is not %accepted and is thus invalid for the key "%key".
 442                         parms => value, accepted
 443                 duplicate
 444                 key not string
 445                         mesg => The key "%key" is not a string.
 446                 key not int
 447                         mesg => The key "%key" is not an integer.
 448                 key not bool
 449                         mesg => The key "%key" is not a boolean.
 450                 key not list
 451                         mesg => The key "%key" is not a list.
 452                 no_value_reset
 453                         mesg => The key "%key" does not take any parameters when prefixed by a "reset-".
 454                 no_value_enable
 455                         mesg => The key "%key" does not take any parameters when prefixed by an "enable-".
 456                 no_value_disable
 457                         mesg => The key "%key" does not take any parameters when prefixed by a "dont-" or "disable-".
 458                 no_value_clear
 459                         mesg => The key "%key" does not take any parameters when prefixed by a "clear-".
 460
 461         language related
 462                 parms => lang
 463                 /
 464                 unknown language
 465                         mesg => The language "%lang" is not known.
 466                 unknown soundslike
 467                         mesg => The soundslike "%sl" is not known.
 468                         parms => sl
 469                 language not supported
 470                         mesg => The language "%lang" is not supported.
 471                 no wordlist for lang
 472                         mesg => No word lists can be found for the language "%lang".
 473                 mismatched language
 474                         mesg => Expected language "%lang" but got "%prev".
 475                         parms => prev
 476         affix
 477                 /
 478                 corrupt affix
 479                         mesg => Affix '%aff' is corrupt.
 480                         parms => aff
 481                 invalid cond
 482                         mesg => The condition "%cond" is invalid.
 483                         parms => cond
 484                 invalid cond strip
 485                         mesg => The condition "%cond" does not guarantee that "%strip" can always be stripped.
 486                         parms => cond, strip
 487                 incorrect encoding
 488                         mesg => The file "%file" is not in the proper format. Expected the file to be in "%exp" not "%got".
 489                         parms => file, exp, got
 490         encoding
 491                 parms => encod
 492                 /
 493                 unknown encoding
 494                         mesg => The encoding "%encod" is not known.
 495                 encoding not supported
 496                         mesg => The encoding "%encod" is not supported.
 497                 conversion not supported
 498                         mesg => The conversion from "%encod" to "%encod2" is not supported.
 499                         parms => encod2
 500         pipe
 501                 /
 502                 cant create pipe
 503                 process died
 504         bad input
 505                 /
 506                 invalid string
 507                         mesg => The string "%str" is invalid.
 508                         parms => str
 509                 invalid word
 510                         mesg => The word "%word" is invalid.
 511                         parms => word
 512                 invalid affix
 513                         mesg => The affix flag '%aff' is invalid for word "%word".
 514                         parms => aff, word
 515                 inapplicable affix
 516                         mesg => The affix flag '%aff' can not be applied to word "%word".
 517                         parms => aff, word
 518                 unknown unichar
 519                         mesg =>
 520                 word list flags
 521                         /
 522                         invalid flag
 523                         conflicting flags
 524         version control
 525                 /
 526                 bad version string
 527                         mesg => not a version number
 528         filter
 529                 /
 530                 cant dlopen file
 531                         mesg => dlopen returned "%return".
 532                         parms => return
 533                 empty filter
 534                         mesg => The file "%filter" does not contain any filters.
 535                         parms => filter
 536                 no such filter
 537                         mesg => The filter "%filter" does not exist.
 538                         parms => filter
 539                 confusing version
 540                         mesg => Confused by version control.
 541                 bad version
 542                         mesg => Aspell version does not match filter's requirement.
 543                 identical option
 544                         mesg => Filter option already exists.
 545                 options only
 546                         mesg => Use option modifiers only within named option.
 547                 invalid option modifier
 548                         mesg => Option modifier unknown.
 549                 cant describe filter
 550                         mesg => Error setting filter description.
 551         filter mode file
 552                 /
 553                 mode option name
 554                         mesg => Empty option specifier.
 555                 no filter to option
 556                         mesg => Option "%option" possibly specified prior to filter.
 557                         parms => option
 558                 bad mode key
 559                         mesg => Unknown mode description key "%key".
 560                         parms => key
 561                 expect mode key
 562                         mesg => Expecting "%modekey" key.
 563                         parms => modekey
 564                 mode version requirement
 565                         mesg => Version specifier missing key: "aspell".
 566                 confusing mode version
 567                         mesg => Confused by version control.
 568                 bad mode version
 569                         mesg => Aspell version does not match mode's requirement.
 570                 missing magic expression
 571                         mesg => Missing magic mode expression.
 572                 empty file ext
 573                         mesg => Empty extension at char %char.
 574                         parms => char
 575         filter mode expand
 576                 mesg => "%mode" error
 577                 parms => mode
 578                 /
 579                 unknown mode
 580                         mesg => Unknown mode: "%mode".
 581                 mode extend expand
 582                         mesg => "%mode" error while extend Aspell modes. (out of memory?)
 583         filter mode magic
 584                 mesg = "%mode": bad magic "%magic"
 585                 parms => mode, magic
 586                 /
 587                 file magic pos
 588                         mesg => "%mode": no start for magic search given for magic "%magic".
 589                 file magic range
 590                         mesg => "%mode": no range for magic search given for magic "%magic".
 591                 missing magic
 592                         mesg => "%mode": no magic expression available for magic "%magic".
 593                 bad magic
 594                         mesg => "%mode": Magic "%magic": bad regular expression after location specifier; regexp reports: "%regerr".
 595                         parms => regerr
 596
 597         expression
 598                 /
 599                 invalid expression
 600                         mesg => "%expression" is not a valid regular expression.
 601                         parms => expression
 602 }
 603 group: speller
 604 {
 605 no native
 606 /
 607 class: speller
 608         c impl headers => error
 609         /
 610         # FIXME: make a "methods" of the next two contractors
 611         #      which will probably involve modifying mk-src.pl
 612
 613         constructor: new aspell speller
 614                 returns alt type
 615                 c impl =>
 616                         PosibErr<Speller *> ret = new_speller(config);
 617                         if (ret.has_err()) \{
 618                           return new CanHaveError(ret.release_err());
 619                         \} else \{
 620                           return ret;
 621                         \}
 622                 /
 623                 can have error
 624                 config: config
 625
 626         constructor: to aspell speller
 627                 c impl => return static_cast<Speller *>(obj);
 628                 /
 629                 can have error: obj
 630
 631         destructible methods
 632
 633         can have error methods
 634
 635         method: config
 636                 /
 637                 config
 638
 639         method: check
 640
 641                 posib err
 642                 desc => Returns 0 if it is not in the dictionary,
 643                         1 if it is, or -1 on error.
 644                 /
 645                 bool
 646                 encoded string: word
 647
 648         method: add to personal
 649
 650                 posib err
 651                 desc => Add this word to your own personal word list.
 652                 /
 653                 void
 654                 encoded string: word
 655
 656         method: add to session
 657
 658                 posib err
 659                 desc => Add this word to the current spelling session.
 660                 /
 661                 void
 662                 encoded string: word
 663
 664         method: personal word list
 665
 666                 posib err
 667                 desc => This is your own personal word list file plus
 668                         any extra words added during this session to
 669                         your own personal word list.
 670                 /
 671                 const word list
 672
 673         method: session word list
 674
 675                 posib err
 676                 desc => This is a list of words added to this session
 677                         that are not in the main word list or in your
 678                         own personal list but are considered valid for
 679                         this spelling session.
 680                 /
 681                 const word list
 682
 683         method: main word list
 684
 685                 posib err
 686                 desc => This is the main list of words used during this
 687                         spelling session.
 688                 /
 689                 const word list
 690
 691         method: save all word lists
 692
 693                 posib err
 694                 /
 695                 void
 696
 697         method: clear session
 698
 699                 posib err
 700                 /
 701                 void
 702
 703         method: suggest
 704
 705                 posib err
 706                 desc => Return NULL on error.
 707                         The word list returned by suggest is only
 708                         valid until the next call to suggest.
 709                 /
 710                 const word list
 711                 encoded string: word
 712
 713         method: store replacement
 714
 715                 posib err
 716                 /
 717                 bool
 718                 encoded string: mis
 719                 encoded string: cor
 720
 721 }
 722
 723 group: filter
 724 {
 725 no native
 726 /
 727 class: filter
 728         c impl headers => error
 729         /
 730         destructible methods
 731
 732         can have error methods
 733
 734         # FIXME: make a "methods" of the next two contractors
 735
 736 #       constructor: new aspell filter
 737 #               returns alt type
 738 #               c impl =>
 739 #                       PosibErr<Filter *> ret = new_filter(config);
 740 #                       if (ret.has_err()) \{
 741 #                         return new CanHaveError(ret.release_err());
 742 #                       \} else \{
 743 #                         return ret;
 744 #                       \}
 745 #               /
 746 #               can have error
 747 #               config: config
 748
 749         constructor: to aspell filter
 750                 c impl => return static_cast<Filter *>(obj);
 751                 /
 752                 can have error: obj
 753
 754 #       method: setup
 755 #
 756 #               posib err
 757 #               /
 758 #               void
 759 #               speller: speller
 760 #               config: config
 761 #
 762 #       method: reset
 763 #
 764 #               /
 765 #               void
 766 #
 767 #       method: process
 768 #
 769 #               /
 770 #               void
 771 #               char pointer: str
 772 #               int: size
 773 #
 774 #       method: config
 775 #
 776 #               /
 777 #               config
 778 }
 779
 780 group: document checker
 781 {
 782 no native
 783 /
 784 struct: token
 785         /
 786         unsigned int: offset
 787         unsigned int: len
 788
 789 class: document checker
 790         c impl headers => error
 791         /
 792         destructible methods
 793
 794         can have error methods
 795
 796         # FIXME: make a "methods" of the next two contractors
 797
 798         constructor: new aspell document checker
 799                 returns alt type
 800                 c impl =>
 801                         PosibErr<DocumentChecker *> ret = new_document_checker(speller);
 802                         if (ret.has_err()) \{
 803                           return new CanHaveError(ret.release_err());
 804                         \} else \{
 805                           return ret;
 806                         \}
 807                 desc => Creates a new document checker.
 808                         The speller class is expected to last until
 809                         this class is destroyed.
 810                         If config is given it will be used to override
 811                         any relevent options set by this speller class.
 812                         The config class is not once this function is done.
 813                         If filter is given then it will take ownership of
 814                         the filter class and use it to do the filtering.
 815                         You are expected to free the checker when done.
 816                 /
 817                 can have error
 818                 speller: speller
 819
 820         constructor: to aspell document checker
 821                 c impl => return static_cast<DocumentChecker *>(obj);
 822                 /
 823                 can have error: obj
 824
 825         method: reset
 826
 827                 desc => Reset the internal state of the filter.
 828                         Should be called whenever a new document is
 829                         being filtered.
 830                 /
 831                 void
 832
 833         method: process
 834
 835                 desc => Process a string.
 836                         The string passed in should only be split on
 837                         white space characters.  Furthermore, between
 838                         calls to reset, each string should be passed
 839                         in exactly once and in the order they appeared
 840                         in the document.  Passing in strings out of
 841                         order, skipping strings or passing them in
 842                         more than once may lead to undefined results.
 843                 /
 844                 void
 845                 string: str
 846                 int: size
 847
 848         method: next misspelling
 849
 850                 desc => Returns the next misspelled word in the
 851                         processed string.  If there are no more
 852                         misspelled words, then token.word will be
 853                         NULL and token.size will be 0
 854                 /
 855                 token object
 856
 857         method: filter
 858
 859                 desc => Returns the underlying filter class.
 860                 /
 861                 filter
 862 }
 863
 864 group: word list
 865 {
 866 /
 867 class: word list
 868         c impl headers => string enumeration
 869         /
 870         cxx member: from internal
 871                 what => class Convert * from_internal_
 872                 default => 0
 873
 874         method: empty
 875                 const
 876                 /
 877                 bool
 878
 879         method: size
 880                 const
 881                 /
 882                 unsigned int
 883
 884         method: elements
 885                 const
 886                 c impl =>
 887                         StringEnumeration * els = ths->elements();
 888                         els->from_internal_ = ths->from_internal_;
 889                         return els;
 890                 /
 891                 string enumeration
 892 }
 893 group: string enumeration
 894 {
 895 /
 896 class: string enumeration
 897         c impl headers => convert
 898         /
 899         copyable methods
 900         method: at end
 901                 const
 902                 /
 903                 bool
 904
 905         method: next
 906                 c impl =>
 907                         const char * s = ths->next();
 908                         if (s == 0 || ths->from_internal_ == 0) \{
 909                           return s;
 910                         \} else \{
 911                           ths->temp_str.clear();
 912                           ths->from_internal_->convert(s,-1,ths->temp_str);
 913                           ths->from_internal_->append_null(ths->temp_str);
 914                           return ths->temp_str.data();
 915                         \}
 916                 /
 917                 const string
 918
 919 }
 920 group: info
 921 {
 922 /
 923 struct: module info
 924         /
 925         string: name
 926         double: order num
 927         string: lib dir
 928         string list: dict dirs
 929         string list: dict exts
 930
 931 struct: dict info
 932         /
 933         string: name
 934                 desc => The Name to identify this dictionary by.
 935         string: code
 936                 desc => The language code to identify this dictionary.
 937                         A two letter UPPER-CASE ISO 639 language code
 938                         and an optional two letter ISO 3166 country
 939                         code after a dash or underscore.
 940         string: jargon
 941                 desc => Any extra information to distinguish this
 942                         variety of dictionary from other dictionaries
 943                         which may have the same language and size.
 944         int: size
 945         string: size str
 946                 desc => A two char digit code describing the size of
 947                         the dictionary: 10=tiny, 20=really small,
 948                         30=small, 40=med-small, 50=med, 60=med-large,
 949                         70=large, 80=huge, 90=insane.  Please check
 950                         the README in aspell-lang-200?????.tar.bz2 or
 951                         see SCOWL (http://wordlist.sourceforge.net)
 952                         for an example of how these sizes are used.
 953         module info: module
 954
 955 class: module info list
 956         /
 957         constructor: get aspell module info list
 958                 /
 959                 config: config
 960
 961         list methods
 962
 963 class: dict info list
 964         /
 965         constructor: get aspell dict info list
 966                 /
 967                 config: config
 968
 969         list methods
 970
 971 class: module info enumeration
 972         /
 973         enumeration methods
 974         copyable methods
 975
 976 class: dict info enumeration
 977         /
 978         enumeration methods
 979         copyable methods
 980 }
 981
 982 group: string list
 983 {
 984 /
 985 class: string list
 986         /
 987         constructor
 988
 989         list methods
 990
 991         mutable container methods
 992
 993         copyable methods
 994 }
 995
 996 group: string map
 997 {
 998 /
 999 class: string map
1000         /
1001         constructor
1002
1003         mutable container methods
1004
1005         copyable methods
1006
1007         list methods: string pair
1008
1009         method: insert
1010                 desc => Insert a new element.
1011                         Will NOT overwrite an existing entry.
1012                         Returns FALSE if the element already exists.
1013                 /
1014                 bool
1015                 string: key
1016                 string: value
1017
1018         method: replace
1019                 desc => Insert a new element.
1020                         Will overwrite an existing entry.
1021                         Always returns TRUE.
1022                 /
1023                 bool
1024                 string: key
1025                 string: value
1026
1027         method: lookup
1028                 const
1029                 desc => Looks up an element and returns the value.
1030                         Returns NULL if the element does not exist.
1031                         Returns an empty string if the element exists
1032                         but has a NULL value.
1033                 /
1034                 string
1035                 string: key
1036 }
1037
1038 group: string pair
1039 {
1040 /
1041 struct: string pair
1042         treat as object
1043         /
1044         string: first
1045                 default => ""
1046         string: second
1047                 default => ""
1048 }
1049 group: string pair enumeration
1050 {
1051 /
1052 class: string pair enumeration
1053         /
1054         enumeration methods
1055         copyable methods
1056 }
1057 group: cache
1058 {
1059 /
1060 func: reset cache
1061         desc => Reset the global cache(s) so that cache queries will
1062                 create a new object. If existing objects are still in
1063                 use they are not deleted. If which is NULL then all
1064                 caches will be reset. Current caches are "encode",
1065                 "decode", "dictionary", "language", and "keyboard".
1066         /
1067         bool
1068         string: which
1069 }
1070