--- /dev/null
+/*
+ * @copyright Copyright (c) 2016-2020 TOYOTA MOTOR CORPORATION.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <string.h>
+#include <unistd.h>
+#include <errno.h>
+#include <libgen.h>
+
+#include <expat.h>
+
+#define BUFSIZE 4096
+#define OUTFILE "tskm_auto_build.h"
+#define TMPFILE "parsexml.tmp"
+
+typedef uint32_t ELE_STATE_t;
+#define ELE_NONE 0x00000000U
+#define ELE_TSKM_CFG 0x10000000U
+#define ELE_SERVICE_LIST 0x11000000U
+#define ELE_SERVICE 0x11100000U
+#define ELE_SUBGID_LIST 0x11110000U
+
+#define ELE_COMMON_GSTEP 0x00100000U
+#define ELE_COMMON_EXEC 0x00010000U
+#define ELE_COMMON_REQ 0x00020000U
+
+#define ELE_NORMAL_WAKEUP 0x12000000U
+#define ELE_NORMAL_W_GSTEP (ELE_NORMAL_WAKEUP|ELE_COMMON_GSTEP)
+#define ELE_NORMAL_W_EXEC (ELE_NORMAL_WAKEUP|ELE_COMMON_GSTEP|ELE_COMMON_EXEC)
+#define ELE_NORMAL_W_REQ (ELE_NORMAL_WAKEUP|ELE_COMMON_GSTEP|ELE_COMMON_REQ)
+
+#define ELE_NORMAL_SHUTDOWN 0x13000000U
+#define ELE_NORMAL_D_GSTEP (ELE_NORMAL_SHUTDOWN|ELE_COMMON_GSTEP)
+#define ELE_NORMAL_D_REQ (ELE_NORMAL_SHUTDOWN|ELE_COMMON_GSTEP|ELE_COMMON_REQ)
+
+#define ELE_VUP_WAKEUP 0x14000000U
+#define ELE_VUP_W_GSTEP (ELE_VUP_WAKEUP|ELE_COMMON_GSTEP)
+#define ELE_VUP_W_EXEC (ELE_VUP_WAKEUP|ELE_COMMON_GSTEP|ELE_COMMON_EXEC)
+#define ELE_VUP_W_REQ (ELE_VUP_WAKEUP|ELE_COMMON_GSTEP|ELE_COMMON_REQ)
+
+#define ELE_VUP_SHUTDOWN 0x15000000U
+#define ELE_VUP_D_GSTEP (ELE_VUP_SHUTDOWN|ELE_COMMON_GSTEP)
+#define ELE_VUP_D_REQ (ELE_VUP_SHUTDOWN|ELE_COMMON_GSTEP|ELE_COMMON_REQ)
+
+
+#define ELE_MASK0 0xF0000000U
+#define ELE_MASK1 0x0F000000U
+#define ELE_MASK2 0x00F00000U
+#define ELE_MASK3 0x000F0000U
+
+#define PARSE_ASSERT_EXIT(x) \
+ if(!(x)){ \
+ printf("ASSERT %s:%s:%d\n",__FILE__,__FUNCTION__,__LINE__); \
+ exit(-1); \
+ }
+
+#define VALUE_NAME_MAX 255
+typedef struct {
+ int step;
+ char gstepIdStr[VALUE_NAME_MAX];
+ int execSvcNum;
+ int reqNum;
+ char nextStepCondStr[VALUE_NAME_MAX];
+ char execSvcName[VALUE_NAME_MAX];
+ char reqTableName[VALUE_NAME_MAX];
+} PARSE_GSTEP_t;
+
+
+typedef struct {
+ char svcid[VALUE_NAME_MAX];
+ char name[VALUE_NAME_MAX];
+ char path[VALUE_NAME_MAX];
+ char type[VALUE_NAME_MAX];
+ char life_cycle[VALUE_NAME_MAX];
+ char retry_cnt[VALUE_NAME_MAX];
+ char cpu_assign[VALUE_NAME_MAX];
+ char prio[VALUE_NAME_MAX];
+ char policy[VALUE_NAME_MAX];
+ char user[VALUE_NAME_MAX];
+ char runtime_limit[VALUE_NAME_MAX];
+ char cpu_limit[VALUE_NAME_MAX];
+ char mem_limit[VALUE_NAME_MAX];
+ int subgidNum;
+ char args[VALUE_NAME_MAX];
+ char shutdown_wait[VALUE_NAME_MAX];
+} PARSE_SVC_t;
+
+/***************************************
+ * Context
+ **************************************/
+typedef struct {
+ FILE* fp; // Output file pointer
+ FILE* tmpFp; // Temporary file
+ ELE_STATE_t state;
+
+ PARSE_SVC_t svc;
+
+ int svcNum; // Number of services
+ PARSE_GSTEP_t gstep;
+} PARSE_CTX_t;
+
+
+/***************************************
+ * entryTskmCfg
+ **************************************/
+void
+entryTskmCfg(PARSE_CTX_t* p_ctx,const XML_Char* atts[]) {
+ p_ctx->state = ELE_TSKM_CFG;
+}
+
+/***************************************
+ * exitTskmCfg
+ **************************************/
+void
+exitTskmCfg(PARSE_CTX_t* p_ctx) {
+ p_ctx->state = ELE_NONE;
+}
+
+
+/***************************************
+ * entryServiceList
+ **************************************/
+void
+entryServiceList(PARSE_CTX_t* p_ctx,const XML_Char* atts[]) {
+ p_ctx->state = ELE_SERVICE_LIST;
+
+ p_ctx->tmpFp = fopen(TMPFILE,"w");
+
+ fprintf(p_ctx->tmpFp,
+ "static TSKM_SVC_ATTR_t serviceAttr[]={"
+ "\n");
+}
+
+/***************************************
+ * exitServiceList
+ **************************************/
+void
+exitServiceList(PARSE_CTX_t* p_ctx) {
+ fprintf(p_ctx->tmpFp,
+ "};"
+ "\n\n");
+
+ fprintf(p_ctx->tmpFp, "#define TSKM_SVC_NUM (%d) \n\n",p_ctx->svcNum);
+
+ fprintf(p_ctx->tmpFp, "static TSKM_SVC_CTX_t serviceList[TSKM_SVC_NUM]; \n\n");
+
+ fclose(p_ctx->tmpFp);
+
+ fprintf(p_ctx->fp,"\n\n");
+
+ p_ctx->state = ELE_TSKM_CFG;
+}
+
+/***************************************
+ * handleServiceList
+ **************************************/
+void
+entryService(PARSE_CTX_t* p_ctx,const XML_Char *name,const XML_Char* atts[]) {
+ PARSE_ASSERT_EXIT(strcmp(name,"service") == 0);
+ int ii;
+ char* tp;
+ p_ctx->state = ELE_SERVICE;
+
+ memset(&p_ctx->svc,0,sizeof(p_ctx->svc));
+
+ for(ii=0; atts[ii]; ii+=2) {
+ const char* attr = atts[ii];
+ const char* value = atts[ii+1];
+ if(strcmp(attr,"svcid")==0) {
+ strcpy(p_ctx->svc.svcid,value);
+ } else if(strcmp(attr,"name")==0) {
+ strcpy(p_ctx->svc.name,value);
+ } else if(strcmp(attr,"path")==0) {
+ strcpy(p_ctx->svc.path,value);
+ } else if(strcmp(attr,"type")==0) {
+ const char* typeName = (strcmp(value,"native")==0) ? "TSKM_SVC_TYPE_NATIVE" : "TSKM_SVC_TYPE_UNKNONW";
+ strcpy(p_ctx->svc.type,typeName);
+ } else if(strcmp(attr,"prio")==0) {
+ strcpy(p_ctx->svc.prio,value);
+ } else if(strcmp(attr,"policy")==0) {
+ const char* polName = (strcmp(value,"fifo")==0) ? "TSKM_SVC_POLICY_FIFO" :
+ (strcmp(value,"tss")==0) ? "TSKM_SVC_POLICY_TSS" :
+ (strcmp(value,"rr")==0) ? "TSKM_SVC_POLICY_RR" : "ERROR";
+ strcpy(p_ctx->svc.policy,polName);
+ } else if(strcmp(attr,"life_cycle")==0) {
+ const char* lcName = (strcmp(value,"always")==0) ? "TSKM_SVC_LC_ALWAYS" :
+ (strcmp(value,"always_recoverable")==0) ? "TSKM_SVC_LC_ALWAYS_RECOVERABLE" :
+ (strcmp(value,"dynamic")==0) ? "TSKM_SVC_LC_DYNAMIC" : "ERROR";
+ strcpy(p_ctx->svc.life_cycle,lcName);
+ } else if(strcmp(attr,"retry_cnt")==0) {
+ strcpy(p_ctx->svc.retry_cnt,value);
+ } else if(strcmp(attr,"cpu_assign")==0) {
+ const char* caName = (strcmp(value,"cpu0")==0) ? "TSKM_SVC_ASSIGN_CPU_0" :
+ (strcmp(value,"cpu1")==0) ? "TSKM_SVC_ASSIGN_CPU_1" :
+ (strcmp(value,"auto")==0) ? "TSKM_SVC_ASSIGN_CPU_AUTO" : "ERROR";
+ strcpy(p_ctx->svc.cpu_assign,caName);
+ } else if(strcmp(attr,"user")==0) {
+ strcpy(p_ctx->svc.user,value);
+ } else if(strcmp(attr,"runtime_limit")==0) {
+ strcpy(p_ctx->svc.runtime_limit,value);
+ } else if(strcmp(attr,"cpu_limit")==0) {
+ strcpy(p_ctx->svc.cpu_limit,value);
+ } else if(strcmp(attr,"mem_limit")==0) {
+ strcpy(p_ctx->svc.mem_limit,value);
+ } else if(strcmp(attr,"args")==0) {
+ strcpy(p_ctx->svc.args,value);
+ } else if(strcmp(attr,"shutdown_wait")==0) {
+ const char* swStr = (strcmp(value,"yes")==0) ? "TSKM_TRUE" :
+ (strcmp(value,"no")==0) ? "TSKM_FALSE" : "ERROR";
+ strcpy(p_ctx->svc.shutdown_wait,swStr);
+ }
+ }
+
+ fprintf(p_ctx->fp,"char const *svcArgs%d[] = {",p_ctx->svcNum);
+ fprintf(p_ctx->fp,"\"%s\",",p_ctx->svc.path);
+
+ // Output arguments
+ tp = strtok(p_ctx->svc.args," ");
+ while(tp != NULL) {
+ fprintf(p_ctx->fp,"\"%s\",",tp);
+ tp = strtok(NULL," ");
+ }
+
+ fprintf(p_ctx->fp,"NULL");
+ fprintf(p_ctx->fp,"};\n");
+}
+
+/***************************************
+ * exitService
+ **************************************/
+void
+exitService(PARSE_CTX_t* p_ctx) {
+ uint32_t ii;
+ fprintf(p_ctx->tmpFp,"{" );
+
+ fprintf(p_ctx->tmpFp,"%s",p_ctx->svc.svcid);
+ fprintf(p_ctx->tmpFp,", (const char *)\"%s\"",p_ctx->svc.name);
+ fprintf(p_ctx->tmpFp,", (const char *)\"%s\"",p_ctx->svc.path);
+ fprintf(p_ctx->tmpFp,", (char**)svcArgs%d",p_ctx->svcNum);
+ fprintf(p_ctx->tmpFp,", %s",p_ctx->svc.type);
+ fprintf(p_ctx->tmpFp,", %s",p_ctx->svc.prio);
+ fprintf(p_ctx->tmpFp,", %s",p_ctx->svc.policy);
+ fprintf(p_ctx->tmpFp,", %s",p_ctx->svc.life_cycle);
+ fprintf(p_ctx->tmpFp,", (uint32_t)%s",p_ctx->svc.retry_cnt);
+ fprintf(p_ctx->tmpFp,", %s",p_ctx->svc.cpu_assign);
+ fprintf(p_ctx->tmpFp,", (const char *)\"%s\"",p_ctx->svc.user);
+ fprintf(p_ctx->tmpFp,", %s",(p_ctx->svc.runtime_limit[0] != '\0') ? p_ctx->svc.runtime_limit : "0");
+ fprintf(p_ctx->tmpFp,", %s",(p_ctx->svc.cpu_limit[0] != '\0') ? p_ctx->svc.cpu_limit : "0");
+ fprintf(p_ctx->tmpFp,", %s",(p_ctx->svc.mem_limit[0] != '\0') ? p_ctx->svc.mem_limit : "0");
+ fprintf(p_ctx->tmpFp,", %s",p_ctx->svc.shutdown_wait);
+ fprintf(p_ctx->tmpFp,", %d",p_ctx->svc.subgidNum);
+ if(p_ctx->svc.subgidNum) {
+ fprintf(p_ctx->tmpFp,", subgidList%d",p_ctx->svcNum);
+ } else {
+ fprintf(p_ctx->tmpFp,", NULL");
+ }
+
+ fprintf(p_ctx->tmpFp,"},\n");
+
+ p_ctx->svcNum++;
+
+ p_ctx->state = ELE_SERVICE_LIST;
+}
+
+/***************************************
+ * entrySubgidList
+ **************************************/
+void
+entrySubgidList(PARSE_CTX_t* p_ctx,const XML_Char* atts[]) {
+ p_ctx->state = ELE_SUBGID_LIST;
+
+ fprintf(p_ctx->fp,"static gid_t subgidList%d[] = {",p_ctx->svcNum);
+
+
+}
+
+/***************************************
+ * handleSubgidList
+ **************************************/
+void
+handleSubgidList(PARSE_CTX_t* p_ctx,const XML_Char *name,const XML_Char* atts[]) {
+ PARSE_ASSERT_EXIT(strcmp(name,"subgid") == 0);
+ int32_t ii;
+
+ if(p_ctx->svc.subgidNum > 0) {
+ fprintf(p_ctx->fp,",");
+ }
+ for(ii=0; atts[ii]; ii+=2) {
+ const char* attr = atts[ii];
+ const char* value = atts[ii+1];
+ if(strcmp(attr,"gid")==0) {
+ fprintf(p_ctx->fp,"%s",value);
+ } else {
+ PARSE_ASSERT_EXIT(0);
+ }
+ }
+ p_ctx->svc.subgidNum++;
+}
+
+/***************************************
+ * exitSubgidList
+ **************************************/
+void
+exitSubgidList(PARSE_CTX_t* p_ctx) {
+
+ fprintf(p_ctx->fp,"};\n");
+
+ p_ctx->state = ELE_SERVICE;
+}
+
+
+/***************************************
+ * entryNormalWakeup
+ **************************************/
+void
+entryNormalWakeup(PARSE_CTX_t* p_ctx,const XML_Char* atts[]) {
+ p_ctx->state = ELE_NORMAL_WAKEUP;
+ memset(&p_ctx->gstep,0,sizeof(p_ctx->gstep));
+
+ sprintf(p_ctx->gstep.reqTableName,"wakeupReqList");
+ sprintf(p_ctx->gstep.execSvcName,"wakeupExecSvcId");
+ p_ctx->tmpFp = fopen(TMPFILE,"a");
+ PARSE_ASSERT_EXIT(p_ctx->tmpFp);
+
+ fprintf(p_ctx->tmpFp,"TSKM_GSTEP_t wakeupGstep[]={\n");
+}
+
+/***************************************
+ * exitNormalWakeup
+ **************************************/
+void
+exitNormalWakeup(PARSE_CTX_t* p_ctx) {
+ fprintf(p_ctx->tmpFp,"};\n\n");
+ fclose(p_ctx->tmpFp);
+
+ p_ctx->state = ELE_TSKM_CFG;
+}
+
+/***************************************
+ * entryVupWakeup
+ **************************************/
+void
+entryVupWakeup(PARSE_CTX_t* p_ctx,const XML_Char* atts[]) {
+ p_ctx->state = ELE_VUP_WAKEUP;
+ memset(&p_ctx->gstep,0,sizeof(p_ctx->gstep));
+
+ sprintf(p_ctx->gstep.reqTableName,"wakeupReqListVup");
+ sprintf(p_ctx->gstep.execSvcName,"wakeupExecSvcIdVup");
+ p_ctx->tmpFp = fopen(TMPFILE,"a");
+ PARSE_ASSERT_EXIT(p_ctx->tmpFp);
+
+ fprintf(p_ctx->tmpFp,"TSKM_GSTEP_t wakeupGstepVup[]={\n");
+}
+
+/***************************************
+ * exitVupWakeup
+ **************************************/
+void
+exitVupWakeup(PARSE_CTX_t* p_ctx) {
+ fprintf(p_ctx->tmpFp,"};\n\n");
+ fclose(p_ctx->tmpFp);
+
+ p_ctx->state = ELE_TSKM_CFG;
+}
+
+void
+entryGstep(PARSE_CTX_t* p_ctx,const XML_Char* atts[]) {
+
+ p_ctx->state &= ~ELE_MASK2;
+ p_ctx->state |= ELE_COMMON_GSTEP;
+
+ PARSE_GSTEP_t *p_gstep = &p_ctx->gstep;
+
+ if(atts[0] && strcmp(atts[0],"stepid") == 0) {
+ sprintf(p_gstep->gstepIdStr,"%s",atts[1]);
+ } else {
+ sprintf(p_gstep->gstepIdStr,"TSKM_GSTEP_NONE");
+ }
+ p_gstep->execSvcNum = 0;
+ p_gstep->reqNum = 0;
+ sprintf(p_gstep->nextStepCondStr,"INI_INITCOMP_NONE");
+}
+
+void
+handleGstep(PARSE_CTX_t* p_ctx,const XML_Char *name,const XML_Char* atts[]) {
+ PARSE_ASSERT_EXIT(strcmp(name,"next_trans_condition") == 0);
+ PARSE_GSTEP_t *p_gstep = &p_ctx->gstep;
+
+ if(atts[0] && strcmp(atts[0],"cond") == 0) {
+ sprintf(p_gstep->nextStepCondStr,"%s",atts[1]);
+ } else {
+ PARSE_ASSERT_EXIT(0);
+ }
+}
+
+void
+exitGstep(PARSE_CTX_t* p_ctx) {
+ PARSE_GSTEP_t *p_gstep = &p_ctx->gstep;
+
+ fprintf(p_ctx->tmpFp,"{");
+ fprintf(p_ctx->tmpFp,"%s,",p_gstep->gstepIdStr);
+ fprintf(p_ctx->tmpFp,"%d,",p_gstep->execSvcNum);
+ if(p_gstep->execSvcNum) {
+ fprintf(p_ctx->tmpFp,"%s%d,",p_gstep->execSvcName,p_gstep->step);
+ } else {
+ fprintf(p_ctx->tmpFp,"NULL,");
+ }
+ fprintf(p_ctx->tmpFp,"%d,",p_gstep->reqNum);
+ if(p_gstep->reqNum) {
+ fprintf(p_ctx->tmpFp,"%s%d,",p_gstep->reqTableName,p_gstep->step);
+ } else {
+ fprintf(p_ctx->tmpFp,"NULL,");
+ }
+ fprintf(p_ctx->tmpFp,"%s",p_gstep->nextStepCondStr);
+ fprintf(p_ctx->tmpFp,"},\n");
+
+ p_gstep->step++;
+
+ p_ctx->state &= ~ELE_MASK2;
+}
+
+void
+entryExec(PARSE_CTX_t* p_ctx,const XML_Char* atts[]) {
+ p_ctx->state &= ~ELE_MASK3;
+ p_ctx->state |= ELE_COMMON_EXEC;
+
+ PARSE_GSTEP_t *p_gstep = &p_ctx->gstep;
+ fprintf(p_ctx->fp,
+ "static TSKM_SVCID_t %s%d[] = {",p_gstep->execSvcName,p_gstep->step);
+}
+void
+handleExec(PARSE_CTX_t* p_ctx,const XML_Char *name,const XML_Char* atts[]) {
+ PARSE_ASSERT_EXIT(strcmp(name,"exec_svc") == 0);
+ PARSE_GSTEP_t *p_gstep = &p_ctx->gstep;
+ int ii;
+
+ if(p_gstep->execSvcNum > 0) {
+ fprintf(p_ctx->fp,",");
+ }
+
+ for(ii=0; atts[ii]; ii+=2) {
+ const char* attr = atts[ii];
+ const char* value = atts[ii+1];
+ PARSE_ASSERT_EXIT(strcmp(attr,"svcid") == 0);
+ fprintf(p_ctx->fp,"%s",value);
+ }
+ p_gstep->execSvcNum++;
+}
+void
+exitExec(PARSE_CTX_t* p_ctx) {
+ fprintf(p_ctx->fp,"};\n\n");
+ p_ctx->state &= ~ELE_MASK3;
+}
+
+void
+entryReq(PARSE_CTX_t* p_ctx,const XML_Char* atts[]) {
+ p_ctx->state &= ~ELE_MASK3;
+ p_ctx->state |= ELE_COMMON_REQ;
+ PARSE_GSTEP_t *p_gstep = &p_ctx->gstep;
+
+ fprintf(p_ctx->fp,"static TSKM_GSTEP_REQ_INFO_t %s%d[] ={",p_gstep->reqTableName,p_gstep->step);
+}
+void
+handleReq(PARSE_CTX_t* p_ctx,const XML_Char *name,const XML_Char* atts[]) {
+ PARSE_GSTEP_t *p_gstep = &p_ctx->gstep;
+ PARSE_ASSERT_EXIT(strcmp(name,"request") == 0);
+ int ii;
+
+ fprintf(p_ctx->fp," {");
+
+ for(ii=0; atts[ii]; ii+=2) {
+ const char* attr = atts[ii];
+ const char* value = atts[ii+1];
+ if(strcmp(attr,"local_step") == 0) {
+ if(strcmp(value,"shm") == 0) {
+ fprintf(p_ctx->fp,"TSKM_LSTEP_SHM");
+ } else if(strcmp(value,"bupchk") == 0) {
+ fprintf(p_ctx->fp,"TSKM_LSTEP_BUPCHK");
+ } else if(strcmp(value,"last") == 0) {
+ fprintf(p_ctx->fp,"TSKM_LSTEP_LAST");
+ } else if(strcmp(value,"all") == 0) {
+ fprintf(p_ctx->fp,"TSKM_LSTEP_ALL");
+ } else {
+ fprintf(p_ctx->fp,"%s",value);
+ }
+ } else {
+ fprintf(p_ctx->fp,"%s",value); // Output of ","
+ }
+ fprintf(p_ctx->fp,"%s",(atts[ii+2])?",":""); // Outoput of ","
+ }
+ fprintf(p_ctx->fp,"},");
+ p_gstep->reqNum++;
+}
+void
+exitReq(PARSE_CTX_t* p_ctx) {
+ fprintf(p_ctx->fp,"};\n\n");
+ p_ctx->state &= ~ELE_MASK3;
+}
+
+/***************************************
+ * entryNormalShutdown
+ **************************************/
+void
+entryNormalShutdown(PARSE_CTX_t* p_ctx,const XML_Char* atts[]) {
+ p_ctx->state = ELE_NORMAL_SHUTDOWN;
+
+ memset(&p_ctx->gstep,0,sizeof(p_ctx->gstep));
+ sprintf(p_ctx->gstep.reqTableName,"downReqList");
+ p_ctx->tmpFp = fopen(TMPFILE,"a");
+ PARSE_ASSERT_EXIT(p_ctx->tmpFp);
+
+ fprintf(p_ctx->tmpFp,"static TSKM_GSTEP_t downGstep[]={\n");
+}
+
+/***************************************
+ * exitNormalShutdown
+ **************************************/
+void
+exitNormalShutdown(PARSE_CTX_t* p_ctx) {
+
+ fprintf(p_ctx->tmpFp,"};\n\n");
+ fclose(p_ctx->tmpFp);
+
+ p_ctx->state = ELE_TSKM_CFG;
+}
+
+/***************************************
+ * entryVupShutdown
+ **************************************/
+void
+entryVupShutdown(PARSE_CTX_t* p_ctx,const XML_Char* atts[]) {
+ p_ctx->state = ELE_VUP_SHUTDOWN;
+ memset(&p_ctx->gstep,0,sizeof(p_ctx->gstep));
+
+ sprintf(p_ctx->gstep.reqTableName,"downReqListVup");
+ p_ctx->tmpFp = fopen(TMPFILE,"a");
+ PARSE_ASSERT_EXIT(p_ctx->tmpFp);
+
+ fprintf(p_ctx->tmpFp,"static TSKM_GSTEP_t downGstepVup[]={\n");
+}
+
+/***************************************
+ * exitVupShutdown
+ **************************************/
+void
+exitVupShutdown(PARSE_CTX_t* p_ctx) {
+ fprintf(p_ctx->tmpFp,"};\n\n");
+ fclose(p_ctx->tmpFp);
+
+ p_ctx->state = ELE_TSKM_CFG;
+}
+
+/***************************************
+ * elementStart
+ **************************************/
+void
+elementStart(void *userData, const XML_Char *name, const XML_Char *atts[]) {
+ PARSE_CTX_t *p_ctx = (PARSE_CTX_t*)userData;
+#if 0
+ int ii;
+ printf("[ELEMENT] %s Start!\n", name);
+ for(ii=0; atts[ii]; ii+=2) {
+ printf(" %s:%s \n", atts[ii],atts[ii+1]);
+ }
+#endif
+ switch(p_ctx->state) {
+ case ELE_NONE:
+ if(strcmp(name,"tskm_cfg") == 0) {
+ entryTskmCfg(p_ctx,atts);
+ } else {
+ PARSE_ASSERT_EXIT(0);
+ }
+ break;
+ case ELE_TSKM_CFG:
+ if(strcmp(name,"service_list") == 0) {
+ entryServiceList(p_ctx,atts);
+ } else if(strcmp(name,"normal_wakeup") == 0) {
+ entryNormalWakeup(p_ctx,atts);
+ } else if(strcmp(name,"normal_shutdown") == 0) {
+ entryNormalShutdown(p_ctx,atts);
+ } else if(strcmp(name,"vup_wakeup") == 0) {
+ entryVupWakeup(p_ctx,atts);
+ } else if(strcmp(name,"vup_shutdown") == 0) {
+ entryVupShutdown(p_ctx,atts);
+ } else {
+ PARSE_ASSERT_EXIT(0);
+ }
+ break;
+ case ELE_SERVICE_LIST:
+ if(strcmp(name,"service") == 0) {
+ entryService(p_ctx,name,atts);
+ }
+ break;
+ case ELE_SERVICE:
+ if(strcmp(name,"subgid_list") == 0) {
+ entrySubgidList(p_ctx,atts);
+ }
+ break;
+ case ELE_SUBGID_LIST:
+ handleSubgidList(p_ctx,name,atts);
+ break;
+ case ELE_NORMAL_WAKEUP:
+ case ELE_NORMAL_SHUTDOWN:
+ case ELE_VUP_WAKEUP:
+ case ELE_VUP_SHUTDOWN:
+ if(strcmp(name,"global_step") == 0) {
+ entryGstep(p_ctx,atts);
+ } else {
+ PARSE_ASSERT_EXIT(0);
+ }
+ break;
+ case ELE_NORMAL_W_GSTEP:
+ case ELE_NORMAL_D_GSTEP:
+ case ELE_VUP_W_GSTEP:
+ case ELE_VUP_D_GSTEP:
+ if(strcmp(name,"exec_list") == 0) {
+ entryExec(p_ctx,atts);
+ } else if(strcmp(name,"request_list") == 0) {
+ entryReq(p_ctx,atts);
+ } else {
+ handleGstep(p_ctx,name,atts);
+ }
+ break;
+ case ELE_NORMAL_W_EXEC:
+ case ELE_VUP_W_EXEC:
+ handleExec(p_ctx,name,atts);
+ break;
+ case ELE_NORMAL_W_REQ:
+ case ELE_NORMAL_D_REQ:
+ case ELE_VUP_W_REQ:
+ case ELE_VUP_D_REQ:
+ handleReq(p_ctx,name,atts);
+ break;
+ }
+}
+
+
+/***************************************
+ * elementEnd
+ **************************************/
+void
+elementEnd(void *userData, const XML_Char *name) {
+ PARSE_CTX_t *p_ctx = (PARSE_CTX_t*)userData;
+ switch(p_ctx->state) {
+ case ELE_NONE:
+ PARSE_ASSERT_EXIT(0);
+ break;
+ case ELE_TSKM_CFG:
+ if(strcmp(name,"tskm_cfg") == 0) {
+ exitTskmCfg(p_ctx);
+ } else {
+ PARSE_ASSERT_EXIT(0);
+ }
+ break;
+ case ELE_SERVICE_LIST:
+ if(strcmp(name,"service_list") == 0) {
+ exitServiceList(p_ctx);
+ }
+ break;
+ case ELE_SERVICE:
+ if(strcmp(name,"service") == 0) {
+ exitService(p_ctx);
+ }
+ break;
+ case ELE_SUBGID_LIST:
+ if(strcmp(name,"subgid_list") == 0) {
+ exitSubgidList(p_ctx);
+ }
+ break;
+ case ELE_NORMAL_WAKEUP:
+ if(strcmp(name,"normal_wakeup") == 0) {
+ exitNormalWakeup(p_ctx);
+ }
+ break;
+ case ELE_NORMAL_SHUTDOWN:
+ if(strcmp(name,"normal_shutdown") == 0) {
+ exitNormalShutdown(p_ctx);
+ }
+ break;
+ case ELE_VUP_WAKEUP:
+ if(strcmp(name,"vup_wakeup") == 0) {
+ exitVupWakeup(p_ctx);
+ }
+ break;
+ case ELE_VUP_SHUTDOWN:
+ if(strcmp(name,"vup_shutdown") == 0) {
+ exitVupShutdown(p_ctx);
+ }
+ break;
+ case ELE_NORMAL_D_GSTEP:
+ case ELE_NORMAL_W_GSTEP:
+ case ELE_VUP_D_GSTEP:
+ case ELE_VUP_W_GSTEP:
+ if(strcmp(name,"global_step") == 0) {
+ exitGstep(p_ctx);
+ }
+ break;
+ case ELE_NORMAL_W_EXEC:
+ case ELE_VUP_W_EXEC:
+ if(strcmp(name,"exec_list") == 0) {
+ exitExec(p_ctx);
+ }
+ break;
+ case ELE_NORMAL_D_REQ:
+ case ELE_NORMAL_W_REQ:
+ case ELE_VUP_D_REQ:
+ case ELE_VUP_W_REQ:
+ if(strcmp(name,"request_list") == 0) {
+ exitReq(p_ctx);
+ }
+ break;
+ }
+}
+/***************************************
+ * parseXmlFile
+ **************************************/
+int
+parseXmlFile(const char* file,XML_Parser parser) {
+ int ret = -1;
+ FILE* fp = fopen(file, "r");
+ if (fp == NULL) {
+ goto ERROR;
+ }
+
+ while(1) {
+ char *buf = (char*) XML_GetBuffer(parser, BUFSIZE);
+ if (!buf) {
+ goto ERROR;
+ }
+
+ size_t nread = fread(buf, sizeof(char), BUFSIZE, fp);
+ if (ferror(fp)) {
+ goto ERROR;
+ }
+
+ if (!XML_ParseBuffer(parser, nread, feof(fp))) {
+ goto ERROR;
+ }
+
+ if (feof(fp)) {
+ break;
+ }
+ }
+ ret = 0;
+ERROR:
+ if(fp) {
+ fclose(fp);
+ }
+ return ret;
+}
+
+/***************************************
+ * externalHandler
+ **************************************/
+int
+externalHandler(XML_Parser parser,
+ const XML_Char* content, const XML_Char* base,
+ const XML_Char* systemId, const XML_Char* publicId) {
+ printf("parse %s \n",systemId);
+
+ int ret = XML_ERROR_EXTERNAL_ENTITY_HANDLING;
+ XML_Parser extparser = NULL;
+
+ extparser = XML_ExternalEntityParserCreate(parser, content, NULL);
+ if(extparser ==NULL) {
+ goto ERROR;
+ }
+
+ if(parseXmlFile(systemId,extparser) != 0) {
+ goto ERROR;
+ }
+ ret = XML_STATUS_OK;
+ERROR:
+ if(extparser) {
+ XML_ParserFree(extparser);
+ }
+ return ret;
+}
+
+/***************************************
+ * usage
+ **************************************/
+void
+usage(const char* cmd) {
+ printf("usage:%s xmlfile\n",cmd);
+}
+
+/***************************************
+ * main
+ **************************************/
+int
+main (int argc, char *argv[]) {
+ struct stat statinfo;
+ int ret=-1;
+ int xmlRet;
+ const char* inpath;
+ char tmpstr1[255];
+ char tmpstr2[255];
+ const char* workdir;
+ const char* infile;
+ XML_Parser parser;
+ PARSE_CTX_t ctx;
+
+ if(argc < 2) {
+ usage(argv[0]);
+ goto ERROR;
+ }
+
+ inpath = argv[1];
+ if(0 != stat(inpath,&statinfo)) {
+ fprintf(stderr, "%s:%s",strerror(errno),inpath);
+ goto ERROR;
+ }
+ memset(&ctx,0,sizeof(ctx));
+
+ strcpy(tmpstr1,inpath);
+ strcpy(tmpstr2,inpath);
+ workdir=dirname(tmpstr1);
+ infile=basename(tmpstr2);
+
+ if(0 != chdir(workdir)) {
+ fprintf(stderr, "%s:%s",strerror(errno),workdir);
+ goto ERROR;
+ }
+
+ ctx.fp = fopen(OUTFILE, "w");
+ if (ctx.fp == NULL) {
+ goto ERROR;
+ }
+ fprintf(ctx.fp,"//This file is created automatically from %s.\n",inpath);
+ fprintf(ctx.fp,"//So you shall not modify this file immediately.\n");
+
+ /* create XML parser */
+ if ((parser = XML_ParserCreate(NULL)) == NULL) {
+ fprintf(stderr, "parser creation error\n");
+ goto ERROR;
+ }
+ XML_SetUserData(parser,&ctx);
+ XML_SetParamEntityParsing(parser,XML_PARAM_ENTITY_PARSING_ALWAYS); // Allow External Entities
+ XML_SetExternalEntityRefHandler(parser,externalHandler);
+ XML_SetElementHandler(parser, elementStart, elementEnd);
+
+ if(parseXmlFile(infile,parser) != 0) {
+ goto ERROR;
+ }
+ ret = 0;
+
+ERROR:
+ if(parser) {
+ XML_ParserFree(parser);
+ }
+ if(ctx.fp) {
+ fclose(ctx.fp);
+ }
+ char buf[255];
+ sprintf(buf,"cat %s >> %s",TMPFILE,OUTFILE);
+ printf("%s\n",buf);
+ system(buf);
+ unlink(TMPFILE);
+ return ret;
+}
+
Code Review / staging / basesystem.git / blobdiff