///////////////////////////////////// // Name: ScriptLineDestroy // Purpose: destroys given script line // Output: script line destroyed // Return: none ///////////////////////////////////// PROTECTED void ScriptLineDestroy(void *owner, ScriptLine **sLine) { if(*sLine) { //destroy sub lines if((*sLine)->subLines) { for(int i = 0; i < (*sLine)->subLines->size(); i++) ScriptLineDestroy(owner, &(*(*sLine)->subLines)[i]); delete (*sLine)->subLines; } //destroy function if((*sLine)->func) ScriptFuncDestroy(owner, &(*sLine)->func); //destroy script line condition if((*sLine)->condDat) ScriptCondDestroy(&(*sLine)->condDat); //destroy params delete (*sLine)->params; SCRIPT_FREE(*sLine); sLine = 0; } }
///////////////////////////////////// // Name: ScriptVarDestroy // Purpose: destroys a variable // Output: variable destroyed // Return: ///////////////////////////////////// PROTECTED void ScriptVarDestroy(void *owner, hVAR *var) { if(*var) { ScriptVarCall(owner, *var, VAR_DESTROY, 0, 0); SCRIPT_FREE(*var); var = 0; } }
///////////////////////////////////// // Name: ScriptCondDestroy // Purpose: destroys given script line // condition // Output: script line condition destroyed // Return: none ///////////////////////////////////// PROTECTED void ScriptCondDestroy(ScriptLineCond **sCond) { if(*sCond) { if((*sCond)->left) ScriptCondDestroy(&(*sCond)->left); if((*sCond)->right) ScriptCondDestroy(&(*sCond)->right); SCRIPT_FREE(*sCond); sCond = 0; } }
///////////////////////////////////// // Name: ScriptLineCreate // Purpose: creates a script line // depending on initType: // func call -> sInd -> function type call // var set -> sInd.ind -> variable index in variables, also uses bGlobal // condition -> sInd.ind -> (eCondition) // Output: // Return: ///////////////////////////////////// PROTECTED ScriptLine * ScriptLineCreate(void *owner, FILE *fp, VarPtrArray *variables, const ScriptInd & sInd, bool bGlobal, eScriptLineInit initType) { ScriptLine *newScriptLine = (ScriptLine *)SCRIPT_MALLOC(sizeof(ScriptLine)); if(!newScriptLine) { ASSERT_MSG(0, "Unable to allocate new script line!", "ScriptLineCreate"); return 0; } //do something depending on init type switch(initType) { case eScriptLine_Function: { //initialize function newScriptLine->func = ScriptFuncCreate(owner, sInd); assert(newScriptLine->func); ///////////////////////////////////////////////////////////// //create parameters newScriptLine->params = new ParamArray; assert(newScriptLine->params); //get parameters char *buff; int buffSize; if(ParserCountStringFile(fp, &buffSize, '(', ')') != RETCODE_ENDREACHED) { ASSERT_MSG(0, "Error reading parameters", "ScriptLineCreate"); ScriptLineDestroy(owner, &newScriptLine); return 0; } buff = (char*)SCRIPT_MALLOC(sizeof(char)*(buffSize+1)); ParserReadStringFile(fp, buff, buffSize+1, '(', ')'); //now parse the buffer containing stuff inside '(...)' //insert them in param ScriptInd fInd = ScriptFuncGetTypeInd(newScriptLine->func); ScriptParamParseBuff(buff, variables, &SCRIPT_FUNCTYPE(fInd.ascii, fInd.ind).funcParam, newScriptLine->params); SCRIPT_FREE(buff); ///////////////////////////////////////////////////////////// } break; case eScriptLine_VarSet: { //set var ind newScriptLine->var.bGlobal = bGlobal; newScriptLine->var.dat._varInd = sInd.ind; newScriptLine->var.paramVarType = eVarPtr; //get the variable hVAR var = bGlobal ? ScriptTeaseGetGlobalVar(sInd.ind) : ScriptGetVar(sInd.ind, variables); assert(var); //this can't be null! ///////////////////////////////////////////////////////////// //create parameters newScriptLine->params = new ParamArray; assert(newScriptLine->params); //get parameters char *buff; int buffSize; if(ParserCountStringFile(fp, &buffSize, '(', ')') != RETCODE_ENDREACHED) { ASSERT_MSG(0, "Error reading parameters", "ScriptLineCreate"); ScriptLineDestroy(owner, &newScriptLine); return 0; } buff = (char*)SCRIPT_MALLOC(sizeof(char)*(buffSize+1)); ParserReadStringFile(fp, buff, buffSize+1, '(', ')'); //now parse the buffer containing stuff inside '(...)' //insert them in param ScriptInd vInd = ScriptVarGetTypeInd(var); ScriptParamParseBuff(buff, variables, &SCRIPT_VARTYPE(vInd.ascii, vInd.ind).funcParam, newScriptLine->params); SCRIPT_FREE(buff); ///////////////////////////////////////////////////////////// } break; case eScriptLine_Condition: //extra precaution... newScriptLine->func = 0; newScriptLine->var.paramVarType = eVarNULL; //intialize some stuff newScriptLine->curSubLine = -1; //this is so that we only check the condition //once newScriptLine->prevRet = SCRIPTLINERET_DONE; //create script condition newScriptLine->condition = (eCondition)sInd.ind; ///////////////////////////////////////////////////////////// //create conditions if(newScriptLine->condition != eCondNone && newScriptLine->condition != eElse) { //get conditions tests, eg: if (...) char *buff; int buffSize; if(ParserCountStringFile(fp, &buffSize, '(', ')') != RETCODE_ENDREACHED) { ASSERT_MSG(0, "Error reading parameters", "ScriptLineCreate"); ScriptLineDestroy(owner, &newScriptLine); return 0; } buff = (char*)SCRIPT_MALLOC(sizeof(char)*(buffSize+1)); ParserReadStringFile(fp, buff, buffSize+1, '(', ')'); newScriptLine->condDat = ScriptCondCreate(buff, variables); SCRIPT_FREE(buff); } ///////////////////////////////////////////////////////////// //allocate the sub lines newScriptLine->subLines = new ScriptLinePtrArray; assert(newScriptLine->subLines); //now get the sub lines inside the condition if(ScriptParseFile(owner, fp, variables, newScriptLine->subLines, "{", "}") != RETCODE_SUCCESS) { ScriptLineDestroy(owner, &newScriptLine); return 0; } break; } return newScriptLine; }
/* * init script */ int __init script_init(void) { int i, j, count; script_origin_head_t *script_hdr = __va(SYS_CONFIG_MEMBASE); script_origin_main_key_t *origin_main; script_origin_sub_key_t *origin_sub; script_main_key_t *main_key; script_sub_key_t *sub_key, *tmp_sub, swap_sub; script_item_u *sub_val, *tmp_val, swap_val, *pval_temp; printk("%s enter!\n", __func__); if(!script_hdr) { printk(KERN_ERR "script buffer is NULL!\n"); return -1; } /* alloc memory for main keys */ g_script = SCRIPT_MALLOC(script_hdr->main_cnt*sizeof(script_main_key_t)); if(!g_script) { printk(KERN_ERR "try to alloc memory for main keys!\n"); return -1; } origin_main = &script_hdr->main_key; for(i=0; i<script_hdr->main_cnt; i++) { main_key = &g_script[i]; /* copy main key name */ strncpy(main_key->name, origin_main[i].name, SCRIPT_NAME_SIZE_MAX); /* calculate hash value */ main_key->hash = hash(main_key->name); if (origin_main[i].sub_cnt == 0) { /* this mainkey have no subkey, skip subkey initialize */ main_key->subkey = NULL; main_key->subkey_val = NULL; count = 0; goto next_mainkey; } /* allock memory for sub-keys */ main_key->subkey = SCRIPT_MALLOC(origin_main[i].sub_cnt*sizeof(script_sub_key_t)); main_key->subkey_val = SCRIPT_MALLOC(origin_main[i].sub_cnt*sizeof(script_item_u)); if(!main_key->subkey || !main_key->subkey_val) { printk(KERN_ERR "try alloc memory for sub keys failed!\n"); goto err_out; } sub_key = main_key->subkey; sub_val = main_key->subkey_val; origin_sub = (script_origin_sub_key_t *)((unsigned int)script_hdr + (origin_main[i].offset<<2)); /* process sub keys */ for(j=0; j<origin_main[i].sub_cnt; j++) { strncpy(sub_key[j].name, origin_sub[j].name, SCRIPT_NAME_SIZE_MAX); sub_key[j].hash = hash(sub_key[j].name); sub_key[j].type = (script_item_value_type_e)origin_sub[j].pattern.type; sub_key[j].value = &sub_val[j]; if(origin_sub[j].pattern.type == SCIRPT_PARSER_VALUE_TYPE_SINGLE_WORD) { sub_val[j].val = *(int *)((unsigned int)script_hdr + (origin_sub[j].offset<<2)); sub_key[j].type = SCIRPT_ITEM_VALUE_TYPE_INT; } else if(origin_sub[j].pattern.type == SCIRPT_PARSER_VALUE_TYPE_STRING) { sub_val[j].str = SCRIPT_MALLOC((origin_sub[j].pattern.cnt<<2) + 1); memcpy(sub_val[j].str, (char *)((unsigned int)script_hdr + (origin_sub[j].offset<<2)), origin_sub[j].pattern.cnt<<2); sub_key[j].type = SCIRPT_ITEM_VALUE_TYPE_STR; } else if(origin_sub[j].pattern.type == SCIRPT_PARSER_VALUE_TYPE_GPIO_WORD) { script_origin_gpio_t *origin_gpio = (script_origin_gpio_t *)((unsigned int)script_hdr + (origin_sub[j].offset<<2) - 32); u32 gpio_tmp = port_to_index(origin_gpio->port, origin_gpio->port_num); if(GPIO_INDEX_INVALID == gpio_tmp) printk(KERN_ERR "%s:%s->%s gpio cfg invalid, please check sys_config.fex!\n",__func__,main_key->name,sub_key[j].name); sub_val[j].gpio.gpio = gpio_tmp; sub_val[j].gpio.mul_sel = (u32)origin_gpio->mul_sel; sub_val[j].gpio.pull = (u32)origin_gpio->pull; sub_val[j].gpio.drv_level = (u32)origin_gpio->drv_level; sub_val[j].gpio.data = (u32)origin_gpio->data; sub_key[j].type = SCIRPT_ITEM_VALUE_TYPE_PIO; } else { sub_key[j].type = SCIRPT_ITEM_VALUE_TYPE_INVALID; } } /* process gpios */ tmp_sub = main_key->subkey; tmp_val = main_key->subkey_val; count = 0; for(j=0; j<origin_main[i].sub_cnt; j++) { if(sub_key[j].type == SCIRPT_ITEM_VALUE_TYPE_PIO) { /* swap sub key */ swap_sub = *tmp_sub; *tmp_sub = sub_key[j]; sub_key[j] = swap_sub; /* swap sub key value ptr */ pval_temp = tmp_sub->value; tmp_sub->value = sub_key[j].value; sub_key[j].value = pval_temp; /* swap key value */ swap_val = *tmp_val; *tmp_val = main_key->subkey_val[j]; main_key->subkey_val[j] = swap_val; tmp_sub++; tmp_val++; count++; } } /* process sub key link */ for(j=0; j<origin_main[i].sub_cnt-1; j++) { main_key->subkey[j].next = &main_key->subkey[j+1]; } /* set gpio infermation */ next_mainkey: main_key->gpio = main_key->subkey_val; main_key->gpio_cnt = count; main_key->next = &g_script[i+1]; } g_script[script_hdr->main_cnt-1].next = 0; /* dump all the item */ //script_dump_mainkey(NULL); printk("%s exit!\n", __func__); return 0; err_out: /* script init failed, release resource */ printk(KERN_ERR "init sys_config script failed!\n"); if(g_script) { for(i=0; i<script_hdr->main_cnt; i++) { main_key = &g_script[i]; origin_sub = (script_origin_sub_key_t *)((unsigned int)script_hdr + (origin_main[i].offset<<2)); if(main_key->subkey_val) { for(j=0; j<origin_main[i].sub_cnt; j++) { if(main_key->subkey[j].type == SCIRPT_ITEM_VALUE_TYPE_STR) { if (main_key->subkey_val[j].str) { SCRIPT_FREE(main_key->subkey_val[j].str, (origin_sub[j].pattern.cnt<<2) + 1); } } } SCRIPT_FREE(main_key->subkey_val, sizeof(script_item_u)); } if(main_key->subkey) { SCRIPT_FREE(main_key->subkey, sizeof(script_sub_key_t)); } } SCRIPT_FREE(g_script, script_hdr->main_cnt*sizeof(script_main_key_t)); g_script = 0; } return -1; }