/******************************************************************************

* $id: mapfile.c 7854 2008-08-14 19:22:48Z dmorissette $

*

* Project: MapServer

* Purpose: High level Map file parsing code.

* Author: Steve Lime and the MapServer team.

*

******************************************************************************

* Copyright (c) 1996-2005 Regents of the University of Minnesota.

*

* Permission is hereby granted, free of charge, to any person obtaining a

* copy of this software and associated documentation files (the "Software"),

* to deal in the Software without restriction, including without limitation

* the rights to use, copy, modify, merge, publish, distribute, sublicense,

* and/or sell copies of the Software, and to permit persons to whom the

* Software is furnished to do so, subject to the following conditions:

*

* The above copyright notice and this permission notice shall be included in

* all copies of this Software or works derived from this Software.

*

* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS

* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL

* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING

* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER

* DEALINGS IN THE SOFTWARE.

****************************************************************************/

#ifndef _GNU_SOURCE

#define _GNU_SOURCE

#endif

#include <stdarg.h>

#include <assert.h>

#include <ctype.h>

#include <float.h>

#include "mapserver.h"

#include "mapfile.h"

#include "mapthread.h"

#include "maptime.h"

#ifdef USE_GDAL

# include "cpl_conv.h"

# include "gdal.h"

#endif

extern int msyylex(void);

extern void msyyrestart(FILE *);

extern int msyylex_destroy(void);

extern double msyynumber;

extern int msyylineno;

extern FILE *msyyin;

extern int msyysource;

extern int msyystate;

extern char *msyystring;

extern char *msyybasepath;

extern int msyyreturncomments;

extern char *msyystring_buffer;

extern int msyystring_icase;

extern int loadSymbol(symbolObj *s, char *symbolpath); /* in mapsymbol.c */

extern void writeSymbol(symbolObj *s, FILE *stream); /* in mapsymbol.c */

static int loadGrid( layerObj *pLayer );

static int loadStyle(styleObj *style);

static void writeStyle(FILE* stream, int indent, styleObj *style);

static int resolveSymbolNames(mapObj *map);

static int loadExpression(expressionObj *exp);

static void writeExpression(FILE *stream, int indent, const char *name, expressionObj *exp);

/*

** Symbol to string static arrays needed for writing map files.

** Must be kept in sync with enumerations and defines found in mapserver.h.

*/

/* static char *msUnits[9]={"INCHES", "FEET", "MILES", "METERS", "KILOMETERS", "DD", "PIXELS", "PERCENTAGES", "NAUTICALMILES"}; */

/* static char *msLayerTypes[10]={"POINT", "LINE", "POLYGON", "RASTER", "ANNOTATION", "QUERY", "CIRCLE", "TILEINDEX","CHART"}; */

char *msPositionsText[MS_POSITIONS_LENGTH] = {"UL", "LR", "UR", "LL", "CR", "CL", "UC", "LC", "CC", "AUTO", "XY", "FOLLOW"}; /* msLabelPositions[] also used in mapsymbols.c (not static) */

/* static char *msBitmapFontSizes[5]={"TINY", "SMALL", "MEDIUM", "LARGE", "GIANT"}; */

/* static char *msQueryMapStyles[4]={"NORMAL", "HILITE", "SELECTED", "INVERTED"}; */

/* static char *msStatus[4]={"OFF", "ON", "DEFAULT", "EMBED"}; */

/* static char *msOnOff[2]={"OFF", "ON"}; */

/* static char *msTrueFalse[2]={"FALSE", "TRUE"}; */

/* static char *msYesNo[2]={"NO", "YES"}; */

/* static char *msJoinType[2]={"ONE-TO-ONE", "ONE-TO-MANY"}; */

/* static char *msAlignValue[3]={"LEFT","CENTER","RIGHT"}; */

/*

** Validates a string (value) against a series of patterns. We support up to four to allow cascading from classObj to

** layerObj to webObj plus a legacy pattern like TEMPLATEPATTERN.

*/

int msValidateParameter(char *value, char *pattern1, char *pattern2, char *pattern3, char *pattern4)

{

if(msEvalRegex(pattern1, value) == MS_TRUE) return MS_SUCCESS;

if(msEvalRegex(pattern2, value) == MS_TRUE) return MS_SUCCESS;

if(msEvalRegex(pattern3, value) == MS_TRUE) return MS_SUCCESS;

if(msEvalRegex(pattern4, value) == MS_TRUE) return MS_SUCCESS;

return(MS_FAILURE);

}

int msEvalRegex(const char *e, const char *s)

{

ms_regex_t re;

if(!e || !s) return(MS_FALSE);

if(ms_regcomp(&re, e, MS_REG_EXTENDED|MS_REG_NOSUB) != 0) {

msSetError(MS_REGEXERR, "Failed to compile expression (%s).", "msEvalRegex()", e);

return(MS_FALSE);

}

if(ms_regexec(&re, s, 0, NULL, 0) != 0) { /* no match */

ms_regfree(&re);

return(MS_FALSE);

}

ms_regfree(&re);

return(MS_TRUE);

}

#ifdef USE_MSFREE

void msFree(void *p)

{

if(p) free(p);

}

#endif

/*

** Free memory allocated for a character array

*/

void msFreeCharArray(char **array, int num_items)

{

int i;

if(!array) return;

for(i=0; i<num_items; i++)

msFree(array[i]);

msFree(array);

}

/*

** Checks symbol from lexer against variable length list of

** legal symbols.

*/

int getSymbol(int n, ...)

{

int symbol;

va_list argp;

int i=0;

symbol = msyylex();

va_start(argp, n);

while(i<n) { /* check each symbol in the list */

if(symbol == va_arg(argp, int)) {

va_end(argp);

return(symbol);

}

i++;

}

va_end(argp);

msSetError(MS_SYMERR, "Parsing error near (%s):(line %d)", "getSymbol()", msyystring_buffer, msyylineno);

return(-1);

}

/*

** Same as getSymbol, except no error message is set on failure

*/

int getSymbol2(int n, ...)

{

int symbol;

va_list argp;

int i=0;

symbol = msyylex();

va_start(argp, n);

while(i<n) { /* check each symbol in the list */

if(symbol == va_arg(argp, int)) {

va_end(argp);

return(symbol);

}

i++;

}

va_end(argp);

return(-1);

}

/*

** Get a string or symbol as a string. Operates like getString(), but also

** supports symbols.

*/

static char *getToken(void)

{

msyylex();

return msStrdup(msyystring_buffer);

}

/*

** Load a string from the map file. A "string" is defined in lexer.l.

*/

int getString(char **s)

{

/* if (*s)

msSetError(MS_SYMERR, "Duplicate item (%s):(line %d)", "getString()", msyystring_buffer, msyylineno);

return(MS_FAILURE);

} else */

if(msyylex() == MS_STRING) {

if(*s) free(*s); /* avoid leak */

*s = msStrdup(msyystring_buffer);

return(MS_SUCCESS);

}

msSetError(MS_SYMERR, "Parsing error near (%s):(line %d)", "getString()", msyystring_buffer, msyylineno);

return(MS_FAILURE);

}

/*

** Load a floating point number from the map file. (see lexer.l)

*/

int getDouble(double *d)

{

if(msyylex() == MS_NUMBER) {

*d = msyynumber;

return(0); /* success */

}

msSetError(MS_SYMERR, "Parsing error near (%s):(line %d)", "getDouble()", msyystring_buffer, msyylineno);

return(-1);

}

/*

** Load a integer from the map file. (see lexer.l)

*/

int getInteger(int *i)

{

if(msyylex() == MS_NUMBER) {

*i = (int)msyynumber;

return(0); /* success */

}

msSetError(MS_SYMERR, "Parsing error near (%s):(line %d)", "getInteger()", msyystring_buffer, msyylineno);

return(-1);

}

int getCharacter(char *c)

{

if(msyylex() == MS_STRING) {

*c = msyystring_buffer[0];

return(0);

}

msSetError(MS_SYMERR, "Parsing error near (%s):(line %d)", "getCharacter()", msyystring_buffer, msyylineno);

return(-1);

}

/*

** Try to load as an integer, then try as a named symbol.

** Part of work on bug 490.

*/

int getIntegerOrSymbol(int *i, int n, ...)

{

int symbol;

va_list argp;

int j=0;

symbol = msyylex();

if (symbol == MS_NUMBER) {

*i = (int)msyynumber;

return MS_SUCCESS; /* success */

}

va_start(argp, n);

while (j<n) { /* check each symbol in the list */

if(symbol == va_arg(argp, int)) {

va_end(argp);

*i = symbol;

return MS_SUCCESS;

}

j++;

}

va_end(argp);

msSetError(MS_SYMERR, "Parsing error near (%s):(line %d)",

"getIntegerOrSymbol()", msyystring_buffer, msyylineno);

return(-1);

}

/*

** msBuildPluginLibraryPath

**

** This function builds a path to be used dynamically to load plugin library.

*/

int msBuildPluginLibraryPath(char **dest, const char *lib_str, mapObj *map)

{

char szLibPath[MS_MAXPATHLEN] = { '\0' };

char szLibPathExt[MS_MAXPATHLEN] = { '\0' };

const char *plugin_dir = msLookupHashTable( &(map->configoptions), "MS_PLUGIN_DIR");

/* do nothing on windows, filename without .dll will be loaded by default*/

#if !defined(_WIN32)

if (lib_str) {

size_t len = strlen(lib_str);

if (3 < len && strcmp(lib_str + len-3, ".so")) {

strlcpy(szLibPathExt, lib_str, MS_MAXPATHLEN);

strlcat(szLibPathExt, ".so", MS_MAXPATHLEN);

lib_str = szLibPathExt;

}

}

#endif /* !defined(_WIN32) */

if (NULL == msBuildPath(szLibPath, plugin_dir, lib_str)) {

return MS_FAILURE;

}

*dest = msStrdup(szLibPath);

return MS_SUCCESS;

}

/*

** Returns the index of specified symbol or -1 if not found.

**

** If try_addimage_if_notfound==MS_TRUE then msAddImageSymbol() will be called

** to try to allocate the symbol as an image symbol.

*/

int msGetSymbolIndex(symbolSetObj *symbols, char *name, int try_addimage_if_notfound)

{

int i;

if(!symbols || !name) return(-1);

/* symbol 0 has no name */

for(i=1; i<symbols->numsymbols; i++) {

if(symbols->symbol[i]->name)

if(strcasecmp(symbols->symbol[i]->name, name) == 0) return(i);

}

if (try_addimage_if_notfound)

return(msAddImageSymbol(symbols, name)); /* make sure it's not a filename */

return(-1);

}

/*

** Return the index number for a given layer based on its name.

*/

int msGetLayerIndex(mapObj *map, const char *name)

{

int i;

if(!name) return(-1);

for(i=0; i<map->numlayers; i++) {

if(!GET_LAYER(map, i)->name) /* skip it */

continue;

if(strcmp(name, GET_LAYER(map, i)->name) == 0)

return(i);

}

return(-1);

}

static

int msGetClassIndex(layerObj *layer, const char *name)

{

int i;

if(!name) return(-1);

for(i=0; i<layer->numclasses; i++) {

if(!layer->class[i]->name) /* skip it */

continue;

if(strcmp(name, layer->class[i]->name) == 0)

return(i);

}

return(-1);

}

int loadColor(colorObj *color, attributeBindingObj *binding)

{

int symbol;

char hex[2];

if(binding) {

if((symbol = getSymbol(3, MS_NUMBER, MS_BINDING, MS_STRING)) == -1) return MS_FAILURE;

} else {

if((symbol = getSymbol(2, MS_NUMBER, MS_STRING)) == -1) return MS_FAILURE;

}

color->alpha=255;

if(symbol == MS_NUMBER) {

color->red = (int) msyynumber;

if(getInteger(&(color->green)) == -1) return MS_FAILURE;

if(getInteger(&(color->blue)) == -1) return MS_FAILURE;

} else if(symbol == MS_STRING) {

int len = strlen(msyystring_buffer);

if(msyystring_buffer[0] == '#' && (len == 7 || len == 9)) { /* got a hex color w/optional alpha */

hex[0] = msyystring_buffer[1];

hex[1] = msyystring_buffer[2];

color->red = msHexToInt(hex);

hex[0] = msyystring_buffer[3];

hex[1] = msyystring_buffer[4];

color->green = msHexToInt(hex);

hex[0] = msyystring_buffer[5];

hex[1] = msyystring_buffer[6];

color->blue = msHexToInt(hex);

if(len == 9) {

hex[0] = msyystring_buffer[7];

hex[1] = msyystring_buffer[8];

color->alpha = msHexToInt(hex);

}

} else {

/* TODO: consider named colors here */

msSetError(MS_SYMERR, "Invalid hex color (%s):(line %d)", "loadColor()", msyystring_buffer, msyylineno);

return MS_FAILURE;

}

} else {

binding->item = msStrdup(msyystring_buffer);

binding->index = -1;

}

return MS_SUCCESS;

}

#if ALPHACOLOR_ENABLED

int loadColorWithAlpha(colorObj *color)

{

char hex[2];

if(getInteger(&(color->red)) == -1) {

if(msyystring_buffer[0] == '#' && strlen(msyystring_buffer) == 7) { /* got a hex color */

hex[0] = msyystring_buffer[1];

hex[1] = msyystring_buffer[2];

color->red = msHexToInt(hex);

hex[0] = msyystring_buffer[3];

hex[1] = msyystring_buffer[4];

color->green = msHexToInt(hex);

hex[0] = msyystring_buffer[5];

hex[1] = msyystring_buffer[6];

color->blue = msHexToInt(hex);

color->alpha = 0;

return(MS_SUCCESS);

} else if(msyystring_buffer[0] == '#' && strlen(msyystring_buffer) == 9) { /* got a hex color with alpha */

hex[0] = msyystring_buffer[1];

hex[1] = msyystring_buffer[2];

color->red = msHexToInt(hex);

hex[0] = msyystring_buffer[3];

hex[1] = msyystring_buffer[4];

color->green = msHexToInt(hex);

hex[0] = msyystring_buffer[5];

hex[1] = msyystring_buffer[6];

color->blue = msHexToInt(hex);

hex[0] = msyystring_buffer[7];

hex[1] = msyystring_buffer[8];

color->alpha = msHexToInt(hex);

return(MS_SUCCESS);

}

return(MS_FAILURE);

}

if(getInteger(&(color->green)) == -1) return(MS_FAILURE);

if(getInteger(&(color->blue)) == -1) return(MS_FAILURE);

if(getInteger(&(color->alpha)) == -1) return(MS_FAILURE);

return(MS_SUCCESS);

}

#endif

/*

** Helper functions for writing mapfiles.

*/

static void writeLineFeed(FILE *stream)

{

msIO_fprintf(stream, "\n");

}

static void writeIndent(FILE *stream, int indent)

{

const char *str=" "; /* change this string to define the indent */

int i;

for(i=0; i<indent; i++) msIO_fprintf(stream, "%s", str);

}

static void writeBlockBegin(FILE *stream, int indent, const char *name)

{

writeIndent(stream, indent);

msIO_fprintf(stream, "%s\n", name);

}

static void writeBlockEnd(FILE *stream, int indent, const char *name)

{

writeIndent(stream, indent);

msIO_fprintf(stream, "END # %s\n", name);

}

static void writeKeyword(FILE *stream, int indent, const char *name, int value, int size, ...)

{

va_list argp;

int i, j=0;

const char *s;

va_start(argp, size);

while (j<size) { /* check each value/keyword mapping in the list, values with no match are ignored */

i = va_arg(argp, int);

s = va_arg(argp, const char *);

if(value == i) {

writeIndent(stream, ++indent);

msIO_fprintf(stream, "%s %s\n", name, s);

va_end(argp);

return;

}

j++;

}

va_end(argp);

}

static void writeDimension(FILE *stream, int indent, const char *name, int x, int y, char *bind_x, char *bind_y)

{

writeIndent(stream, ++indent);

if(bind_x) msIO_fprintf(stream, "%s [%s] ", name, bind_x);

else msIO_fprintf(stream, "%s %d ", name, x);

if(bind_y) msIO_fprintf(stream, "[%s]\n", bind_y);

else msIO_fprintf(stream, "%d\n", y);

}

static void writeDoubleRange(FILE *stream, int indent, const char *name, double x, double y)

{

writeIndent(stream, ++indent);

msIO_fprintf(stream, "%s %f %f\n", name, x, y);

}

static void writeExtent(FILE *stream, int indent, const char *name, rectObj extent)

{

if(!MS_VALID_EXTENT(extent)) return;

writeIndent(stream, ++indent);

msIO_fprintf(stream, "%s %.15g %.15g %.15g %.15g\n", name, extent.minx, extent.miny, extent.maxx, extent.maxy);

}

static void writeNumber(FILE *stream, int indent, const char *name, double defaultNumber, double number)

{

if(number == defaultNumber) return; /* don't output default */

writeIndent(stream, ++indent);

msIO_fprintf(stream, "%s %.15g\n", name, number);

}

static void writeCharacter(FILE *stream, int indent, const char *name, const char defaultCharacter, char character)

{

if(defaultCharacter == character) return;

writeIndent(stream, ++indent);

msIO_fprintf(stream, "%s '%c'\n", name, character);

}

static void writeStringElement(FILE *stream, char *string)

{

char *string_escaped;

if(strchr(string,'\\')) {

string_escaped = msStrdup(string);

string_escaped = msReplaceSubstring(string_escaped,"\\","\\\\");

} else {

string_escaped = string;

}

if ( (strchr(string_escaped, '\'') == NULL) && (strchr(string_escaped, '\"') == NULL))

msIO_fprintf(stream, "\"%s\"", string_escaped);

else if ( (strchr(string_escaped, '\"') != NULL) && (strchr(string_escaped, '\'') == NULL))

msIO_fprintf(stream, "'%s'", string_escaped);

else if ( (strchr(string_escaped, '\'') != NULL) && (strchr(string_escaped, '\"') == NULL))

msIO_fprintf(stream, "\"%s\"", string_escaped);

else {

char *string_tmp = msStringEscape(string_escaped);

msIO_fprintf(stream, "\"%s\"", string_tmp);

if(string_escaped!=string_tmp) free(string_tmp);

}

if(string_escaped!=string) free(string_escaped);

}

static void writeString(FILE *stream, int indent, const char *name, const char *defaultString, char *string)

{

if(!string) return;

if(defaultString && strcmp(string, defaultString) == 0) return;

writeIndent(stream, ++indent);

if(name) msIO_fprintf(stream, "%s ", name);

writeStringElement(stream, string);

writeLineFeed(stream);

}

static void writeNumberOrString(FILE *stream, int indent, const char *name, double defaultNumber, double number, char *string)

{

if(string)

writeString(stream, indent, name, NULL, string);

else

writeNumber(stream, indent, name, defaultNumber, number);

}

static void writeNumberOrKeyword(FILE *stream, int indent, const char *name, double defaultNumber, double number, int value, int size, ...)

{

va_list argp;

int i, j=0;

const char *s;

va_start(argp, size);

while (j<size) { /* check each value/keyword mapping in the list */

i = va_arg(argp, int);

s = va_arg(argp, const char *);

if(value == i) {

writeIndent(stream, ++indent);

msIO_fprintf(stream, "%s %s\n", name, s);

va_end(argp);

return;

}

j++;

}

va_end(argp);

writeNumber(stream, indent, name, defaultNumber, number);

}

static void writeNameValuePair(FILE *stream, int indent, const char *name, const char *value)

{

if(!name || !value) return;

writeIndent(stream, ++indent);

writeStringElement(stream, (char*)name);

msIO_fprintf(stream,"\t");

writeStringElement(stream, (char*)value);

writeLineFeed(stream);

}

static void writeAttributeBinding(FILE *stream, int indent, const char *name, attributeBindingObj *binding)

{

if(!binding || !binding->item) return;

writeIndent(stream, ++indent);

msIO_fprintf(stream, "%s [%s]\n", name, binding->item);

}

static void writeColor(FILE *stream, int indent, const char *name, colorObj *defaultColor, colorObj *color)

{

if (!defaultColor && !MS_VALID_COLOR(*color)) return;

else if(defaultColor && MS_COMPARE_COLOR(*defaultColor, *color)) return; /* if defaultColor has the same value than the color, return.*/

writeIndent(stream, ++indent);

#if ALPHACOLOR_ENABLED

msIO_fprintf(stream, "%s %d %d %d\n", name, color->red, color->green, color->blue, color->alpha);

#else

if(color->alpha != 255) {

char buffer[9];

sprintf(buffer, "%02x", color->red);

sprintf(buffer+2, "%02x", color->green);

sprintf(buffer+4, "%02x", color->blue);

sprintf(buffer+6, "%02x", color->alpha);

*(buffer+8) = 0;

msIO_fprintf(stream, "%s \"#%s\"\n", name, buffer);

} else {

msIO_fprintf(stream, "%s %d %d %d\n", name, color->red, color->green, color->blue);

}

#endif

}

/* todo: deal with alpha's... */

static void writeColorRange(FILE *stream, int indent, const char *name, colorObj *mincolor, colorObj *maxcolor)

{

if(!MS_VALID_COLOR(*mincolor) || !MS_VALID_COLOR(*maxcolor)) return;

writeIndent(stream, ++indent);

msIO_fprintf(stream, "%s %d %d %d %d %d %d\n", name, mincolor->red, mincolor->green, mincolor->blue, maxcolor->red, maxcolor->green, maxcolor->blue);

}

/*

** Initialize, load and free a single join

*/

void initJoin(joinObj *join)

{

join->numitems = 0;

join->name = NULL; /* unique join name, used for variable substitution */

join->items = NULL; /* array to hold item names for the joined table */

join->values = NULL; /* arrays of strings to holds one record worth of data */

join->table = NULL;

join->joininfo = NULL;

join->from = NULL; /* join items */

join->to = NULL;

join->header = NULL;

join->template = NULL; /* only html type templates are supported */

join->footer = NULL;

join->type = MS_JOIN_ONE_TO_ONE;

join->connection = NULL;

join->connectiontype = MS_DB_XBASE;

}

void freeJoin(joinObj *join)

{

msFree(join->name);

msFree(join->table);

msFree(join->from);

msFree(join->to);

msFree(join->header);

msFree(join->template);

msFree(join->footer);

msFreeCharArray(join->items, join->numitems); /* these may have been free'd elsewhere */

msFreeCharArray(join->values, join->numitems);

join->numitems = 0;

msJoinClose(join);

msFree(join->connection);

}

int loadJoin(joinObj *join)

{

int nTmp;

initJoin(join);

for(;;) {

switch(msyylex()) {

case(CONNECTION):

if(getString(&join->connection) == MS_FAILURE) return(-1);

break;

case(CONNECTIONTYPE):

if((nTmp = getSymbol(5, MS_DB_XBASE, MS_DB_MYSQL, MS_DB_ORACLE, MS_DB_POSTGRES, MS_DB_CSV)) == -1) return(-1);

join->connectiontype = nTmp;

break;

case(EOF):

msSetError(MS_EOFERR, NULL, "loadJoin()");

return(-1);

case(END):

if((join->from == NULL) || (join->to == NULL) || (join->table == NULL)) {

msSetError(MS_EOFERR, "Join must define table, name, from and to properties.", "loadJoin()");

return(-1);

}

if((join->type == MS_MULTIPLE) && ((join->template == NULL) || (join->name == NULL))) {

msSetError(MS_EOFERR, "One-to-many joins must define template and name properties.", "loadJoin()");

return(-1);

}

return(0);

case(FOOTER):

if(getString(&join->footer) == MS_FAILURE) return(-1);

break;

case(FROM):

if(getString(&join->from) == MS_FAILURE) return(-1);

break;

case(HEADER):

if(getString(&join->header) == MS_FAILURE) return(-1);

break;

case(JOIN):

break; /* for string loads */

case(NAME):

if(getString(&join->name) == MS_FAILURE) return(-1);

break;

case(TABLE):

if(getString(&join->table) == MS_FAILURE) return(-1);

break;

case(TEMPLATE):

if(getString(&join->template) == MS_FAILURE) return(-1);

break;

case(TO):

if(getString(&join->to) == MS_FAILURE) return(-1);

break;

case(TYPE):

if((nTmp = getSymbol(2, MS_JOIN_ONE_TO_ONE, MS_JOIN_ONE_TO_MANY)) == -1) return(-1);

join->type = nTmp;

break;

default:

msSetError(MS_IDENTERR, "Parsing error near (%s):(line %d)", "loadJoin()", msyystring_buffer, msyylineno);

return(-1);

}

} /* next token */

}

static void writeScaleToken(FILE *stream, int indent, scaleTokenObj *token) {

int i;

indent++;

writeBlockBegin(stream,indent,"SCALETOKEN");

writeString(stream, indent, "NAME", NULL, token->name);

indent++;

writeBlockBegin(stream,indent,"VALUES");

for(i=0;i<token->n_entries;i++) {

char minscale[32];

sprintf(minscale,"%g",token->tokens[i].minscale);

writeNameValuePair(stream, indent, minscale, token->tokens[i].value);

}

writeBlockEnd(stream,indent,"VALUES");

indent--;

writeBlockEnd(stream,indent,"SCALETOKEN");

}

static void writeJoin(FILE *stream, int indent, joinObj *join)

{

indent++;

writeBlockBegin(stream, indent, "JOIN");

writeString(stream, indent, "FOOTER", NULL, join->footer);

writeString(stream, indent, "FROM", NULL, join->from);

writeString(stream, indent, "HEADER", NULL, join->header);

writeString(stream, indent, "NAME", NULL, join->name);

writeString(stream, indent, "TABLE", NULL, join->table);

writeString(stream, indent, "TEMPLATE", NULL, join->template);

writeString(stream, indent, "TO", NULL, join->to);

writeKeyword(stream, indent, "CONNECTIONTYPE", join->connectiontype, 3, MS_DB_CSV, "CSV", MS_DB_POSTGRES, "POSTRESQL", MS_DB_MYSQL, "MYSQL");

writeKeyword(stream, indent, "TYPE", join->type, 1, MS_JOIN_ONE_TO_MANY, "ONE-TO-MANY");

writeBlockEnd(stream, indent, "JOIN");

}

/* inserts a feature at the end of the list, can create a new list */

featureListNodeObjPtr insertFeatureList(featureListNodeObjPtr *list, shapeObj *shape)

{

featureListNodeObjPtr node;

node = (featureListNodeObjPtr) msSmallMalloc(sizeof(featureListNodeObj));

msInitShape(&(node->shape));

if(msCopyShape(shape, &(node->shape)) == -1) {

msFree(node);

return(NULL);

}

/* AJS - alans@wunderground.com O(n^2) -> O(n) conversion, keep a pointer to the end */

/* set the tailifhead to NULL, since it is only set for the head of the list */

node->tailifhead = NULL;

node->next = NULL;

/* if we are at the head of the list, we need to set the list to node, before pointing tailifhead somewhere */

if(*list == NULL) {

*list=node;

} else {

if((*list)->tailifhead!=NULL) /* this should never be NULL, but just in case */

(*list)->tailifhead->next=node; /* put the node at the end of the list */

}

/* repoint the head of the list to the end - our new element

this causes a loop if we are at the head, be careful not to

walk in a loop */

(*list)->tailifhead = node;

return(node); /* a pointer to last object in the list */

}

void freeFeatureList(featureListNodeObjPtr list)

{

featureListNodeObjPtr listNext = NULL;

while (list!=NULL) {

listNext = list->next;

msFreeShape(&(list->shape));

msFree(list);

list = listNext;

}

}

/* lineObj = multipointObj */

static int loadFeaturePoints(lineObj *points)

{

int buffer_size=0;

points->point = (pointObj *)malloc(sizeof(pointObj)*MS_FEATUREINITSIZE);

MS_CHECK_ALLOC(points->point, sizeof(pointObj)*MS_FEATUREINITSIZE, MS_FAILURE);

points->numpoints = 0;

buffer_size = MS_FEATUREINITSIZE;

for(;;) {

switch(msyylex()) {

case(EOF):

msSetError(MS_EOFERR, NULL, "loadFeaturePoints()");

return(MS_FAILURE);

case(END):

return(MS_SUCCESS);

case(MS_NUMBER):

if(points->numpoints == buffer_size) { /* just add it to the end */

points->point = (pointObj *) realloc(points->point, sizeof(pointObj)*(buffer_size+MS_FEATUREINCREMENT));

MS_CHECK_ALLOC(points->point, sizeof(pointObj)*(buffer_size+MS_FEATUREINCREMENT), MS_FAILURE);

buffer_size+=MS_FEATUREINCREMENT;

}

points->point[points->numpoints].x = atof(msyystring_buffer);

if(getDouble(&(points->point[points->numpoints].y)) == -1) return(MS_FAILURE);

points->numpoints++;

break;

default:

msSetError(MS_IDENTERR, "Parsing error near (%s):(line %d)", "loadFeaturePoints()", msyystring_buffer, msyylineno );

return(MS_FAILURE);

}

}

}

static int loadFeature(layerObj *player, int type)

{

int status=MS_SUCCESS;

featureListNodeObjPtr *list = &(player->features);

multipointObj points= {0,NULL};

shapeObj *shape=NULL;

shape = (shapeObj *) malloc(sizeof(shapeObj));

MS_CHECK_ALLOC(shape, sizeof(shapeObj), MS_FAILURE);

msInitShape(shape);

shape->type = type;

for(;;) {

switch(msyylex()) {

case(EOF):

msSetError(MS_EOFERR, NULL, "loadFeature()");

msFreeShape(shape); /* clean up */

msFree(shape);

return(MS_FAILURE);

case(END):

if(player->features != NULL && player->features->tailifhead != NULL)

shape->index = player->features->tailifhead->shape.index + 1;

else

shape->index = 0;

if(insertFeatureList(list, shape) == NULL)

status = MS_FAILURE;

msFreeShape(shape); /* clean up */

msFree(shape);

return(status);

case(FEATURE):

break; /* for string loads */

case(POINTS):

if(loadFeaturePoints(&points) == MS_FAILURE) {

msFreeShape(shape); /* clean up */

msFree(shape);

return(MS_FAILURE);

}

status = msAddLine(shape, &points);

msFree(points.point); /* clean up */

points.numpoints = 0;

if(status == MS_FAILURE) {

msFreeShape(shape); /* clean up */

msFree(shape);

return(MS_FAILURE);

}

break;

case(ITEMS): {

char *string=NULL;

if(getString(&string) == MS_FAILURE) {

msFreeShape(shape); /* clean up */

msFree(shape);

return(MS_FAILURE);

}

if (string) {

if(shape->values) msFreeCharArray(shape->values, shape->numvalues);

shape->values = msStringSplitComplex(string, ";", &shape->numvalues,MS_ALLOWEMPTYTOKENS);

msFree(string); /* clean up */

}

break;

}

case(TEXT):

if(getString(&shape->text) == MS_FAILURE) {

msFreeShape(shape); /* clean up */

msFree(shape);

return(MS_FAILURE);

}

break;

case(WKT): {

char *string=NULL;

/* todo, what do we do with multiple WKT property occurances? */

msFreeShape(shape);

msFree(shape);

if(getString(&string) == MS_FAILURE) return(MS_FAILURE);

if((shape = msShapeFromWKT(string)) == NULL)

status = MS_FAILURE;

msFree(string); /* clean up */

if(status == MS_FAILURE) {

msFreeShape(shape); /* clean up */

msFree(shape);

return(MS_FAILURE);

}

break;

}

default:

msSetError(MS_IDENTERR, "Parsing error near (%s):(line %d)", "loadfeature()", msyystring_buffer, msyylineno);

msFreeShape(shape); /* clean up */

msFree(shape);

return(MS_FAILURE);

}

} /* next token */

}