gtl/src/gml_parser.cpp

0001 /* This software is distributed under the GNU Lesser General Public License */
0002 //==========================================================================
0003 //
0004 //   gml_parser.cpp - parser for the GML-file-format specified in:
0005 //                    Michael Himsolt, GML: Graph Modelling Language,
0006 //                    21.01.1997
0007 //
0008 //==========================================================================
0009 // $Id: gml_parser.cpp,v 1.9 2001/11/07 13:58:10 pick Exp $
0010
0011 #include <GTL/gml_parser.h>
0012
0013 #include <cstdio>
0014 #include <cstdlib>
0015 #include <cassert>
0016 #include <string.h>
0017
0018 #ifdef __GTL_MSVCC
0019 #   ifdef _DEBUG
0020 #   ifndef SEARCH_MEMORY_LEAKS_ENABLED
0021 #   error SEARCH NOT ENABLED
0022 #   endif
0023 #   define new DEBUG_NEW
0024 #   undef THIS_FILE
0025     static char THIS_FILE[] = __FILE__;
0026 #   endif   // _DEBUG
0027 #endif  // __GTL_MSVCC
0028
0029 __GTL_BEGIN_NAMESPACE
0030
0031 struct GML_pair* GML_parser (FILE* source, struct GML_stat* stat, int open) {
0032
0033     struct GML_token token;
0034     struct GML_pair* pair;
0035     struct GML_pair* list;
0036     struct GML_pair* tmp = NULL;
0037     struct GML_list_elem* tmp_elem;
0038
0039     assert (stat);
0040
0041     pair = (struct GML_pair*) malloc (sizeof (struct GML_pair));
0042     pair->next = NULL;
0043     list = pair;
0044
0045     for (;;) {
0046     token = GML_scanner (source);
0047
0048     if (token.kind == GML_END) {
0049         if (open) {
0050         stat->err.err_num = GML_OPEN_BRACKET;
0051         stat->err.line = GML_line;
0052         stat->err.column = GML_column;
0053         free (pair);
0054
0055         if (tmp == NULL) {
0056           return NULL;
0057         } else {
0058           tmp->next = NULL;
0059           return list;
0060         }
0061         }
0062
0063         break;
0064
0065     } else if (token.kind == GML_R_BRACKET) {
0066         if (!open) {
0067         stat->err.err_num = GML_TOO_MANY_BRACKETS;
0068         stat->err.line = GML_line;
0069         stat->err.column = GML_column;
0070         free (pair);
0071
0072         if (tmp == NULL) {
0073           return NULL;
0074         } else {
0075           tmp->next = NULL;
0076           return list;
0077         }
0078         }
0079
0080         break;
0081
0082     } else if (token.kind == GML_ERROR) {
0083         stat->err.err_num = token.value.err.err_num;
0084         stat->err.line = token.value.err.line;
0085         stat->err.column = token.value.err.column;
0086         free (pair);
0087
0088         if (tmp == NULL) {
0089         return NULL;
0090         } else {
0091         tmp->next = NULL;
0092         return list;
0093         }
0094
0095     } else if (token.kind != GML_KEY) {
0096         stat->err.err_num = GML_SYNTAX;
0097         stat->err.line = GML_line;
0098         stat->err.column = GML_column;
0099         free (pair);
0100
0101         if (token.kind == GML_STRING) {
0102         free (token.value.str);
0103         }
0104
0105         if (tmp == NULL) {
0106         return NULL;
0107         } else {
0108         tmp->next = NULL;
0109         return list;
0110         }
0111     }
0112
0113     if (!stat->key_list) {
0114         stat->key_list = (struct GML_list_elem*)
0115         malloc (sizeof (struct GML_list_elem));
0116         stat->key_list->next = NULL;
0117         stat->key_list->key = token.value.str;
0118         pair->key = token.value.str;
0119
0120     } else {
0121         tmp_elem = stat->key_list;
0122
0123         while (tmp_elem) {
0124         if (!strcmp (tmp_elem->key, token.value.str)) {
0125             free (token.value.str);
0126             pair->key = tmp_elem->key;
0127             break;
0128         }
0129
0130         tmp_elem = tmp_elem->next;
0131         }
0132
0133         if (!tmp_elem) {
0134         tmp_elem = (struct GML_list_elem*)
0135             malloc (sizeof (struct GML_list_elem));
0136         tmp_elem->next = stat->key_list;
0137         stat->key_list = tmp_elem;
0138         tmp_elem->key = token.value.str;
0139         pair->key = token.value.str;
0140         }
0141     }
0142
0143     token = GML_scanner (source);
0144
0145     switch (token.kind) {
0146     case GML_INT:
0147         pair->kind = GML_INT;
0148         pair->value.integer = token.value.integer;
0149         break;
0150
0151     case GML_DOUBLE:
0152         pair->kind = GML_DOUBLE;
0153         pair->value.floating = token.value.floating;
0154         break;
0155
0156     case GML_STRING:
0157         pair->kind = GML_STRING;
0158         pair->value.str = token.value.str;
0159         break;
0160
0161     case GML_L_BRACKET:
0162         pair->kind = GML_LIST;
0163         pair->value.list = GML_parser (source, stat, 1);
0164
0165         if (stat->err.err_num != GML_OK) {
0166         return list;
0167         }
0168
0169         break;
0170
0171     case GML_ERROR:
0172         stat->err.err_num = token.value.err.err_num;
0173         stat->err.line = token.value.err.line;
0174         stat->err.column = token.value.err.column;
0175         free (pair);
0176
0177         if (tmp == NULL) {
0178         return NULL;
0179         } else {
0180         tmp->next = NULL;
0181         return list;
0182         }
0183
0184     default:
0185         stat->err.line = GML_line;
0186         stat->err.column = GML_column;
0187         stat->err.err_num = GML_SYNTAX;
0188         free (pair);
0189
0190         if (tmp == NULL) {
0191         return NULL;
0192         } else {
0193         tmp->next = NULL;
0194         return list;
0195         }
0196     }
0197
0198     tmp = pair;
0199     pair = (struct GML_pair*) malloc (sizeof (struct GML_pair));
0200     tmp->next = pair;
0201     pair->next = NULL;
0202     }
0203
0204     stat->err.err_num = GML_OK;
0205     free (pair);
0206
0207     if (tmp == NULL) {
0208     return NULL;
0209     } else {
0210     tmp->next = NULL;
0211     return list;
0212     }
0213 }
0214
0215
0216 void GML_free_list (struct GML_pair* list, struct GML_list_elem* keys) {
0217
0218     struct GML_pair* tmp = list;
0219     struct GML_list_elem* tmp_key;
0220
0221     while (keys) {
0222     free (keys->key);
0223     tmp_key = keys->next;
0224     free (keys);
0225     keys = tmp_key;
0226     }
0227
0228     while (list) {
0229
0230     switch (list->kind) {
0231     case GML_LIST:
0232         GML_free_list (list->value.list, NULL);
0233         break;
0234
0235     case GML_STRING:
0236         free (list->value.str);
0237         break;
0238
0239     default:
0240         break;
0241     }
0242
0243     tmp = list->next;
0244     free (list);
0245     list = tmp;
0246     }
0247 }
0248
0249
0250
0251 void GML_print_list (struct GML_pair* list, int level) {
0252
0253     struct GML_pair* tmp = list;
0254     int i;
0255
0256     while (tmp) {
0257
0258     for (i = 0; i < level; i++) {
0259         printf ("    ");
0260     }
0261
0262     printf ("*KEY* : %s", tmp->key);
0263
0264     switch (tmp->kind) {
0265     case GML_INT:
0266         printf ("  *VALUE* (long) : %ld \n", tmp->value.integer);
0267         break;
0268
0269     case GML_DOUBLE:
0270         printf ("  *VALUE* (double) : %f \n", tmp->value.floating);
0271         break;
0272
0273     case GML_STRING:
0274         printf ("  *VALUE* (string) : %s \n", tmp->value.str);
0275         break;
0276
0277     case GML_LIST:
0278         printf ("  *VALUE* (list) : \n");
0279         GML_print_list (tmp->value.list, level+1);
0280         break;
0281
0282     default:
0283         break;
0284     }
0285
0286     tmp = tmp->next;
0287     }
0288 }
0289
0290 __GTL_END_NAMESPACE
0291
0292 //--------------------------------------------------------------------------
0293 //   end of file
0294 //--------------------------------------------------------------------------