libanjuta/anjuta-plugin-description.c

   1 /*
   2  * AnjutaPluginDescription - Plugin meta data
   3  * anjuta-plugin-description.c Copyright (C) 2002 Red Hat, Inc.
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the
  17  * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  18  * Boston, MA 02110-1301, USA.
  19  */
  20
  21 /**
  22  * SECTION:anjuta-plugin-description
  23  * @title: AnjutaPluginDescription
  24  * @short_description: Plugin description from .plugin file
  25  * @see_also: #AnjutaPlugin, #AnjutaPluginHandle
  26  * @stability: Unstable
  27  * @include: libanjuta/anjuta-plugin-description.h
  28  *
  29  */
  30
  31 #include <string.h>
  32 #include <locale.h>
  33 #include <stdlib.h>
  34
  35 #include <libanjuta/anjuta-plugin-description.h>
  36
  37 typedef struct _AnjutaPluginDescriptionSection AnjutaPluginDescriptionSection;
  38 typedef struct _AnjutaPluginDescriptionLine AnjutaPluginDescriptionLine;
  39 typedef struct _AnjutaPluginDescriptionParser AnjutaPluginDescriptionParser;
  40
  41 struct _AnjutaPluginDescriptionSection {
  42   GQuark section_name; /* 0 means just a comment block (before any section) */
  43   gint n_lines;
  44   AnjutaPluginDescriptionLine *lines;
  45 };
  46
  47 struct _AnjutaPluginDescriptionLine {
  48   GQuark key; /* 0 means comment or blank line in value */
  49   char *locale;
  50   gchar *value;
  51 };
  52
  53 struct _AnjutaPluginDescription {
  54   gint n_sections;
  55   AnjutaPluginDescriptionSection *sections;
  56   char *current_locale[2];
  57 };
  58
  59 struct _AnjutaPluginDescriptionParser {
  60   AnjutaPluginDescription *df;
  61   gint current_section;
  62   gint n_allocated_lines;
  63   gint n_allocated_sections;
  64   gint line_nr;
  65   char *line;
  66 };
  67
  68 #define VALID_KEY_CHAR 1
  69 #define VALID_LOCALE_CHAR 2
  70 guchar valid[256] = {
  71    0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 ,
  72    0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 ,
  73    0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x3 , 0x2 , 0x0 ,
  74    0x3 , 0x3 , 0x3 , 0x3 , 0x3 , 0x3 , 0x3 , 0x3 , 0x3 , 0x3 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 ,
  75    0x0 , 0x3 , 0x3 , 0x3 , 0x3 , 0x3 , 0x3 , 0x3 , 0x3 , 0x3 , 0x3 , 0x3 , 0x3 , 0x3 , 0x3 , 0x3 ,
  76    0x3 , 0x3 , 0x3 , 0x3 , 0x3 , 0x3 , 0x3 , 0x3 , 0x3 , 0x3 , 0x3 , 0x0 , 0x0 , 0x0 , 0x0 , 0x2 ,
  77    0x0 , 0x3 , 0x3 , 0x3 , 0x3 , 0x3 , 0x3 , 0x3 , 0x3 , 0x3 , 0x3 , 0x3 , 0x3 , 0x3 , 0x3 , 0x3 ,
  78    0x3 , 0x3 , 0x3 , 0x3 , 0x3 , 0x3 , 0x3 , 0x3 , 0x3 , 0x3 , 0x3 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 ,
  79    0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 ,
  80    0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 ,
  81    0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 ,
  82    0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 ,
  83    0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 ,
  84    0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 ,
  85    0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 ,
  86    0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 , 0x0 ,
  87 };
  88
  89 static void report_error (AnjutaPluginDescriptionParser *parser,
  90                                                   char *message,
  91                                                   AnjutaPluginDescriptionParseError    error_code,
  92                                                   GError                  **error);
  93
  94 static AnjutaPluginDescriptionSection *lookup_section (AnjutaPluginDescription *df,
  95                                               const char *section);
  96
  97 static AnjutaPluginDescriptionLine *lookup_line (AnjutaPluginDescription *df,
  98                                                                                                  AnjutaPluginDescriptionSection *section,
  99                                                                                                  const char *keyname,
 100                                                                                                  const char *locale);
 101
 102 GQuark
 103 anjuta_plugin_description_parse_error_quark (void)
 104 {
 105   static GQuark quark;
 106   if (!quark)
 107     quark = g_quark_from_static_string ("g_desktop_parse_error");
 108
 109   return quark;
 110 }
 111
 112 static void
 113 parser_free (AnjutaPluginDescriptionParser *parser)
 114 {
 115   anjuta_plugin_description_free (parser->df);
 116 }
 117
 118 static void
 119 anjuta_plugin_description_line_free (AnjutaPluginDescriptionLine *line)
 120 {
 121   g_free (line->locale);
 122   g_free (line->value);
 123 }
 124
 125 static void
 126 anjuta_plugin_description_section_free (AnjutaPluginDescriptionSection *section)
 127 {
 128   int i;
 129
 130   for (i = 0; i < section->n_lines; i++)
 131     anjuta_plugin_description_line_free (&section->lines[i]);
 132
 133   g_free (section->lines);
 134 }
 135
 136 /**
 137  * anjuta_plugin_description_free:
 138  * @df: an #AnjutaPluginDescription object
 139  *
 140  * Frees the #AnjutaPluginDescription instance.
 141  */
 142 void
 143 anjuta_plugin_description_free (AnjutaPluginDescription *df)
 144 {
 145   int i;
 146
 147   for (i = 0; i < df->n_sections; i++)
 148     anjuta_plugin_description_section_free (&df->sections[i]);
 149   g_free (df->sections);
 150   g_free (df->current_locale[0]);
 151   g_free (df->current_locale[1]);
 152
 153   g_free (df);
 154 }
 155
 156 static void
 157 grow_lines (AnjutaPluginDescriptionParser *parser)
 158 {
 159   int new_n_lines;
 160   AnjutaPluginDescriptionSection *section;
 161
 162   if (parser->n_allocated_lines == 0)
 163     new_n_lines = 1;
 164   else
 165     new_n_lines = parser->n_allocated_lines*2;
 166
 167   section = &parser->df->sections[parser->current_section];
 168
 169   section->lines = g_realloc (section->lines,
 170                               sizeof (AnjutaPluginDescriptionLine) * new_n_lines);
 171   parser->n_allocated_lines = new_n_lines;
 172 }
 173
 174 static void
 175 grow_sections (AnjutaPluginDescriptionParser *parser)
 176 {
 177   int new_n_sections;
 178
 179   if (parser->n_allocated_sections == 0)
 180     new_n_sections = 1;
 181   else
 182     new_n_sections = parser->n_allocated_sections*2;
 183
 184   parser->df->sections = g_realloc (parser->df->sections,
 185                                     sizeof (AnjutaPluginDescriptionSection) * new_n_sections);
 186   parser->n_allocated_sections = new_n_sections;
 187 }
 188
 189 static gchar *
 190 unescape_string (gchar *str, gint len)
 191 {
 192   gchar *res;
 193   gchar *p, *q;
 194   gchar *end;
 195
 196   /* len + 1 is enough, because unescaping never makes the
 197    * string longer */
 198   res = g_new (gchar, len + 1);
 199   p = str;
 200   q = res;
 201   end = str + len;
 202
 203   while (p < end)
 204     {
 205       if (*p == 0)
 206         {
 207           /* Found an embedded null */
 208           g_free (res);
 209           return NULL;
 210         }
 211       if (*p == '\\')
 212         {
 213           p++;
 214           if (p >= end)
 215             {
 216               /* Escape at end of string */
 217               g_free (res);
 218               return NULL;
 219             }
 220
 221           switch (*p)
 222             {
 223             case 's':
 224               *q++ = ' ';
 225               break;
 226            case 't':
 227               *q++ = '\t';
 228               break;
 229            case 'n':
 230               *q++ = '\n';
 231               break;
 232            case 'r':
 233               *q++ = '\r';
 234               break;
 235            case '\\':
 236               *q++ = '\\';
 237               break;
 238            default:
 239              /* Invalid escape code */
 240              g_free (res);
 241              return NULL;
 242             }
 243           p++;
 244         }
 245       else
 246         *q++ = *p++;
 247     }
 248   *q = 0;
 249
 250   return res;
 251 }
 252
 253 static gchar *
 254 escape_string (const gchar *str, gboolean escape_first_space)
 255 {
 256   gchar *res;
 257   char *q;
 258   const gchar *p;
 259   const gchar *end;
 260
 261   /* len + 1 is enough, because unescaping never makes the
 262    * string longer */
 263   res = g_new (gchar, strlen (str)*2 + 1);
 264
 265   p = str;
 266   q = res;
 267   end = str + strlen (str);
 268
 269   while (*p)
 270     {
 271       if (*p == ' ')
 272         {
 273           if (escape_first_space && p == str)
 274             {
 275               *q++ = '\\';
 276               *q++ = 's';
 277             }
 278           else
 279             *q++ = ' ';
 280         }
 281       else if (*p == '\\')
 282         {
 283           *q++ = '\\';
 284           *q++ = '\\';
 285         }
 286       else if (*p == '\t')
 287         {
 288           *q++ = '\\';
 289           *q++ = 't';
 290         }
 291       else if (*p == '\n')
 292         {
 293           *q++ = '\\';
 294           *q++ = 'n';
 295         }
 296       else if (*p == '\r')
 297         {
 298           *q++ = '\\';
 299           *q++ = 'r';
 300         }
 301       else
 302         *q++ = *p;
 303       p++;
 304     }
 305   *q = 0;
 306
 307   return res;
 308 }
 309
 310
 311 static void
 312 open_section (AnjutaPluginDescriptionParser *parser,
 313               const char           *name)
 314 {
 315   int n;
 316
 317   if (parser->n_allocated_sections == parser->df->n_sections)
 318     grow_sections (parser);
 319
 320   if (parser->current_section == 0 &&
 321       parser->df->sections[0].section_name == 0 &&
 322       parser->df->sections[0].n_lines == 0)
 323     {
 324       if (!name)
 325         g_warning ("non-initial NULL section\n");
 326
 327       /* The initial section was empty. Piggyback on it. */
 328       parser->df->sections[0].section_name = g_quark_from_string (name);
 329
 330       return;
 331     }
 332
 333   n = parser->df->n_sections++;
 334
 335   if (name)
 336     parser->df->sections[n].section_name = g_quark_from_string (name);
 337   else
 338     parser->df->sections[n].section_name = 0;
 339   parser->df->sections[n].n_lines = 0;
 340   parser->df->sections[n].lines = NULL;
 341
 342   parser->current_section = n;
 343   parser->n_allocated_lines = 0;
 344   grow_lines (parser);
 345 }
 346
 347 static AnjutaPluginDescriptionLine *
 348 new_line (AnjutaPluginDescriptionParser *parser)
 349 {
 350   AnjutaPluginDescriptionSection *section;
 351   AnjutaPluginDescriptionLine *line;
 352
 353   section = &parser->df->sections[parser->current_section];
 354
 355   if (parser->n_allocated_lines == section->n_lines)
 356     grow_lines (parser);
 357
 358   line = &section->lines[section->n_lines++];
 359
 360   memset (line, 0, sizeof (AnjutaPluginDescriptionLine));
 361
 362   return line;
 363 }
 364
 365 static gboolean
 366 is_blank_line (AnjutaPluginDescriptionParser *parser)
 367 {
 368   gchar *p;
 369
 370   p = parser->line;
 371
 372   while (*p && *p != '\n')
 373     {
 374       if (!g_ascii_isspace (*p))
 375         return FALSE;
 376
 377       p++;
 378     }
 379   return TRUE;
 380 }
 381
 382 static void
 383 parse_comment_or_blank (AnjutaPluginDescriptionParser *parser)
 384 {
 385   AnjutaPluginDescriptionLine *line;
 386   gchar *line_end;
 387
 388   line_end = strchr (parser->line, '\n');
 389   if (line_end == NULL)
 390     line_end = parser->line + strlen (parser->line);
 391
 392   line = new_line (parser);
 393
 394   line->value = g_strndup (parser->line, line_end - parser->line);
 395
 396   parser->line = (line_end) ? line_end + 1 : NULL;
 397   parser->line_nr++;
 398 }
 399
 400 static gboolean
 401 parse_section_start (AnjutaPluginDescriptionParser *parser, GError **error)
 402 {
 403   gchar *line_end;
 404   gchar *section_name;
 405
 406   line_end = strchr (parser->line, '\n');
 407   if (line_end == NULL)
 408     line_end = parser->line + strlen (parser->line);
 409
 410   if (line_end - parser->line <= 2 ||
 411       line_end[-1] != ']')
 412     {
 413       report_error (parser, "Invalid syntax for section header", ANJUTA_PLUGIN_DESCRIPTION_PARSE_ERROR_INVALID_SYNTAX, error);
 414       parser_free (parser);
 415       return FALSE;
 416     }
 417
 418   section_name = unescape_string (parser->line + 1, line_end - parser->line - 2);
 419
 420   if (section_name == NULL)
 421     {
 422       report_error (parser, "Invalid escaping in section name", ANJUTA_PLUGIN_DESCRIPTION_PARSE_ERROR_INVALID_ESCAPES, error);
 423       parser_free (parser);
 424       return FALSE;
 425     }
 426
 427   open_section (parser, section_name);
 428
 429   parser->line = (line_end) ? line_end + 1 : NULL;
 430   parser->line_nr++;
 431
 432   g_free (section_name);
 433
 434   return TRUE;
 435 }
 436
 437 static gboolean
 438 parse_key_value (AnjutaPluginDescriptionParser *parser, GError **error)
 439 {
 440   AnjutaPluginDescriptionLine *line;
 441   gchar *line_end;
 442   gchar *key_start;
 443   gchar *key_end;
 444   gchar *key;
 445   gchar *locale_start = NULL;
 446   gchar *locale_end = NULL;
 447   gchar *value_start;
 448   gchar *value;
 449   gchar *p;
 450
 451   line_end = strchr (parser->line, '\n');
 452   if (line_end == NULL)
 453     line_end = parser->line + strlen (parser->line);
 454
 455   p = parser->line;
 456   key_start = p;
 457   while (p < line_end &&
 458          (valid[(guchar)*p] & VALID_KEY_CHAR))
 459     p++;
 460   key_end = p;
 461
 462   if (key_start == key_end)
 463     {
 464       report_error (parser, "Empty key name", ANJUTA_PLUGIN_DESCRIPTION_PARSE_ERROR_INVALID_SYNTAX, error);
 465       parser_free (parser);
 466       return FALSE;
 467     }
 468
 469   if (p < line_end && *p == '[')
 470     {
 471       p++;
 472       locale_start = p;
 473       while (p < line_end && *p != ']')
 474         p++;
 475       locale_end = p;
 476
 477       if (p == line_end)
 478         {
 479           report_error (parser, "Unterminated locale specification in key", ANJUTA_PLUGIN_DESCRIPTION_PARSE_ERROR_INVALID_SYNTAX, error);
 480           parser_free (parser);
 481           return FALSE;
 482         }
 483
 484       p++;
 485     }
 486
 487   /* Skip space before '=' */
 488   while (p < line_end && *p == ' ')
 489     p++;
 490
 491   if (p < line_end && *p != '=')
 492     {
 493       report_error (parser, "Invalid characters in key name", ANJUTA_PLUGIN_DESCRIPTION_PARSE_ERROR_INVALID_CHARS, error);
 494       parser_free (parser);
 495       return FALSE;
 496     }
 497
 498   if (p == line_end)
 499     {
 500       report_error (parser, "No '=' in key/value pair", ANJUTA_PLUGIN_DESCRIPTION_PARSE_ERROR_INVALID_SYNTAX, error);
 501       parser_free (parser);
 502       return FALSE;
 503     }
 504
 505   /* Skip the '=' */
 506   p++;
 507
 508   /* Skip space after '=' */
 509   while (p < line_end && *p == ' ')
 510     p++;
 511
 512   value_start = p;
 513
 514   value = unescape_string (value_start, line_end - value_start);
 515   if (value == NULL)
 516     {
 517       report_error (parser, "Invalid escaping in value", ANJUTA_PLUGIN_DESCRIPTION_PARSE_ERROR_INVALID_ESCAPES, error);
 518       parser_free (parser);
 519       return FALSE;
 520     }
 521
 522   line = new_line (parser);
 523   key = g_strndup (key_start, key_end - key_start);
 524   line->key = g_quark_from_string (key);
 525   g_free (key);
 526   if (locale_start)
 527     line->locale = g_strndup (locale_start, locale_end - locale_start);
 528   line->value = value;
 529
 530   parser->line = (line_end) ? line_end + 1 : NULL;
 531   parser->line_nr++;
 532
 533   return TRUE;
 534 }
 535
 536
 537 static void
 538 report_error (AnjutaPluginDescriptionParser *parser,
 539               char                   *message,
 540               AnjutaPluginDescriptionParseError  error_code,
 541               GError                **error)
 542 {
 543   AnjutaPluginDescriptionSection *section;
 544   const gchar *section_name = NULL;
 545
 546   section = &parser->df->sections[parser->current_section];
 547
 548   if (section->section_name)
 549     section_name = g_quark_to_string (section->section_name);
 550
 551   if (error)
 552     {
 553       if (section_name)
 554         *error = g_error_new (ANJUTA_PLUGIN_DESCRIPTION_PARSE_ERROR,
 555                               error_code,
 556                               "Error in section %s at line %d: %s", section_name, parser->line_nr, message);
 557       else
 558         *error = g_error_new (ANJUTA_PLUGIN_DESCRIPTION_PARSE_ERROR,
 559                               error_code,
 560                               "Error at line %d: %s", parser->line_nr, message);
 561     }
 562 }
 563
 564 /**
 565  * anjuta_plugin_description_new_from_string:
 566  * @data: The data to parse. The format of the data is .ini style.
 567  *
 568  * Parses the given plugin description data (usally read from the plugin
 569  * description file and creates an instance of #AnjutaPluginDescription.
 570  * The format of the content string is similar to .ini format.
 571  *
 572  * Return value: a new #AnjutaPluginDescription object
 573  */
 574 AnjutaPluginDescription *
 575 anjuta_plugin_description_new_from_string (char *data, GError **error)
 576 {
 577   AnjutaPluginDescriptionParser parser;
 578
 579   parser.df = g_new0 (AnjutaPluginDescription, 1);
 580   parser.current_section = -1;
 581
 582   parser.n_allocated_lines = 0;
 583   parser.n_allocated_sections = 0;
 584   parser.line_nr = 1;
 585
 586   parser.line = data;
 587
 588   /* Put any initial comments in a NULL segment */
 589   open_section (&parser, NULL);
 590
 591   while (parser.line && *parser.line)
 592     {
 593       if (*parser.line == '[') {
 594         if (!parse_section_start (&parser, error))
 595           return NULL;
 596       } else if (is_blank_line (&parser) ||
 597                  *parser.line == '#')
 598         parse_comment_or_blank (&parser);
 599       else
 600         {
 601           if (!parse_key_value (&parser, error))
 602             return NULL;
 603         }
 604     }
 605
 606   return parser.df;
 607 }
 608
 609 /**
 610  * anjuta_plugin_description_to_string:
 611  * @df: an #AnjutaPluginDescription object.
 612  *
 613  * Converts the description detains into string format, usually for
 614  * saving it in a file.
 615  *
 616  * Return value: The string representation of the description. The
 617  * returned values must be freed after use.
 618  */
 619 char *
 620 anjuta_plugin_description_to_string (AnjutaPluginDescription *df)
 621 {
 622   AnjutaPluginDescriptionSection *section;
 623   AnjutaPluginDescriptionLine *line;
 624   GString *str;
 625   char *s;
 626   int i, j;
 627
 628   str = g_string_sized_new (800);
 629
 630   for (i = 0; i < df->n_sections; i ++)
 631     {
 632       section = &df->sections[i];
 633
 634       if (section->section_name)
 635         {
 636           g_string_append_c (str, '[');
 637           s = escape_string (g_quark_to_string (section->section_name), FALSE);
 638           g_string_append (str, s);
 639           g_free (s);
 640           g_string_append (str, "]\n");
 641         }
 642
 643       for (j = 0; j < section->n_lines; j++)
 644         {
 645           line = &section->lines[j];
 646
 647           if (line->key == 0)
 648             {
 649               g_string_append (str, line->value);
 650               g_string_append_c (str, '\n');
 651             }
 652           else
 653             {
 654               g_string_append (str, g_quark_to_string (line->key));
 655               if (line->locale)
 656                 {
 657                   g_string_append_c (str, '[');
 658                   g_string_append (str, line->locale);
 659                   g_string_append_c (str, ']');
 660                 }
 661               g_string_append_c (str, '=');
 662               s = escape_string (line->value, TRUE);
 663               g_string_append (str, s);
 664               g_free (s);
 665               g_string_append_c (str, '\n');
 666             }
 667         }
 668     }
 669
 670   return g_string_free (str, FALSE);
 671 }
 672
 673 static AnjutaPluginDescriptionSection *
 674 lookup_section (AnjutaPluginDescription  *df,
 675                 const char        *section_name)
 676 {
 677   AnjutaPluginDescriptionSection *section;
 678   GQuark section_quark;
 679   int i;
 680
 681   section_quark = g_quark_try_string (section_name);
 682   if (section_quark == 0)
 683     return NULL;
 684
 685   for (i = 0; i < df->n_sections; i ++)
 686     {
 687       section = &df->sections[i];
 688
 689       if (section->section_name == section_quark)
 690         return section;
 691     }
 692   return NULL;
 693 }
 694
 695 static AnjutaPluginDescriptionLine *
 696 lookup_line (AnjutaPluginDescription        *df,
 697              AnjutaPluginDescriptionSection *section,
 698              const char              *keyname,
 699              const char              *locale)
 700 {
 701   AnjutaPluginDescriptionLine *line;
 702   GQuark key_quark;
 703   int i;
 704
 705   key_quark = g_quark_try_string (keyname);
 706   if (key_quark == 0)
 707     return NULL;
 708
 709   for (i = 0; i < section->n_lines; i++)
 710     {
 711       line = &section->lines[i];
 712
 713       if (line->key == key_quark &&
 714           ((locale == NULL && line->locale == NULL) ||
 715            (locale != NULL && line->locale != NULL && strcmp (locale, line->locale) == 0)))
 716         return line;
 717     }
 718
 719   return NULL;
 720 }
 721
 722 /**
 723  * anjuta_plugin_description_get_raw:
 724  * @df: an #AnjutaPluginDescription object.
 725  * @section_name: Name of the section.
 726  * @keyname: Name of the key.
 727  * @locale: The locale for which the value is to be retrieved.
 728  * @val: Pointer to the variable to store the string value.
 729  *
 730  * Retrieves the value of a key (in the given section) for the given locale.
 731  * The value returned in @val must be freed after use.
 732  *
 733  * Return value: TRUE if sucessful, otherwise FALSE.
 734  */
 735 gboolean
 736 anjuta_plugin_description_get_raw (AnjutaPluginDescription *df,
 737                             const char    *section_name,
 738                             const char    *keyname,
 739                             const char    *locale,
 740                             char         **val)
 741 {
 742   AnjutaPluginDescriptionSection *section;
 743   AnjutaPluginDescriptionLine *line;
 744
 745   *val = NULL;
 746
 747   section = lookup_section (df, section_name);
 748   if (!section)
 749     return FALSE;
 750
 751   line = lookup_line (df,
 752                       section,
 753                       keyname,
 754                       locale);
 755
 756   if (!line)
 757     return FALSE;
 758
 759   *val = g_strdup (line->value);
 760
 761   return TRUE;
 762 }
 763
 764 /**
 765  * anjuta_plugin_description_foreach_section:
 766  * @df: an #AnjutaPluginDescription object.
 767  * @func: Callback function.
 768  * @user_data: User data to pass to @func.
 769  *
 770  * Calls @func for each of the sections in the description.
 771  */
 772 void
 773 anjuta_plugin_description_foreach_section (AnjutaPluginDescription *df,
 774                                   AnjutaPluginDescriptionSectionFunc func,
 775                                   gpointer user_data)
 776 {
 777   AnjutaPluginDescriptionSection *section;
 778   int i;
 779
 780   for (i = 0; i < df->n_sections; i ++)
 781     {
 782       section = &df->sections[i];
 783
 784       (*func) (df, g_quark_to_string (section->section_name),  user_data);
 785     }
 786   return;
 787 }
 788
 789 /**
 790  * anjuta_plugin_description_foreach_key:
 791  * @df: an #AnjutaPluginDescription object.
 792  * @section_name: Name of the section.
 793  * @include_localized: Whether each localized key should be called separately.
 794  * @func: The callback function.
 795  * @user_data: User data to pass to @func.
 796  *
 797  * Calls @func for each of the keys in the given section. @include_localized,
 798  * if set to TRUE will make it call @func for the localized keys also, otherwise
 799  * only one call is made for the key in current locale.
 800  */
 801 void
 802 anjuta_plugin_description_foreach_key (AnjutaPluginDescription *df,
 803                               const char                  *section_name,
 804                               gboolean                     include_localized,
 805                               AnjutaPluginDescriptionLineFunc     func,
 806                               gpointer                     user_data)
 807 {
 808   AnjutaPluginDescriptionSection *section;
 809   AnjutaPluginDescriptionLine *line;
 810   int i;
 811
 812   section = lookup_section (df, section_name);
 813   if (!section)
 814     return;
 815
 816   for (i = 0; i < section->n_lines; i++)
 817     {
 818       line = &section->lines[i];
 819
 820       (*func) (df, g_quark_to_string (line->key), line->locale, line->value, user_data);
 821     }
 822
 823   return;
 824 }
 825
 826
 827 static void
 828 calculate_locale (AnjutaPluginDescription   *df)
 829 {
 830   char *p, *lang;
 831
 832   lang = g_strdup (setlocale (LC_MESSAGES, NULL));
 833
 834   if (lang)
 835     {
 836       p = strchr (lang, '.');
 837       if (p)
 838         *p = '\0';
 839       p = strchr (lang, '@');
 840       if (p)
 841         *p = '\0';
 842     }
 843   else
 844     lang = g_strdup ("C");
 845
 846   p = strchr (lang, '_');
 847   if (p)
 848     {
 849       df->current_locale[0] = g_strdup (lang);
 850       *p = '\0';
 851       df->current_locale[1] = lang;
 852     }
 853   else
 854     {
 855       df->current_locale[0] = lang;
 856       df->current_locale[1] = NULL;
 857     }
 858 }
 859
 860 /**
 861  * anjuta_plugin_description_get_locale_string:
 862  * @df: an #AnjutaPluginDescription object.
 863  * @section: Section name.
 864  * @keyname: Key name.
 865  * @val: Pointer to value to store retured value.
 866  *
 867  * Returns the value of key in the given section in current locale.
 868  *
 869  * Return value: TRUE if sucessful, otherwise FALSE.
 870  */
 871 gboolean
 872 anjuta_plugin_description_get_locale_string  (AnjutaPluginDescription  *df,
 873                                      const char      *section,
 874                                      const char      *keyname,
 875                                      char           **val)
 876 {
 877   gboolean res;
 878
 879   if (df->current_locale[0] == NULL)
 880     calculate_locale (df);
 881
 882   if  (df->current_locale[0] != NULL)
 883     {
 884       res = anjuta_plugin_description_get_raw (df,section, keyname,
 885                                       df->current_locale[0], val);
 886       if (res)
 887         return TRUE;
 888     }
 889
 890   if  (df->current_locale[1] != NULL)
 891     {
 892       res = anjuta_plugin_description_get_raw (df,section, keyname,
 893                                       df->current_locale[1], val);
 894       if (res)
 895         return TRUE;
 896     }
 897
 898   return anjuta_plugin_description_get_raw (df, section, keyname, NULL, val);
 899 }
 900
 901 /**
 902  * anjuta_plugin_description_get_string:
 903  * @df: an #AnjutaPluginDescription object.
 904  * @section: Section name.
 905  * @keyname: Key name.
 906  * @val: Pointer to value to store retured value.
 907  *
 908  * Returns the value of key in the given section.
 909  *
 910  * Return value: TRUE if sucessful, otherwise FALSE.
 911  */
 912 gboolean
 913 anjuta_plugin_description_get_string (AnjutaPluginDescription   *df,
 914                              const char       *section,
 915                              const char       *keyname,
 916                              char            **val)
 917 {
 918   return anjuta_plugin_description_get_raw (df, section, keyname, NULL, val);
 919 }
 920
 921 /**
 922  * anjuta_plugin_description_get_integer:
 923  * @df: an #AnjutaPluginDescription object.
 924  * @section: Section name.
 925  * @keyname: Key name.
 926  * @val: Pointer to value to store retured value.
 927  *
 928  * Returns the value of key as integer in the given section in current locale.
 929  *
 930  * Return value: TRUE if sucessful, otherwise FALSE.
 931  */
 932 gboolean
 933 anjuta_plugin_description_get_integer (AnjutaPluginDescription   *df,
 934                               const char       *section,
 935                               const char       *keyname,
 936                               int              *val)
 937 {
 938   gboolean res;
 939   char *str;
 940
 941   *val = 0;
 942
 943   res = anjuta_plugin_description_get_raw (df, section, keyname, NULL, &str);
 944   if (!res)
 945     return FALSE;
 946
 947
 948   *val = atoi (str);
 949   g_free (str);
 950
 951   return TRUE;
 952
 953 }