Up to [Platon] / libplaton / platon / html

Fixed #include directives according to created #include policy.

#ifdef __cplusplus

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <platon/str/strctype.h>
#include <platon/html/Tag.h>

htmlTag::htmlTag(void){
    params=0;
    name=NULL;
    param=value=NULL;
}

htmlTag::~htmlTag(void){
    free();
}

int htmlTag::init(char*s){
    int i=1;
    char*pom;

    if(s[0]!=HTML_TAG_BEGIN)return(-1);
    free();

    while(s[i]==HTML_TAG_SEPARATOR)i++;
    if((name=getString(s+i))==NULL)return(-1);
    if(name[0]!=HTML_TAG_COMMENT)strlwr(name);
    i+=strlen(name);

    while(1){
        while(s[i]==HTML_TAG_SEPARATOR)i++;
        if((pom=getString(s+i))==NULL)break;
        i+=strlen(pom);
        if((param=(char**)realloc(param,sizeof(char*)*(params+1)))==NULL)
            return(-1);
        if((value=(char**)realloc(value,sizeof(char*)*(params+1)))==NULL)
            return(-1);

        param[params]=pom;
        value[params]=strchr(param[params],HTML_TAG_VALUE);
        if(value[params]!=NULL){
            value[params][0]='\0';
            value[params]++;
        }
        else value[params]=strchr(param[params],'\0');
        if(name[0]!=HTML_TAG_COMMENT)strlwr(param[params]);
        params++;
    }
    return(params);
}

void htmlTag::writeToFile(FILE*f){
    int k;
    fputc(HTML_TAG_BEGIN,f);
    fputs(name,f);
    for(k=0;k<params;k++){
        fputc(HTML_TAG_SEPARATOR,f);
        fputs(param[k],f);
        if(strlen(value[k])){
            fputc(HTML_TAG_VALUE,f);
            fputs(value[k],f);
        }
    }
    fputc(HTML_TAG_END,f);
}

int htmlTag::getIndexParam(const char*a_param){
    register int k;
    for(k=0;k<params;k++)if(!strcmp(a_param,param[k]))return(k);
    return(-1);
}

int htmlTag::getIndexValue(const char*a_value){
    register int k;
    for(k=0;k<params;k++)if(!strcmp(a_value,value[k]))return(k);
    return(-1);
}


/*
 * add... methods.
 */

int htmlTag::addParam(const char*a_param){
    return(addParam(a_param,""));
}

int htmlTag::addParam(const char*a_param,const char*a_value){
    /* printf("addParam() start: params=%d\n",params); */
    if(a_param==NULL)return(-1);
    if(a_value==NULL)return(addParam(a_param));

    if((param=(char**)realloc(param,sizeof(char*)*(params+1)))==NULL)return(-1);
    if((value=(char**)realloc(value,sizeof(char*)*(params+1)))==NULL)return(-1);
    param[params]=
        (char*)malloc(sizeof(char)
                      *(strlen(a_param)+1+strlen(a_value)+strlen(a_value)*1));
    if(param[params]==NULL)return(-1);

    strcpy(param[params],a_param);
    if(strlen(a_value)){
        value[params]=strchr(param[params],'\0')+1;
        strcpy(value[params],a_value);
    }
    else value[params]=strchr(param[params],'\0');

    params++;

    /*  printf("addParam() end: params=%d\n",params); */
    return(0);
}

int htmlTag::removeParam(int index){
    register int k;
    if(index>=0&&index<params){
        ::free(param[index]);
        params--;
        for(k=index;k<params;k++){
            param[k]=param[k+1];
            value[k]=value[k+1];
        }
        if(params>0){
            if((param=(char**)realloc(param,sizeof(char*)*params))==NULL)
                return(-1);
            if((value=(char**)realloc(value,sizeof(char*)*params))==NULL)
                return(-1);
        }
        else{
            ::free(param);
            param=NULL;
            ::free(value);
            value=NULL;
        }
    }
    return(0);
}

int htmlTag::removeValue(int index){
    if(index>=0&&index<params){
        param[index]=(char*)realloc(param[index],
                sizeof(char)*(strlen(param[index])+1));
        if(param[index]==NULL)return(-1);
        value[index]=strchr(param[index],'\0');
    }
    return(0);
}

    int htmlTag::removeParam(const char*a_param){
        while(getIndexParam(a_param)>=0)
            if(removeParam(getIndexParam(a_param))<0)return(-1);
        return(0);
    }

    int htmlTag::removeValue(const char*a_value){
        while(getIndexValue(a_value)>=0)
            if(removeValue(getIndexValue(a_value))<0)return(-1);
        return(0);
    }

    int htmlTag::removeValueParam(const char*a_param){
        while(getIndexParam(a_param)>=0)
            if(removeValue(getIndexParam(a_param))<0)return(-1);
        return(0);
    }

void htmlTag::print(void){
    register int k;
    fprintf(stdout,"TAG: %s / PARAMETERS: %d\n",name,params);
    for(k=0;k<params;k++){
        fprintf(stdout,"  %d: %s%c%s\n",k,param[k],HTML_TAG_VALUE,value[k]);
    }
}

/* Private methods. */
void htmlTag::free(void){
    register int k;
    if(name!=NULL)::free(name);
    for(k=0;k<params;k++)if(param[k]!=NULL)::free(param[k]);
    if(param!=NULL)::free(param);
    if(value!=NULL)::free(value);
    params=0;
}

int htmlTag::paramLength(char*s){
    int ret=0;
    if(s[0]==HTML_TAG_COMMENT)ret=strlen(s)-1;
    else{
        while(1){
            if(s[ret]==HTML_TAG_QUOTES)
                while(1){
                    ret++;
                    if(s[ret]==HTML_TAG_QUOTES)break;
                    if(s[ret]=='\0')break;
                }
            if(s[ret]==HTML_TAG_SEPARATOR)break;
            if(s[ret]==HTML_TAG_END)break;
            if(s[ret]=='\0')break;
            ret++;
        }
    }
    return(ret);
}

char*htmlTag::getString(char*s){
    char*ret;
    unsigned len=paramLength(s);

    if(!len)return(NULL);

    if((ret=(char*)malloc(sizeof(char)*(len+1)))!=NULL){
        strncpy(ret,s,len);
        ret[len]='\0';
    }
    return(ret);
}

#endif /* #ifdef __cplusplus */