Ticket #2128: common.patch

File common.patch, 17.4 KB (added by tamas, 9 years ago)

common.patch

  • Makefile.vc

     
    4141        mapogcfilter.obj mapogcsld.obj mapthread.obj mapobject.obj \
    4242                classobject.obj layerobject.obj mapwcs.obj mapgeos.obj strptime.obj \
    4343                mapcpl.obj mapio.obj mappool.obj mapsvg.obj mapregex.obj mappluginlayer.obj \
    44                 mapogcsos.obj mappostgresql.obj mapcrypto.obj mapowscommon.obj \
     44        mapogcsos.obj mappostgresql.obj mapcrypto.obj mapowscommon.obj \
     45        mapcache.obj mapgeomtrans.obj mapfilter.obj \
    4546                $(EPPL_OBJ) $(REGEX_OBJ)
    4647
    4748MS_HDRS =       map.h mapfile.h
     
    9091.c.exe:
    9192        $(CC) $(CFLAGS) /c $*.c /Fo$*.obj
    9293!IFDEF DLLBUILD
    93         $(LINK) $(LDFLAGS) $*.obj $(LIBS_DLL)
     94        $(LINK) $(LDFLAGS) $(LDEBUG)  $*.obj $(LIBS_DLL)
    9495!ELSE
    95         $(LINK) $(LDFLAGS) $*.obj $(LIBS)
     96        $(LINK) $(LDFLAGS) $(LDEBUG)  $*.obj $(LIBS)
    9697!ENDIF
    9798        if exist $@.manifest mt -manifest $@.manifest -outputresource:$@;1
    9899
     
    100101        del *.obj
    101102        del $(REGEX_OBJ)
    102103        del *.lib
    103         del *.dll
     104#       del *.dll
    104105        del $(MS_EXE)
    105106        del *.pdb
    106107        del *.exp
  • map.h

     
    328328
    329329enum MS_BITMAP_FONT_SIZES {MS_TINY , MS_SMALL, MS_MEDIUM, MS_LARGE, MS_GIANT};
    330330enum MS_QUERYMAP_STYLES {MS_NORMAL, MS_HILITE, MS_SELECTED};
    331 enum MS_CONNECTION_TYPE {MS_INLINE, MS_SHAPEFILE, MS_TILED_SHAPEFILE, MS_SDE, MS_OGR, MS_UNUSED_1, MS_POSTGIS, MS_WMS, MS_ORACLESPATIAL, MS_WFS, MS_GRATICULE, MS_MYGIS, MS_RASTER, MS_PLUGIN };
     331enum MS_CONNECTION_TYPE {MS_INLINE, MS_SHAPEFILE, MS_TILED_SHAPEFILE, MS_SDE, MS_OGR, MS_UNUSED_1, MS_POSTGIS, MS_WMS, MS_ORACLESPATIAL, MS_WFS, MS_GRATICULE, MS_MYGIS, MS_RASTER, MS_PLUGIN, MS_GEOMTRANS, MS_LAYERFILTER, MS_CACHE };
    332332enum MS_JOIN_CONNECTION_TYPE {MS_DB_XBASE, MS_DB_CSV, MS_DB_MYSQL, MS_DB_ORACLE, MS_DB_POSTGRES};
    333333enum MS_JOIN_TYPE {MS_JOIN_ONE_TO_ONE, MS_JOIN_ONE_TO_MANY};
    334334
     
    10511051#ifdef SWIG
    10521052%mutable;
    10531053#endif /* SWIG */
     1054
     1055#ifndef SWIG
     1056  struct layer_obj **layers;
     1057  int numlayers; /* number of sublayers in layer */
     1058#endif /* SWIG */
    10541059} layerObj;
    10551060
    10561061
     
    12491254
    12501255    int (*LayerCreateItems)(layerObj *layer, int nt);
    12511256    int (*LayerGetNumFeatures)(layerObj *layer);
     1257    void (*LayerDestroy)(layerObj *layer);
    12521258};
    12531259#endif /*SWIG*/
    12541260
     
    16001606MS_DLL_EXPORT int msInitializeVirtualTable(layerObj *layer);
    16011607MS_DLL_EXPORT int msConnectLayer(layerObj *layer, const int connectiontype,
    16021608                                 const char *library_str);
    1603 
     1609MS_DLL_EXPORT layerObj *msGetSubLayer(layerObj *layer, char* path);
    16041610MS_DLL_EXPORT int msINLINELayerInitializeVirtualTable(layerObj *layer);
    16051611MS_DLL_EXPORT int msShapeFileLayerInitializeVirtualTable(layerObj *layer);
    16061612MS_DLL_EXPORT int msTiledSHPLayerInitializeVirtualTable(layerObj *layer);
  • mapfile.c

     
    23802380  for (i=0;i<MS_MAXCLASSES;i++) {
    23812381        layer->class[i]=NULL;
    23822382  }
     2383
     2384  layer->layers = NULL;
     2385  layer->numlayers = 0;
    23832386 
    23842387  layer->name = NULL;
    23852388  layer->group = NULL;
     
    24902493//  if (layer->debug)
    24912494//     msDebug("freeLayer(): freeing layer at %p.\n",layer);
    24922495
     2496  if (layer->vtable)
     2497      layer->vtable->LayerDestroy(layer);
     2498
    24932499  msFree(layer->name);
    24942500  msFree(layer->group);
    24952501  msFree(layer->data);
     
    25432549  msFree(layer->joins);
    25442550  layer->numjoins = 0;
    25452551
     2552  for (i=0;i<layer->numlayers;i++) {
     2553      if ( freeLayer(layer->layers[i]) == MS_SUCCESS)
     2554                free(layer->layers[i]);
     2555  }
     2556  if (layer->layers) {
     2557      free(layer->layers);
     2558      layer->layers = NULL;
     2559  }
     2560  layer->numlayers = 0;
     2561
    25462562  return MS_SUCCESS;
    25472563}
    25482564
     
    25802596      if(getString(&layer->connection) == MS_FAILURE) return(-1);
    25812597      break;
    25822598    case(CONNECTIONTYPE):
    2583       if((layer->connectiontype = getSymbol(9, MS_SDE, MS_OGR, MS_POSTGIS, MS_WMS, MS_ORACLESPATIAL, MS_WFS, MS_GRATICULE, MS_MYGIS, MS_PLUGIN)) == -1) return(-1);
     2599      if((layer->connectiontype = getSymbol(12, MS_SDE, MS_OGR, MS_POSTGIS, MS_WMS, MS_ORACLESPATIAL, MS_WFS, MS_GRATICULE, MS_MYGIS, MS_PLUGIN, MS_GEOMTRANS, MS_LAYERFILTER, MS_CACHE)) == -1) return(-1);
    25842600      break;
    25852601    case(DATA):
    25862602      if(getString(&layer->data) == MS_FAILURE) return(-1);
     
    27832799    case(UNITS):
    27842800      if((layer->units = getSymbol(8, MS_INCHES,MS_FEET,MS_MILES,MS_METERS,MS_KILOMETERS,MS_DD,MS_PIXELS,MS_PERCENTAGES)) == -1) return(-1);
    27852801      break;
     2802    case (LAYER):
     2803      if(layer->numlayers == 0)
     2804          layer->layers = (layerObj**) malloc(sizeof(layerObj*));
     2805      else
     2806          layer->layers = (layerObj**) realloc(layer->layers, sizeof(layerObj*) * (layer->numlayers));
     2807      layer->layers[layer->numlayers]=(layerObj*)malloc(sizeof(layerObj));
     2808      if (layer->layers[layer->numlayers] == NULL) {
     2809           msSetError(MS_MEMERR, "Malloc of a new layer failed.", "loadLayer()");
     2810               return MS_FAILURE;
     2811      }
     2812      if(loadLayer(layer->layers[layer->numlayers], map) == -1) return MS_FAILURE;
     2813      layer->layers[layer->numlayers]->index = layer->numlayers; /* save the index */
     2814      ++layer->numlayers;
     2815      break;
    27862816    default:
    27872817      msSetError(MS_IDENTERR, "Parsing error near (%s):(line %d)", "loadLayer()",
    27882818                 msyytext, msyylineno);     
  • maphash.c

     
    3232
    3333MS_CVSID("$Id$")
    3434
    35 static unsigned hash(const char *key)
     35static unsigned hash(const char *key, int hashSize)
    3636{
    3737  unsigned hashval;
    3838 
    3939  for(hashval=0; *key!='\0'; key++)
    4040    hashval = tolower(*key) + 31 * hashval;
    4141
    42   return(hashval % MS_HASHSIZE);
     42  return(hashval % hashSize);
    4343}
    4444
    4545hashTableObj *msCreateHashTable()
     
    4949   
    5050    table = (hashTableObj *) malloc(sizeof(hashTableObj));
    5151    table->items = (struct hashObj **) malloc(sizeof(struct hashObj *)*MS_HASHSIZE);
     52    table->hashSize = MS_HASHSIZE;
    5253   
    5354    for (i=0; i<MS_HASHSIZE; i++)
    5455        table->items[i] = NULL;
     
    5758    return table;
    5859}
    5960
    60 int initHashTable( hashTableObj *table )
     61int initHashTableEx( hashTableObj *table, int hashSize )
    6162{
    6263    int i;
    6364
    64     table->items = (struct hashObj **) malloc(sizeof(struct hashObj *)*MS_HASHSIZE);
     65    table->items = (struct hashObj **) malloc(sizeof(struct hashObj *)*hashSize);
    6566    if (!table->items) {
    6667        msSetError(MS_MEMERR, "Failed to allocate memory for items", "initHashTable");
    6768        return MS_FAILURE;
    6869    }
    69     for (i=0; i<MS_HASHSIZE; i++)
     70    for (i=0; i<hashSize; i++)
    7071        table->items[i] = NULL;
    7172    table->numitems = 0;
     73    table->DestroyData = free;
     74    table->hashSize = hashSize;
    7275    return MS_SUCCESS;
    7376}
    7477
     78int initHashTable( hashTableObj *table )
     79{
     80    return initHashTableEx(table, MS_HASHSIZE);
     81}
     82
    7583void msFreeHashTable( hashTableObj *table )
    7684{
    7785    if( table != NULL )
     
    92100    {
    93101        if (table->items)
    94102        {
    95             for (i=0; i<MS_HASHSIZE; i++)
     103            for (i=0; i<table->hashSize; i++)
    96104            {
    97105                if (table->items[i] != NULL)
    98106                {
     
    101109                         prev_tp=tp,tp=tp->next,free(prev_tp))
    102110                    {
    103111                            free(tp->key);
    104                             free(tp->data);
     112                        table->DestroyData(tp->data);
    105113                    }
    106114                }
    107115                if (tp) free(tp);
     
    120128    }
    121129}
    122130
    123 struct hashObj *msInsertHashTable(hashTableObj *table,
     131void msClearHashItems( hashTableObj *table )
     132{
     133    int i;
     134    struct hashObj *tp=NULL;
     135    struct hashObj *prev_tp=NULL;
     136
     137    if (table)
     138    {
     139        if (table->items)
     140        {
     141            for (i=0; i<table->hashSize; i++)
     142            {
     143                if (table->items[i] != NULL)
     144                {
     145                    for (tp=table->items[i];
     146                         tp!=NULL;
     147                         prev_tp=tp,tp=tp->next,free(prev_tp))
     148                    {
     149                            free(tp->key);
     150                        table->DestroyData(tp->data);
     151                    }
     152                }
     153                if (tp) free(tp);
     154                table->items[i] = NULL;
     155            }
     156        }
     157    }
     158}
     159
     160struct hashObj *msInsertHashTablePtr(hashTableObj *table,
    124161                                  const char *key, const char *value)
    125162{
    126163    struct hashObj *tp;
     
    132169        return NULL;
    133170    }
    134171
    135     for (tp=table->items[hash(key)]; tp!=NULL; tp=tp->next)
     172    for (tp=table->items[hash(key, table->hashSize)]; tp!=NULL; tp=tp->next)
    136173        if(strcasecmp(key, tp->key) == 0)
    137174            break;
    138175
     
    142179            msSetError(MS_HASHERR, "No such hash entry", "msInsertHashTable");
    143180            return NULL;
    144181        }
    145         hashval = hash(key);
     182        hashval = hash(key, table->hashSize);
    146183        tp->next = table->items[hashval];
    147184        table->items[hashval] = tp;
    148185        table->numitems++;
    149186    } else {
    150         free(tp->data);
     187        table->DestroyData(tp->data);
    151188    }
    152189
    153     if ((tp->data = strdup(value)) == NULL)
     190    if ((tp->data = (char*)value) == NULL)
    154191        return NULL;
    155192
    156193    return tp;
    157194}
    158195
     196struct hashObj *msInsertHashTable(hashTableObj *table,
     197                                  const char *key, const char *value)
     198{
     199    return msInsertHashTablePtr(table, key, strdup(value));
     200}
     201
    159202char *msLookupHashTable(hashTableObj *table, const char *key)
    160203{
    161204    struct hashObj *tp;
     
    164207        return(NULL);
    165208    }
    166209
    167     for (tp=table->items[hash(key)]; tp!=NULL; tp=tp->next)
     210    for (tp=table->items[hash(key, table->hashSize)]; tp!=NULL; tp=tp->next)
    168211        if (strcasecmp(key, tp->key) == 0)
    169212            return(tp->data);
    170213
     
    182225        return MS_FAILURE;
    183226    }
    184227 
    185     tp=table->items[hash(key)];
     228    tp=table->items[hash(key, table->hashSize)];
    186229    if (!tp) {
    187230        msSetError(MS_HASHERR, "No such hash entry", "msRemoveHashTable");
    188231        return MS_FAILURE;
     
    193236        if (strcasecmp(key, tp->key) == 0) {
    194237            if (prev_tp) {     
    195238                prev_tp->next = tp->next;
     239                if (tp->key) free(tp->key);
     240                if (tp->data) table->DestroyData(tp->data);
    196241                free(tp);
    197242                break;
    198243            }
    199244            else {
    200                 table->items[hash(key)] = NULL;
     245                table->items[hash(key, table->hashSize)] = NULL;
     246                if (tp->key) free(tp->key);
     247                if (tp->data) table->DestroyData(tp->data);
    201248                free(tp);
    202249                break;
    203250            }
     
    224271        return NULL;
    225272    }
    226273   
    227     for (hash_index = 0; hash_index < MS_HASHSIZE; hash_index++ ) {
     274    for (hash_index = 0; hash_index < table->hashSize; hash_index++ ) {
    228275        if (table->items[hash_index] != NULL )
    229276            return table->items[hash_index]->key;
    230277    }
     
    245292    if ( lastKey == NULL )
    246293        return msFirstKeyFromHashTable( table );
    247294
    248     hash_index = hash(lastKey);
     295    hash_index = hash(lastKey, table->hashSize);
    249296    for ( link = table->items[hash_index];
    250297         link != NULL && strcasecmp(lastKey,link->key) != 0;
    251298         link = link->next ) {}
     
    253300    if ( link != NULL && link->next != NULL )
    254301        return link->next->key;
    255302
    256     while ( ++hash_index < MS_HASHSIZE ) {
     303    while ( ++hash_index < table->hashSize ) {
    257304        if ( table->items[hash_index] != NULL )
    258305            return table->items[hash_index]->key;
    259306    }
     
    261308    return NULL;
    262309}
    263310
     311struct hashObj *msFirstItemFromHashTable( hashTableObj *table)
     312{
     313    int i;
     314
     315    if (!table) {
     316        msSetError(MS_HASHERR, "No hash table", "msFirstItemFromHashTable");
     317        return NULL;
     318    }
     319
     320    for (i=0; i<table->hashSize; i++) {
     321        if (table->items[i])
     322            return table->items[i];
     323    }
     324
     325    return NULL;
     326}
     327
     328struct hashObj *msNextItemFromHashTable( hashTableObj *table, struct hashObj *lastItem )
     329{
     330    int i;
     331
     332    if (!table) {
     333        msSetError(MS_HASHERR, "No hash table", "msNextItemFromHashTable");
     334        return NULL;
     335    }
     336
     337    if ( !lastItem )
     338        return msFirstItemFromHashTable( table );
     339
     340    if (lastItem->next)
     341        return lastItem->next;
     342   
     343    for (i=hash(lastItem->key, table->hashSize)+1; i<table->hashSize; i++) {
     344        if (table->items[i])
     345            return table->items[i];
     346    }
     347
     348    return NULL;
     349}
     350
     351int msGetHashTableItemCount(hashTableObj *table)
     352{
     353    int i, count;
     354    struct hashObj *current;
     355
     356    if (!table) {
     357        msSetError(MS_HASHERR, "No hash table", "msHashTableItemCount");
     358        return 0;
     359    }
     360
     361    count = 0;
     362    for (i=0; i<table->hashSize; i++) {
     363        current = table->items[i];
     364        while(current) {
     365            ++count;
     366            current = current->next;
     367        }
     368    }
     369
     370    return count;
     371}
  • maphash.h

     
    5656typedef struct {
    5757#ifndef SWIG
    5858    struct hashObj **items;  /* the hash table */
     59    void (*DestroyData)(char *data);
     60    int hashSize;
    5961#endif
    6062#ifdef SWIG
    6163%immutable;
     
    142144 */
    143145MS_DLL_EXPORT const char *msNextKeyFromHashTable( hashTableObj *table,
    144146                                                  const char *prevkey );
     147
     148/* msFirstItemFromHashTable - get the first item
     149 * ARGS:
     150 *     table - target hash table
     151 * RETURNS:
     152 *     first item as a hashObj
     153 */
     154MS_DLL_EXPORT struct hashObj *msFirstItemFromHashTable( hashTableObj *table );
     155
     156/* msNextItemFromHashTable - get next item
     157 * ARGS:
     158 *     table - target hash table
     159 *     prevItem - the previous item
     160 * RETURNS:
     161 *     the hashObj of the item of following prevItem hashObj
     162 */
     163MS_DLL_EXPORT struct hashObj *msNextItemFromHashTable( hashTableObj *table,
     164                                                  const struct hashObj *prevItem );
     165
     166/* msGetHashTableItemCount - get item count
     167 * ARGS:
     168 *     table - target hash table
     169 * RETURNS:
     170 *     the count of the items in the hashtable
     171 */
     172MS_DLL_EXPORT int msGetHashTableItemCount(hashTableObj *table);
     173
    145174#endif /*SWIG*/
    146175
    147176#ifdef __cplusplus
  • maplayer.c

     
    10781078    return MS_FAILURE;
    10791079}
    10801080
     1081void
     1082LayerDefaultDestroy(layerObj *layer)
     1083{
     1084}
     1085
    10811086/*
    10821087 * msConnectLayer
    10831088 *
     
    11341139    vtable->LayerCreateItems = LayerDefaultCreateItems;
    11351140   
    11361141    vtable->LayerGetNumFeatures = LayerDefaultGetNumFeatures;
     1142    vtable->LayerDestroy = LayerDefaultDestroy;
    11371143
    11381144    return MS_SUCCESS;
    11391145}
     
    12171223        case(MS_PLUGIN):
    12181224            return(msPluginLayerInitializeVirtualTable(layer));
    12191225            break;
     1226        case(MS_GEOMTRANS):
     1227            return(msGeomTransLayerInitializeVirtualTable(layer));
     1228            break;
     1229        case(MS_LAYERFILTER):
     1230            return(msFilterLayerInitializeVirtualTable(layer));
     1231            break;
     1232        case(MS_CACHE):
     1233            return(msCacheLayerInitializeVirtualTable(layer));
     1234            break;
    12201235        default:
    12211236            msSetError(MS_MISCERR,
    12221237                       "Unknown connectiontype, it was %d",
     
    13321347
    13331348    return MS_SUCCESS;
    13341349}
     1350
     1351layerObj* msGetSubLayer(layerObj *layer, char* path)
     1352{
     1353    int size, i;
     1354   
     1355    if (path == NULL || *path == 0)
     1356        return NULL;
     1357   
     1358    if (path[0] == '/') {
     1359        /* root layer */
     1360        size = 1;
     1361        while (path[size] && path[size] != '/')
     1362            ++size;
     1363        for (i=0; i<layer->map->numlayers; i++) {
     1364            if (layer->map->layers[i] && strncmp(&path[1], layer->map->layers[i]->name, size - 1) == 0) {
     1365                if (path[size] == '/')
     1366                    return msGetSubLayer(layer->map->layers[i], &path[size+1]);
     1367                else
     1368                    return layer->map->layers[i];
     1369            }
     1370        }
     1371    }
     1372    else
     1373    {
     1374        size = 0;
     1375        while (path[size] && path[size] != '/')
     1376            ++size;
     1377        for (i=0; i<layer->numlayers; i++) {
     1378            if (layer->layers[i] && strncmp(path, layer->layers[i]->name, size) == 0) {
     1379                if (path[size] == '/')
     1380                    return msGetSubLayer(layer->layers[i], &path[size+1]);
     1381                else
     1382                    return layer->layers[i];
     1383            }
     1384        }
     1385    }
     1386    return NULL;
     1387}
  • maplexer.l

     
    318318<INITIAL,VALUE_STRING>normal                   { return(MS_NORMAL); }
    319319<INITIAL,VALUE_STRING>off                      { return(MS_OFF); }
    320320<INITIAL,VALUE_STRING>ogr                      { return(MS_OGR); }
     321<INITIAL,VALUE_STRING>geomtrans                { return(MS_GEOMTRANS); }
     322<INITIAL,VALUE_STRING>layerfilter              { return(MS_LAYERFILTER); }
     323<INITIAL,VALUE_STRING>cache                    { return(MS_CACHE); }
    321324<INITIAL,VALUE_STRING>on                       { return(MS_ON); }
    322325<INITIAL,VALUE_STRING>one-to-one               { return(MS_JOIN_ONE_TO_ONE); }
    323326<INITIAL,VALUE_STRING>one-to-many              { return(MS_JOIN_ONE_TO_MANY); }