#include "wwwsys.h"#include "HTUtils.h"#include "HTString.h"#include "HTEscape.h"#include "HTParse.h"#include "CSParse.h"#include "CSUser.h"#include "CSUserSt.h"#define GetCSUser(A) ((A)->target.pCSUser)struct CSUser_s {    CSUserData_t * pCSUserData;    UserService_t * pCurrentUserService;    UserServiceRating_t * pCurrentUserServiceRating;    Range_t * pCurrentRange;    int currentLabelNumber;    UserTargetCallback_t * pUserTargetCallback;    UserErrorHandler_t * pUserErrorHandler;};PRIVATE TargetObject_t User_targetObject;PRIVATE TargetObject_t UserService_targetObject;PRIVATE TargetObject_t UserRatingList_targetObject;PRIVATE TargetObject_t UserRating_targetObject;PRIVATE TargetObject_t UserRange_targetObject;PRIVATE Prep_t User_setTarget;PRIVATE Prep_t clearToken;PRIVATE Check_t getProxy;PRIVATE Check_t getValue;PRIVATE Check_t UserService_getId;PRIVATE Check_t UserRating_getId;PRIVATE Check_t UserRange_get;PRIVATE Open_t User_open;PRIVATE Open_t UserService_open;PRIVATE Open_t UserRating_open;PRIVATE Open_t UserRatingList_open;PRIVATE Open_t UserRange_open;PRIVATE Close_t User_close;PRIVATE Close_t UserService_close;PRIVATE Close_t UserRatingList_close;PRIVATE Close_t UserRating_close;PRIVATE Close_t UserRange_close;PRIVATE Destroy_t User_destroy;PRIVATE Destroy_t UserService_destroy;PRIVATE Destroy_t UserRatingList_destroy;PRIVATE Destroy_t UserRating_destroy;PRIVATE Destroy_t UserRange_destroy;PRIVATE TargetChangeCallback_t targetChangeCallback;PRIVATE ParseErrorHandler_t parseErrorHandler;/* CSParse_doc states *//* U S E R   P A R S E R   S T A T E S *//* This parses the example User profile for the LineMode browser. * See User/Parsing.html for details. */PRIVATE StateToken_t User_stateTokens[] = {     /* A: open or close       B: red open       C: read value        D: read proxy */     {           "start", SubState_N,    Punct_ALL, 0,                  0, 0, 0, &User_targetObject, SubState_A, Command_MATCHANY|Command_OPEN|Command_CHAIN, 0},     {            "open", SubState_A, Punct_LPAREN, 0,                  0, 0, 0, &User_targetObject, SubState_B, 0, 0},     {             "end", SubState_A, Punct_RPAREN, 0,                  0, 0, 0, &User_targetObject, SubState_A, Command_CLOSE, 0},     {         "version", SubState_B,  Punct_WHITE, 0,          "version", 0, 0, &User_targetObject, SubState_C, 0, &User_setTarget},     {       "user-name", SubState_B,  Punct_WHITE, 0,        "user-name", 0, 0, &User_targetObject, SubState_C, 0, &User_setTarget},     {        "password", SubState_B,  Punct_WHITE, 0,         "password", 0, 0, &User_targetObject, SubState_C, 0, &User_setTarget},     {      "super-user", SubState_B,  Punct_WHITE, 0,       "super-user", 0, 0, &User_targetObject, SubState_C, 0, &User_setTarget},     {"minimum-services", SubState_B,  Punct_WHITE, 0, "minimum-services", 0, 0, &User_targetObject, SubState_C, 0, &User_setTarget},     { "missing-service", SubState_B,  Punct_WHITE, 0,  "missing-service", 0, 0, &User_targetObject, SubState_C, 0, &User_setTarget},     {   "missing-scale", SubState_B,  Punct_WHITE, 0,    "missing-scale", 0, 0, &User_targetObject, SubState_C, 0, &User_setTarget},     {   "observe-dates", SubState_B,  Punct_WHITE, 0,    "observe-dates", 0, 0, &User_targetObject, SubState_C, 0, &User_setTarget},     {          "bureau", SubState_B,  Punct_WHITE,0,"bureau","label-bureau", 0, &User_targetObject, SubState_C, 0, &User_setTarget},     {           "proxy", SubState_B,  Punct_WHITE, 0,            "proxy", 0, 0, &User_targetObject, SubState_D, 0, 0},     {  "rating-service", SubState_B,  Punct_WHITE, 0,   "rating-service", 0, 0, &UserService_targetObject, SubState_N, 0, 0},     {       "get value", SubState_C, Punct_RPAREN, &getValue,          0, 0, 0, &User_targetObject, SubState_A, 0, 0},     {       "get proxy", SubState_D, Punct_RPAREN, &getProxy,          0, 0, 0, &User_targetObject, SubState_A, 0, 0}    };PRIVATE TargetObject_t User_targetObject = {"User", &User_open, &User_close, &User_destroy, User_stateTokens, raysize(User_stateTokens), CSUserTC_USER};PRIVATE StateToken_t UserService_stateTokens[] = {     /* A: fresh UserService       B: red id       C: read value        D: need paren before next parm */     {          "start", SubState_N,    Punct_ALL, 0,                  0, 0, 0, &UserService_targetObject, SubState_A, Command_MATCHANY|Command_OPEN|Command_CHAIN, 0},     {  "rating system", SubState_A, Punct_LPAREN, &UserService_getId, 0, 0, 0, &UserService_targetObject, SubState_B, 0, 0},     {        "service", SubState_B,  Punct_WHITE, 0,   "rating-service", 0, 0, &UserService_targetObject, SubState_C, 0, &User_setTarget},     {"missing-service", SubState_B,  Punct_WHITE, 0,  "missing-service", 0, 0, &UserService_targetObject, SubState_C, 0, &User_setTarget},     {  "missing-scale", SubState_B,  Punct_WHITE, 0,    "missing-scale", 0, 0, &UserService_targetObject, SubState_C, 0, &User_setTarget},     {  "observe-dates", SubState_B,  Punct_WHITE, 0,    "observe-dates", 0, 0, &UserService_targetObject, SubState_C, 0, &User_setTarget},     {        "ratings", SubState_B, Punct_LPAREN|Punct_RPAREN,0,"ratings",0,0, &UserRatingList_targetObject, SubState_N, Command_CHAIN, &clearToken},     {      "get value", SubState_C, Punct_RPAREN, &getValue,          0, 0, 0, &UserService_targetObject, SubState_D, 0, 0},     {            "end", SubState_D, Punct_RPAREN, 0,                  0, 0, 0, &User_targetObject, SubState_A, Command_CLOSE, 0},     {      "need open", SubState_D, Punct_LPAREN, 0,                  0, 0, 0, &UserService_targetObject, SubState_B, 0, 0}    };PRIVATE TargetObject_t UserService_targetObject = {"UserService", &UserService_open, &UserService_close, &UserService_destroy, UserService_stateTokens, raysize(UserService_stateTokens), CSUserTC_SERVICE};PRIVATE StateToken_t UserRatingList_stateTokens[] = {     /* A: single state list, expects open or close paren */     {          "start", SubState_N,    Punct_ALL, 0, 0, 0, 0, &UserRatingList_targetObject, SubState_A, Command_MATCHANY|Command_OPEN|Command_CHAIN, 0},     {   "start rating", SubState_A, Punct_LPAREN, 0, 0, 0, 0,     &UserRating_targetObject, SubState_N, 0, 0},     {"end rating list", SubState_A, Punct_RPAREN, 0, 0, 0, 0,    &UserService_targetObject, SubState_D, Command_CLOSE, 0}    };PRIVATE TargetObject_t UserRatingList_targetObject = {"UserRatingList", &UserRatingList_open, &UserRatingList_close, &UserRatingList_destroy, UserRatingList_stateTokens, raysize(UserRatingList_stateTokens), CSUserTC_RLIST};PRIVATE StateToken_t UserRating_stateTokens[] = {     /* A: fresh UserRating       B: red id       C: get value       D: need paren before next parm */     {          "start", SubState_N,    Punct_ALL, 0,                 0, 0, 0, &UserRating_targetObject, SubState_A, Command_MATCHANY|Command_OPEN|Command_CHAIN, 0},     {       "range id", SubState_A, Punct_LPAREN, &UserRating_getId, 0, 0, 0, &UserRating_targetObject, SubState_B, 0, 0},     {  "missing-scale", SubState_B,  Punct_WHITE, 0,   "missing-scale", 0, 0, &UserRating_targetObject, SubState_C, 0, &User_setTarget},     {  "observe-dates", SubState_B,  Punct_WHITE, 0,   "observe-dates", 0, 0, &UserRating_targetObject, SubState_C, 0, &User_setTarget},     {         "ranges", SubState_B,  Punct_WHITE, 0,    "range", "ranges", 0, &UserRange_targetObject, SubState_N, 0, 0},     {      "get value", SubState_C, Punct_RPAREN, &getValue,         0, 0, 0, &UserRating_targetObject, SubState_D, 0, 0},     {     "rating end", SubState_D, Punct_RPAREN, 0,                 0, 0, 0, &UserRatingList_targetObject, SubState_A, Command_CLOSE, 0},     {      "need open", SubState_D, Punct_LPAREN, 0,                 0, 0, 0, &UserRating_targetObject, SubState_B, 0, 0}    };PRIVATE TargetObject_t UserRating_targetObject = {"UserRating", &UserRating_open, &UserRating_close, &UserRating_destroy, UserRating_stateTokens, raysize(UserRating_stateTokens), CSUserTC_RATING};PRIVATE StateToken_t UserRange_stateTokens[] = {     /* A: read ranges */     {      "start", SubState_N,    Punct_ALL,              0, 0, 0, 0, &UserRange_targetObject, SubState_A, Command_MATCHANY|Command_OPEN|Command_CHAIN, 0},     {      "value", SubState_A,  Punct_WHITE, &UserRange_get, 0, 0, 0, &UserRange_targetObject, SubState_A, 0, 0},     {  "value end", SubState_A, Punct_RPAREN, &UserRange_get, 0, 0, 0, &UserRating_targetObject, SubState_D, Command_CLOSE, 0}    };PRIVATE TargetObject_t UserRange_targetObject = {"UserRange", &UserRange_open, &UserRange_close, &UserRange_destroy, UserRange_stateTokens, raysize(UserRange_stateTokens), CSUserTC_RANGE};/* CSParse_doc end *//* S T A T E   A S S O C I A T I O N - associate a CSUser with the label list data    The label list data is kept around until all states referencing it are destroyed */typedef struct {    CSUser_t * pCSUser;    CSUserData_t * pCSUserData;    } CSUserAssoc_t;PRIVATE HTList * CSUserAssocs = 0;PRIVATE void CSUserAssoc_add(CSUser_t * pCSUser, CSUserData_t * pCSUserData){    CSUserAssoc_t * pElement;    if ((pElement = (CSUserAssoc_t *) HT_CALLOC(1, sizeof(CSUserAssoc_t))) == NULL)        HT_OUTOFMEM("CSUserAssoc_t");    pElement->pCSUser = pCSUser;    pElement->pCSUserData = pCSUserData;    if (!CSUserAssocs)        CSUserAssocs = HTList_new();    HTList_appendObject(CSUserAssocs, (void *)pElement);}PRIVATE CSUserAssoc_t * CSUserAssoc_findByData(CSUserData_t * pCSUserData){    HTList * assocs = CSUserAssocs;    CSUserAssoc_t * pElement;    while ((pElement = (CSUserAssoc_t *) HTList_nextObject(assocs)))        if (pElement->pCSUserData == pCSUserData)            return pElement;    return 0;}PRIVATE CSUserAssoc_t * CSUserAssoc_findByState(CSUser_t * pCSUser){    HTList * assocs = CSUserAssocs;    CSUserAssoc_t * pElement;    while ((pElement = (CSUserAssoc_t *) HTList_nextObject(assocs)))        if (pElement->pCSUser == pCSUser)            return pElement;    return 0;}PRIVATE void CSUserAssoc_removeByState(CSUser_t * pCSUser){    CSUserAssoc_t * pElement = CSUserAssoc_findByState(pCSUser);    if (!pElement)        return;    HTList_removeObject(CSUserAssocs, (void *)pElement);    HT_FREE(pElement);}/* C O N S T R U C T O R S / D E S T R U C T O R S */PRIVATE UserServiceRating_t * UserServiceRating_new(void){    UserServiceRating_t * me;    if ((me = (UserServiceRating_t *) HT_CALLOC(1, sizeof(UserServiceRating_t))) == NULL)        HT_OUTOFMEM("UserServiceRating_t");    me->ranges = HTList_new();    return me;}PUBLIC void UserServiceRating_free(UserServiceRating_t * me){    Range_t * pRange;    while ((pRange = (Range_t *) HTList_removeLastObject(me->ranges)))        HT_FREE(pRange);    HTList_delete(me->ranges);    SVal_clear(&me->identifier);    BVal_clear(&me->missing_scale);    BVal_clear(&me->observe_dates);    HT_FREE(me);}PRIVATE UserService_t * UserService_new(void){    UserService_t * me;	if ((me = (UserService_t *) HT_CALLOC(1, sizeof(UserService_t))) == NULL)	    HT_OUTOFMEM("UserService_t");    return me;}PUBLIC void UserService_free(UserService_t * me){    UserServiceRating_t * pUserServiceRating;    while ((pUserServiceRating = (UserServiceRating_t *) HTList_removeLastObject(me->userServiceRatings)))        UserServiceRating_free(pUserServiceRating);    HTList_delete(me->userServiceRatings);    FVal_clear(&me->version);    SVal_clear(&me->rating_system);    SVal_clear(&me->rating_service);    BVal_clear(&me->missing_service);    BVal_clear(&me->missing_scale);    BVal_clear(&me->observe_dates);    HT_FREE(me);}PUBLIC CSUserData_t * CSUserData_new(void){    CSUserData_t * me;    if ((me = (CSUserData_t *) HT_CALLOC(1, sizeof(CSUserData_t))) == NULL)        HT_OUTOFMEM("CSUserData_t");    me->userServices = HTList_new();    me->proxies = HTList_new();    return me;}PUBLIC void CSUserData_free(CSUserData_t * me){    UserService_t * pUserService;    char * proxy;    if (CSUserAssoc_findByData(me))        return;    while ((pUserService = (UserService_t *) HTList_removeLastObject(me->userServices)))        UserService_free(pUserService);    HTList_free(me->userServices);    while ((proxy = (char *) HTList_removeLastObject(me->proxies)))        HT_FREE(proxy);    HTList_free(me->proxies);    FVal_clear(&me->version);    SVal_clear(&me->user_name);    SVal_clear(&me->password);    BVal_clear(&me->super_user);    FVal_clear(&me->minimum_services);    BVal_clear(&me->missing_service);    BVal_clear(&me->missing_scale);    BVal_clear(&me->observe_dates);    SVal_clear(&me->bureau);    HT_FREE(me);}PUBLIC CSUser_t * CSUser_new(CSUserData_t * pCSUserData){    CSUser_t * me;    if ((me = (CSUser_t *) HT_CALLOC(1, sizeof(CSUser_t))) == NULL)        HT_OUTOFMEM("CSUser_t");    me->pCSUserData = pCSUserData;    CSUserAssoc_add(me, pCSUserData);    return me;}PUBLIC CSUser_t * CSUser_copy(CSUser_t * old){    CSUser_t * me;    me = CSUser_new(old->pCSUserData);    memcpy(me, old, sizeof(CSUser_t));    return me;}PUBLIC void CSUser_free(CSUser_t * me){    CSUserData_t * pCSUserData = me->pCSUserData;    CSUserAssoc_removeByState(me);    HT_FREE(me);    CSUserData_free(pCSUserData);}PUBLIC char * CSUser_name(CSUser_t * pCSUser) {return SVal_value(&pCSUser->pCSUserData->user_name);}PUBLIC BOOL CSUser_checkPassword(CSUser_t * pCSUser, char * password) {return strcasecomp(SVal_value(&pCSUser->pCSUserData->password), password) ? NO : YES;}PUBLIC char * CSUser_bureau(CSUser_t * pCSUser) {return SVal_value(&pCSUser->pCSUserData->bureau);}PUBLIC CSUserData_t * CSUser_getCSUserData(CSUser_t * me) {return me->pCSUserData;}PUBLIC UserService_t * CSUser_getUserService(CSUser_t * pCSUser) {return pCSUser->pCurrentUserService;}PUBLIC UserServiceRating_t * CSUser_getUserServiceRating(CSUser_t * pCSUser) {return pCSUser->pCurrentUserServiceRating;}PUBLIC Range_t * CSUser_getUserRatingRange(CSUser_t * pCSUser) {return pCSUser->pCurrentRange;}PUBLIC char * CSUser_getRatingStr(CSUser_t * pCSUser){    HTChunk * pChunk;    HTList * ranges;    Range_t * curRange;    int count = 0;    pChunk = HTChunk_new(20);    ranges = CSUser_getUserServiceRating(pCSUser)->ranges;    while ((curRange = (Range_t *) HTList_nextObject(ranges))) {        char * ptr;	count++;	ptr = Range_toStr(curRange);	if (count > 1)	    HTChunk_puts(pChunk, " ");	HTChunk_puts(pChunk, ptr);	HT_FREE(ptr);    }    return HTChunk_toCString(pChunk);}PUBLIC CSParse_t * CSParse_newUser(){    CSParse_t * me = CSParse_new();    me->pParseContext->engineOf = &CSParse_targetParser;    me->pParseContext->pTargetChangeCallback = &targetChangeCallback;    me->pParseContext->pParseErrorHandler = &parseErrorHandler;    me->target.pCSUser = CSUser_new(CSUserData_new());    me->pTargetObject = &User_targetObject;    me->currentSubState = SubState_N;    return me;}PUBLIC CSUser_t * CSParse_getUser(CSParse_t * me){    return (me->target.pCSUser);}PUBLIC BOOL CSParse_deleteUser(CSParse_t * pCSParse){    CSUser_t * me = GetCSUser(pCSParse);    CSUserData_free(CSUser_getCSUserData(me));    CSUser_free(me);    return YES;}/* P A R S I N G   H A N D L E R S */PRIVATE StateRet_t targetChangeCallback(CSParse_t * pCSParse, TargetObject_t * pTargetObject, CSParseTC_t target, BOOL closed, void * pVoid){    CSUser_t * pCSUser = GetCSUser(pCSParse);    if (pCSUser->pUserTargetCallback)	return (*pCSUser->pUserTargetCallback)(pCSUser, pCSParse, (CSUserTC_t)target, closed, pVoid);    return StateRet_OK;}PRIVATE StateRet_t parseErrorHandler(CSParse_t * pCSParse, const char * token, char demark, StateRet_t errorCode){	CSUser_t * pCSUser = GetCSUser(pCSParse);	if (pCSUser->pUserErrorHandler)		return (*pCSUser->pUserErrorHandler)(pCSUser, pCSParse, token, demark, errorCode);  return errorCode;}/* CSParse_doc methods *//* P A R S I N G   S T A T E   F U N C T I O N S */