/**
* Loads an area from XML file.
* @param filename of the Area to load.
* @param area An optional pointer to the area to load this into, otherwise a new one will be made.
* @return Pointer to the loaded Area.
*/
Area* FileProcessor::loadArea(const string filename, Area* area) {
if(!area) {
area = new Area(DEFAULT_TAG);
}
FILE* fp;
mxml_node_t *tree, *node;
fp = fopen(filename.c_str(), "r");
if(!fp) {
return NULL;
}
tree = mxmlLoadFile(NULL, fp, MXML_TEXT_CALLBACK);
fclose(fp);
for(node = tree->child; node; node = node->next) {
if(node->type == MXML_ELEMENT) {
if(strcasecmp(node->value.element.name, "area") == 0) {
loadArea_Area(node, area);
}
}
}
mxmlDelete(tree);
return area;
}
mxml_node_t *nftnl_mxml_build_tree(const void *data, const char *treename,
struct nftnl_parse_err *err, enum nftnl_parse_input input)
{
mxml_node_t *tree;
switch (input) {
case NFTNL_PARSE_BUFFER:
tree = mxmlLoadString(NULL, data, MXML_OPAQUE_CALLBACK);
break;
case NFTNL_PARSE_FILE:
tree = mxmlLoadFile(NULL, (FILE *)data, MXML_OPAQUE_CALLBACK);
break;
default:
goto err;
}
if (tree == NULL) {
err->error = NFTNL_PARSE_EBADINPUT;
goto err;
}
if (tree->value.opaque != NULL &&
strcmp(tree->value.opaque, treename) == 0)
return tree;
err->error = NFTNL_PARSE_EMISSINGNODE;
err->node_name = treename;
mxmlDelete(tree);
err:
err->line = 0;
err->column = 0;
errno = EINVAL;
return NULL;
}
int LoadSave_loadRocketXML(const text_t* path, TrackData* trackData)
{
FILE* fp = 0;
mxml_node_t* tree = 0;
#if defined(_WIN32)
if (_wfopen_s(&fp, path, L"r") != 0)
return false;
#else
if (!(fp = fopen(path, "r")))
return false;
#endif
if (!(tree = mxmlLoadFile(NULL, fp, MXML_TEXT_CALLBACK)))
{
fclose(fp);
return false;
}
parseXml(tree, trackData);
fclose(fp);
mxmlDelete(tree);
return true;
}
mxml_node_t* read_xml( const char* filename, mxml_node_t* xml_node )
{
FILE* file;
if( (file = fopen(filename, "r")) == NULL ){
perror("Could not open file for reading");
exit(1);
}
xml_node = mxmlLoadFile(NULL, file, MXML_TEXT_CALLBACK);
fclose(file);
return xml_node;
}
static void load(FILE* file, Config* config)
{
mxml_node_t* tree = mxmlLoadFile(NULL, file, MXML_TEXT_CALLBACK);
mxml_node_t* cfg = mxmlFindElement(tree, tree, "config", NULL, NULL, MXML_DESCEND_FIRST);
if (cfg == NULL) {
fprintf(stderr, "missing config item 'config'\n");
exit(1);
}
load_database_config(mxmlFindElement(cfg, cfg, "database", NULL, NULL, MXML_DESCEND_FIRST), &config->db);
load_logic_config(mxmlFindElement(cfg, cfg, "logic", NULL, NULL, MXML_DESCEND_FIRST), &config->logic);
load_reader_config(mxmlFindElement(cfg, cfg, "reader", NULL, NULL, MXML_DESCEND_FIRST), &config->reader);
mxmlDelete(tree);
}
/*
* Utilise mini-xml pour charger dans un arbre en memoire le contenu du fichier FileName
* FileName : chemin du fichier à ouvrir
* return : Pointeur sur le noeud racine de l'arbre
*/
mxml_node_t *loadXmlTree(const char *FileName)
{
FILE *fp;
mxml_node_t *tree;
fp = fopen(FileName, "r");
if(fp == NULL) {
printf("Erreur ouverture en lecture %s :\n",FileName);
perror("fopen");
return NULL;
}
tree = mxmlLoadFile(NULL, fp, MXML_OPAQUE_CALLBACK);
if(tree == NULL)
printf("Erreur lecture xml %s\n",FileName);
fclose(fp);
return tree;
}
int xmldb_open(void)
{
FILE * fp;
mxml_node_t * version;
fp = fopen(XML_DB, "r"); //打开文件
if (fp != NULL) { //文件不存在 创建
mxml_node_t = mxmlNewXML("1.0");
if (xml_root == NULL) {
log_error(LOG_ERROR, "mxmlNewXML");
return -1;
}
version = mxmlNewElement(xml_root, VERSION);
if (version == NULL) {
log_error(LOG_ERROR, "mxmlNewElement");
return -1;
}
version = mxmlNewElement(xml_root, "0.00");
if (version == NULL) {
log_error(LOG_ERROR, "mxmlNewElement");
return -1;
}
} else if (fp == NULL && errno == EEXIST) { //文件存在 读取
xml_root = mxmlLoadFile(NULL, fp, MXML_TEXT_CALLBACK); //已子节点载入 全部使用字符串
if (xml_root == NULL) {
log_error(LOG_ERROR, "mxmlLoadFile");
return -1;
}
/*
cmd = mxmlNewElement(xml_root, CMD_NODE);
if (cmd == NULL) {
log_error(LOG_ERROR, "mxmlNewElement");
return -1;
}
*/
} else {
log_error(LOG_ERROR, "xml open");
return -1;
}
return 0;
}
static int l_mxml_openfile(lua_State *L)
{
const char *top;
mxml_node_t **node;
FILE *fp;
fp = _l_openFileFP(L, 1, "r");
node = _l_new_node(L);
*node = mxmlLoadFile(NULL, fp, MXML_OPAQUE_CALLBACK);
if (*node == NULL)
luaL_error(L, "mxml_error: mxmlLoadFile error");
fclose(fp);
return 1;
}
void backup_init(void)
{
FILE *fp;
if (access(BACKUP_DIR, F_OK) == -1 ) {
mkdir(BACKUP_DIR, 0777);
}
if (access(BACKUP_FILE, F_OK) == -1 ) {
return;
}
fp = fopen(BACKUP_FILE, "r");
if (fp!=NULL) {
backup_tree = mxmlLoadFile(NULL, fp, MXML_NO_CALLBACK);
fclose(fp);
}
backup_load_download();
backup_load_event();
backup_update_all_complete_time_transfer_complete();
}
int load_game(char * path, settings * game_settings){
FILE * fp;
mxml_node_t *xml_tree;
mxml_node_t *xml_node;
char row_node[17] = "game/board/row_x";
char row[9] = { 0 };
cord c;
fp = fopen(path, "r");
if (fp == NULL)
return FALSE;
xml_tree = mxmlLoadFile(NULL, fp, MXML_OPAQUE_CALLBACK);
fclose(fp);
xml_node = mxmlFindPath(xml_tree, "game/next_turn");
game_settings->next = (xml_node == NULL) ? WHITE : string_to_color(mxmlGetOpaque(xml_node));
xml_node = mxmlFindPath(xml_tree, "game/game_mode");
game_settings->mode = (xml_node == NULL) ? PLAYER_VS_COMP : atoi(mxmlGetOpaque(xml_node));
if (game_settings->mode == PLAYER_VS_COMP){
xml_node = mxmlFindPath(xml_tree, "game/difficulty");
game_settings->minimax_depth = (xml_node == NULL) ? 1 : atoi(mxmlGetOpaque(xml_node));
xml_node = mxmlFindPath(xml_tree, "game/user_color");
game_settings->color = (xml_node == NULL) ? WHITE : string_to_color(mxmlGetOpaque(xml_node));
}
for (int y = 8; y > 0; y--) {
row_node[15] = '0' + y;
xml_node = mxmlFindPath(xml_tree, row_node);
strcpy(row, mxmlGetOpaque(xml_node));
for (int x = 0; x < 8; x++) {
c.x = x;
c.y = y - 1;
board_piece(game_settings->board, c) = (row[x] == '_') ? EMPTY : row[x];
}
}
//mxmlDelete(xml_tree);
return TRUE;
}
int load_feeds()
{
if (!fatInitDefault()) {
return -1;
}
mxml_node_t *tree;
mxml_node_t *rss;
mxml_node_t *node;
//printf("DEBUG: load_feeds()\n");
FILE *fp = fopen("/feeds.xml", "rb");
if (fp == NULL) {
fclose(fp);
//printf("DEBUG: File-Pointer is NULL!!!\n");
return -2;
}
else {
fseek (fp , 0, SEEK_END);
long settings_size = ftell (fp);
rewind (fp);
if (settings_size > 0) {
tree = mxmlLoadFile(NULL, fp, MXML_OPAQUE_CALLBACK);
fclose(fp);
rss = mxmlFindElement(tree, tree, "rss", NULL, NULL, MXML_DESCEND);
if (rss == NULL) return -103;
for (node = mxmlFindElement(rss, rss, "feed", NULL, NULL, MXML_DESCEND); node != NULL; node = mxmlFindElement(node, rss, "feed", NULL, NULL, MXML_DESCEND))
{
const char * feedurl = node->child->value.opaque;
if (feedurl)
{
const char * sender = mxmlElementGetAttr(node, "name");
if (sender)
{
//printf("DEBUG: Valid node found!!!\n");
int old_length = ijobs;
RSS_Job * tmp = new RSS_Job[old_length];
for (int i = 0; i < old_length; i++)
{
//printf("DEBUG: Copying an element to the temp-Array...\n");
tmp[i] = jobs[i];
}
jobs = new RSS_Job[ old_length + 1 ];
for (int j = 0; j < old_length ; j++)
{
//printf("DEBUG: Copying an element back to the jobs-Array...\n");
jobs[j] = tmp[j];
}
memset(newone.url, 0, 256);
memset(newone.name, 0, 256);
snprintf(newone.url, 255, feedurl);
snprintf(newone.name, 255, sender);
jobs[old_length] = newone;
ijobs++;
//printf("DEBUG: ijobs: %i\n", ijobs);
}
else
{
//printf("DEBUG: return -102\n");
return -102;
}
}
else
{
//printf("DEBUG: return -101\n");
return -101;
}
}
mxmlDelete(tree);
//printf("File loaded.\n\n");
}
else {
fclose(fp);
//printf("DEBUG: return -1\n");
return -3;
}
}
return 0;
}
int parse_opt(int argc, char *argv[])
{
char cmd[4] = {0};
char key[128] = {0};
char val[128] = {0};
char file[128] = {0};
int num = 0;
int flag = 0;
int c;
while (1) {
int option_index = 0;
/*
* name; has_arg; flag; val;
* {"quiet", 0, 0, 0}
*
* ATTENTION:
* when has_arg set to 1, a ':' add in "hc:k:f:v:" accordingly
* on cmdline: -q a <==> -qa
*/
static struct option long_options[] = {
{"help" , 0, 0, 'h'},
{"inner", 0, 0, 'i'},
{"cmd" , 1, 0, 'c'},
{"file" , 1, 0, 'f'},
{"key" , 1, 0, 'k'},
{"val" , 1, 0, 'v'},
{"num" , 1, 0, 'n'},
{0 , 0, 0, 0 }
};
c = getopt_long(argc, argv, "hic:k:f:v:n:", long_options, &option_index);
if (c == -1)
break;
switch (c) {
case 'c':
flag |= FLAG_CMD;
strncpy(cmd, optarg, 1);
if (cmd[0] != 'a' && cmd[0] != 'd' && cmd[0] != 'w' && cmd[0] != 'r') {
pritnt_usage(argv, __LINE__);
}
break;
case 'f':
flag |= FLAG_FILE;
strncpy(file, optarg, sizeof(file));
break;
case 'k':
flag |= FLAG_KEY;
strncpy(key, optarg, sizeof(key));
break;
case 'v':
flag |= FLAG_VAL;
strncpy(val, optarg, sizeof(val));
break;
case 'n':
flag |= FLAG_NUM;
num = atoi(optarg);
break;
case 'i':
flag |= FLAG_INNER;
break;
case 'h':
pritnt_usage(argv, 0);
default:
pritnt_usage(argv, __LINE__);
}
}
if (!(flag & FLAG_CMD)) {
pritnt_usage(argv, __LINE__);
}
if ((flag & FLAG_NUM) && num < 1) {
pritnt_usage(argv, __LINE__);
}
// xml-file needed
if (optind == (argc-1)) {
if (0 != access(argv[optind], R_OK)) {
eprintf("file %s is not readable\n", argv[optind]);
exit(1);
}
} else {
fprintf(stderr, "optind:%d argc-1:%d\n", optind, argc-1);
pritnt_usage(argv, __LINE__);
}
int ret;
const char *xmlfile = argv[optind];
FILE *fp_xml = fopen(xmlfile, "r");
return_val_if_fail(fp_xml != NULL, FAILURE);
mxml_node_t *tree = NULL;
if (cmd[0] == 'r') {
tree = mxmlLoadFile(NULL, fp_xml, MXML_OPAQUE_CALLBACK);
return_val_if_fail(tree != NULL, FAILURE);
} else {
tree = mxmlLoadFile(NULL, fp_xml, MXML_TEXT_CALLBACK);
return_val_if_fail(tree != NULL, FAILURE);
}
fclose(fp_xml);
if (flag & FLAG_FILE) {
int match;
FILE *fp;
char *line = NULL;
size_t len = 0;
fp = fopen(file, "r");
if (fp == NULL) {
exit(1);
}
while ((getline(&line, &len, fp)) != -1) {
match = sscanf(line, "%d%s%*[ ]%[^\n]", &num, key, val);
if ((match == 3 && (cmd[0] == 'a' || cmd[0] == 'w')) ||
(match == 2 && (cmd[0] == 'd' || cmd[0] == 'r'))) {
ret = node_process(cmd[0], tree, key, val, num);
if (ret != 0) {
pritnt_usage(argv, ret);
}
} else {
eprintf("Retrieved error format line %s\n", line);
}
}
free(line);
fclose(fp);
} else {
ret = node_process(cmd[0], tree, key, val, num);
if (ret != 0) {
pritnt_usage(argv, ret);
}
}
if (cmd[0] != 'r') {
if (flag&FLAG_INNER) {
FILE *fp = fopen(argv[optind], "w");
mxmlSaveFile(tree, fp, xml_format_write);
} else {
char *ptr = mxmlSaveAllocString(tree, xml_format_write);
printf("%s\n", ptr);
}
}
return 0;
}
int main(int argc, char ** argv)
{
uint32_t max_doc_id = 50000000; // 最大docid
uint32_t max_thread_num = 8; // 最大线程数量
char cfgFile[PATH_MAX] = ""; // 配置文件名
// parse argv
for(int ch; -1 != (ch = getopt(argc, argv, "d:f:t:h?"));) {
switch(ch) {
case 'd':
{
max_doc_id = strtoul(optarg, NULL, 10);
break;
}
case 'f':
{
int32_t len = strlen(optarg);
if (len >= PATH_MAX) {
usage(basename(argv[0]));
return -1;
}
strcpy(cfgFile, optarg);
break;
}
case 't':
{
max_thread_num = strtoul(optarg, NULL, 10);
break;
}
case 'h':
case '?':
default:
{
usage(basename(argv[0]));
return -1;
}
}
}
if (strlen(cfgFile) <= 0) {
usage(basename(argv[0]));
return -1;
}
time_t beginTime = time(NULL);
alog::Configurator::configureRootLogger();
// 解析配置文件
FILE* fp = fopen(cfgFile, "r");
if(fp == NULL) {
usage(basename(argv[0]));
return -1;
}
mxml_node_t* pXMLTree = mxmlLoadFile(NULL, fp, MXML_NO_CALLBACK);
if(pXMLTree == NULL) {
fclose(fp);
TERR("config file %s format error", cfgFile);
mxmlDelete(pXMLTree);
return -1;
}
fclose(fp);
// 创建build对象
char szIdxPath[PATH_MAX]; // 输出路径
char szInputPath[PATH_MAX]; // 输入路径
index_lib::IndexBuilder cIndexBuilder(max_doc_id);
// globals
mxml_node_t* pRoot = mxmlFindElement(pXMLTree, pXMLTree, "globals", NULL, NULL, MXML_DESCEND);
if (NULL == pRoot) {
TERR("config file %s, cant find field globals", cfgFile);
mxmlDelete(pXMLTree);
return -1;
}
const char* pPathRoot = mxmlElementGetAttr(pRoot, "root");
if (NULL == pPathRoot) {
TERR("config file %s, cant find field root", cfgFile);
mxmlDelete(pXMLTree);
return -1;
}
// <index name="index" sub_dir="index">
pRoot = mxmlFindElement(pXMLTree, pXMLTree, "index", NULL, NULL, MXML_DESCEND);
if(pRoot == NULL) {
TERR("config file %s, cant find field index", cfgFile);
mxmlDelete(pXMLTree);
return -1;
}
const char* pSubDir = mxmlElementGetAttr(pRoot, "sub_dir");
if (NULL == pSubDir) {
TERR("config file %s, cant find field sub_dir", cfgFile);
mxmlDelete(pXMLTree);
return -1;
}
int32_t len = strlen(pPathRoot) + strlen(pSubDir) + 1;
if (len >= PATH_MAX) {
TERR("config file %s, root path + sub path len over", cfgFile);
mxmlDelete(pXMLTree);
return -1;
}
sprintf(szIdxPath, "%s/%s", pPathRoot, pSubDir);
mkdir(szIdxPath, 0755);
// 输入文件路径
const char* pInputDir = mxmlElementGetAttr(pRoot, "input_dir");
if (NULL == pInputDir) {
TERR("config file %s, cant find field input_dir", cfgFile);
mxmlDelete(pXMLTree);
return -1;
}
if (strlen(pInputDir) >= PATH_MAX) {
TERR("config file %s, input path len over", cfgFile);
mxmlDelete(pXMLTree);
return -1;
}
strcpy(szInputPath, pInputDir);
// <index_field name="title" max_occ="1" />
int32_t maxOcc = 0;
int32_t nFieldNum = 0;
ThreadPara threadPara[MAX_INDEX_FIELD_NUM]; // 每个field一个线程
mxml_node_t* cpNode = mxmlFindElement(pRoot, pRoot, "index_field", NULL, NULL, MXML_DESCEND_FIRST);
while(cpNode) {
const char* name = mxmlElementGetAttr(cpNode, "name");
const char* max_occ = mxmlElementGetAttr(cpNode, "max_occ");
if (NULL == name) {
TERR("config file %s, cant find name", cfgFile);
mxmlDelete(pXMLTree);
return -1;
}
if (NULL == max_occ) {
maxOcc = 0;
} else {
maxOcc = atol(max_occ);
}
if (cIndexBuilder.addField(name, maxOcc) < 0) {
mxmlDelete(pXMLTree);
TERR("addField %s occ=%d error", name, maxOcc);
return -1;
}
if (nFieldNum >= MAX_INDEX_FIELD_NUM) {
mxmlDelete(pXMLTree);
TERR("field num over limit=%d\n", MAX_INDEX_FIELD_NUM);
return -1;
}
snprintf(threadPara[nFieldNum].inputFile,
sizeof(threadPara[nFieldNum].inputFile), "%s/%s.idx.txt", szInputPath, name);
snprintf(threadPara[nFieldNum].fieldName,
sizeof(threadPara[nFieldNum].fieldName), name);
nFieldNum++;
cpNode = mxmlFindElement(cpNode, pRoot, "index_field", NULL, NULL, MXML_NO_DESCEND);
}
mxmlDelete(pXMLTree);
if(nFieldNum <= 0) {
TERR("config file %s, index field num = %d error", cfgFile, nFieldNum);
return -1;
}
char filename[PATH_MAX];
snprintf(filename, sizeof(filename), "%s/%s", szInputPath, "max_doc_id");
fp = fopen(filename, "rb");
if(fp) {
char buf[128];
fgets(buf, 128, fp);
fclose(fp);
max_doc_id = atol(buf);
TLOG("use max_doc_id(%u) from %s", max_doc_id, filename);
} else {
TLOG("use max_doc_id(%u) from para", max_doc_id);
}
// 准备线程参数，检测txt文件是否存在
for (int32_t i = 0; i < nFieldNum; i++) {
threadPara[i].pBuilder = &cIndexBuilder;
threadPara[i].error = 0;
if(access(threadPara[i].inputFile, 0)) {
TERR( "field %s not exit\n", threadPara[i].inputFile);
return -1;
}
}
if (cIndexBuilder.open(szIdxPath) < 0) {
TERR( "open %s error\n", szIdxPath);
return -1;
}
// 启动线程
void *retval = NULL;
int32_t threadNum = 0;
const int32_t maxThreadNum = max_thread_num;
pthread_t threadId[maxThreadNum];
for (int32_t i = 0, j = 0; i < nFieldNum; i++) {
int ret = pthread_create(&threadId[j], NULL, worker, &threadPara[i]);
if (ret!=0){
TERR("pthread_create() failed.\n");
return -1;
}
if(threadNum < maxThreadNum) {
threadNum++;
j++;
continue;
}
// 等待一个结束的
struct timespec ts;
do {
clock_gettime(CLOCK_REALTIME, &ts);
ts.tv_sec += 5;
for(j = 0; j < threadNum; j++) {
if(pthread_timedjoin_np(threadId[j], &retval, &ts)) {
continue;
}
// 线程结束
if (threadPara[i].error) {
TERR("build %s error, code=%d\n", threadPara[i].fieldName, threadPara[i].error);
}
break;
}
} while(j >= threadNum);
threadId[j] = 0;
}
// 等待其余的线程结束
for (int32_t i = 0; i < threadNum; i++) {
if(0 == threadId[i]) continue;
int ret = pthread_join(threadId[i], &retval);
if(ret != 0){
TERR("pthread_join failed.\n");
}
if (threadPara[i].error) {
TERR("build %s error, code=%d\n", threadPara[i].fieldName, threadPara[i].error);
}
}
cIndexBuilder.dump();
// close index lib
cIndexBuilder.close();
TLOG("build success, use Time = %ld\n", time(NULL) - beginTime);
return 0;
}
int /* O - Exit status */
main(int argc, /* I - Number of command-line args */
char *argv[]) /* I - Command-line args */
{
int size;
FILE *fpr;
char buffer[4096];
mxml_node_t *mtree;
mxml_node_t *root;
mxml_node_t *child;
#if 1
mxml_node_t *value;
fpr = fopen("ChineseTest.xml", "r");
if (!fpr)
return -1;
fseek(fpr, 0, SEEK_END);
size = ftell(fpr);
fseek(fpr, 0, SEEK_SET);
fread(buffer, size, 1, fpr);
printf("\n%s\n-------------------------------------\n", buffer);
mtree = mxmlLoadString(NULL, buffer, MXML_TEXT_CALLBACK);
root = mxmlFindElement(mtree, mtree, NULL, NULL, NULL, MXML_DESCEND_FIRST);
if (root)
{
printf("name : %s\n", root->value.element.name);
child = mxmlFindElement(root, root, NULL, NULL, NULL, MXML_DESCEND_FIRST);
while (child)
{
printf("name : %s\n", child->value.element.name);
value = child->child;
if (MXML_TEXT == value->type)
{
//printf("value: %s\n", value->value.text.string);
while ((NULL != value) && (MXML_TEXT == value->type) &&
(NULL != value->value.text.string))
{
printf(" text.string: [%s]\n", value->value.text.string);
value = value->next;
}
}
child = mxmlFindElement(child, child, NULL, NULL, NULL, MXML_NO_DESCEND);
}
}
mxmlDelete(mtree);
fclose(fpr);
#endif
return 0;
char chinese[32] = {0};
fpr = fopen("chinese.txt", "r");
if (!fpr)
return -1;
fseek(fpr, 0, SEEK_END);
size = ftell(fpr);
fseek(fpr, 0, SEEK_SET);
fread(chinese, size, 1, fpr);
printf("\nchinese: %s\n", chinese);
mtree = mxmlNewElement(MXML_NO_PARENT, "?xml version=\"1.0\" encoding=\"UTF-8\"?");
root = mxmlNewElement(mtree, "message");
child = mxmlNewElement(root, "child");
mxmlNewText(child, 0, chinese);
mxmlSaveString(mtree, buffer, sizeof(buffer), MXML_TEXT_CALLBACK);
printf("-------------------------------------\n%s\n", buffer);
return 0;
#if 0
int i; /* Looping var */
FILE *fp; /* File to read */
int fd; /* File descriptor */
mxml_node_t *tree, /* XML tree */
*node; /* Node which should be in test.xml */
mxml_index_t *ind; /* XML index */
char buffer[16384]; /* Save string */
static const char *types[] = /* Strings for node types */
{
"MXML_ELEMENT",
"MXML_INTEGER",
"MXML_OPAQUE",
"MXML_REAL",
"MXML_TEXT"
};
/*
* Check arguments...
*/
if (argc != 2)
{
fputs("Usage: testmxml filename.xml\n", stderr);
return (1);
}
/*
* Test the basic functionality...
*/
tree = mxmlNewElement(MXML_NO_PARENT, "element");
if (!tree)
{
fputs("ERROR: No parent node in basic test!\n", stderr);
return (1);
}
if (tree->type != MXML_ELEMENT)
{
fprintf(stderr, "ERROR: Parent has type %s (%d), expected MXML_ELEMENT!\n",
tree->type < MXML_ELEMENT || tree->type > MXML_TEXT ?
"UNKNOWN" : types[tree->type], tree->type);
mxmlDelete(tree);
return (1);
}
if (strcmp(tree->value.element.name, "element"))
{
fprintf(stderr, "ERROR: Parent value is \"%s\", expected \"element\"!\n",
tree->value.element.name);
mxmlDelete(tree);
return (1);
}
mxmlNewInteger(tree, 123);
mxmlNewOpaque(tree, "opaque");
mxmlNewReal(tree, 123.4f);
mxmlNewText(tree, 1, "text");
mxmlLoadString(tree, "<group type='string'>string string string</group>",
MXML_NO_CALLBACK);
mxmlLoadString(tree, "<group type='integer'>1 2 3</group>",
MXML_INTEGER_CALLBACK);
mxmlLoadString(tree, "<group type='real'>1.0 2.0 3.0</group>",
MXML_REAL_CALLBACK);
mxmlLoadString(tree, "<group>opaque opaque opaque</group>",
MXML_OPAQUE_CALLBACK);
node = tree->child;
if (!node)
{
fputs("ERROR: No first child node in basic test!\n", stderr);
mxmlDelete(tree);
return (1);
}
if (node->type != MXML_INTEGER)
{
fprintf(stderr, "ERROR: First child has type %s (%d), expected MXML_INTEGER!\n",
node->type < MXML_ELEMENT || node->type > MXML_TEXT ?
"UNKNOWN" : types[node->type], node->type);
mxmlDelete(tree);
return (1);
}
if (node->value.integer != 123)
{
fprintf(stderr, "ERROR: First child value is %d, expected 123!\n",
node->value.integer);
mxmlDelete(tree);
return (1);
}
node = node->next;
if (!node)
{
fputs("ERROR: No second child node in basic test!\n", stderr);
mxmlDelete(tree);
return (1);
}
if (node->type != MXML_OPAQUE)
{
fprintf(stderr, "ERROR: Second child has type %s (%d), expected MXML_OPAQUE!\n",
node->type < MXML_ELEMENT || node->type > MXML_TEXT ?
"UNKNOWN" : types[node->type], node->type);
mxmlDelete(tree);
return (1);
}
if (!node->value.opaque || strcmp(node->value.opaque, "opaque"))
{
fprintf(stderr, "ERROR: Second child value is \"%s\", expected \"opaque\"!\n",
node->value.opaque ? node->value.opaque : "(null)");
mxmlDelete(tree);
return (1);
}
node = node->next;
if (!node)
{
fputs("ERROR: No third child node in basic test!\n", stderr);
mxmlDelete(tree);
return (1);
}
if (node->type != MXML_REAL)
{
fprintf(stderr, "ERROR: Third child has type %s (%d), expected MXML_REAL!\n",
node->type < MXML_ELEMENT || node->type > MXML_TEXT ?
"UNKNOWN" : types[node->type], node->type);
mxmlDelete(tree);
return (1);
}
if (node->value.real != 123.4f)
{
fprintf(stderr, "ERROR: Third child value is %f, expected 123.4!\n",
node->value.real);
mxmlDelete(tree);
return (1);
}
node = node->next;
if (!node)
{
fputs("ERROR: No fourth child node in basic test!\n", stderr);
mxmlDelete(tree);
return (1);
}
if (node->type != MXML_TEXT)
{
fprintf(stderr, "ERROR: Fourth child has type %s (%d), expected MXML_TEXT!\n",
node->type < MXML_ELEMENT || node->type > MXML_TEXT ?
"UNKNOWN" : types[node->type], node->type);
mxmlDelete(tree);
return (1);
}
if (!node->value.text.whitespace ||
!node->value.text.string || strcmp(node->value.text.string, "text"))
{
fprintf(stderr, "ERROR: Fourth child value is %d,\"%s\", expected 1,\"text\"!\n",
node->value.text.whitespace,
node->value.text.string ? node->value.text.string : "(null)");
mxmlDelete(tree);
return (1);
}
for (i = 0; i < 4; i ++)
{
node = node->next;
if (!node)
{
fprintf(stderr, "ERROR: No group #%d child node in basic test!\n", i + 1);
mxmlDelete(tree);
return (1);
}
if (node->type != MXML_ELEMENT)
{
fprintf(stderr, "ERROR: Group child #%d has type %s (%d), expected MXML_ELEMENT!\n",
i + 1, node->type < MXML_ELEMENT || node->type > MXML_TEXT ?
"UNKNOWN" : types[node->type], node->type);
mxmlDelete(tree);
return (1);
}
}
/*
* Test indices...
*/
ind = mxmlIndexNew(tree, NULL, NULL);
if (!ind)
{
fputs("ERROR: Unable to create index of all nodes!\n", stderr);
mxmlDelete(tree);
return (1);
}
if (ind->num_nodes != 5)
{
fprintf(stderr, "ERROR: Index of all nodes contains %d "
"nodes; expected 5!\n", ind->num_nodes);
mxmlIndexDelete(ind);
mxmlDelete(tree);
return (1);
}
mxmlIndexReset(ind);
if (!mxmlIndexFind(ind, "group", NULL))
{
fputs("ERROR: mxmlIndexFind for \"group\" failed!\n", stderr);
mxmlIndexDelete(ind);
mxmlDelete(tree);
return (1);
}
mxmlIndexDelete(ind);
ind = mxmlIndexNew(tree, "group", NULL);
if (!ind)
{
fputs("ERROR: Unable to create index of groups!\n", stderr);
mxmlDelete(tree);
return (1);
}
if (ind->num_nodes != 4)
{
fprintf(stderr, "ERROR: Index of groups contains %d "
"nodes; expected 4!\n", ind->num_nodes);
mxmlIndexDelete(ind);
mxmlDelete(tree);
return (1);
}
mxmlIndexReset(ind);
if (!mxmlIndexEnum(ind))
{
fputs("ERROR: mxmlIndexEnum failed!\n", stderr);
mxmlIndexDelete(ind);
mxmlDelete(tree);
return (1);
}
mxmlIndexDelete(ind);
ind = mxmlIndexNew(tree, NULL, "type");
if (!ind)
{
fputs("ERROR: Unable to create index of type attributes!\n", stderr);
mxmlDelete(tree);
return (1);
}
if (ind->num_nodes != 3)
{
fprintf(stderr, "ERROR: Index of type attributes contains %d "
"nodes; expected 3!\n", ind->num_nodes);
mxmlIndexDelete(ind);
mxmlDelete(tree);
return (1);
}
mxmlIndexReset(ind);
if (!mxmlIndexFind(ind, NULL, "string"))
{
fputs("ERROR: mxmlIndexFind for \"string\" failed!\n", stderr);
mxmlIndexDelete(ind);
mxmlDelete(tree);
return (1);
}
mxmlIndexDelete(ind);
ind = mxmlIndexNew(tree, "group", "type");
if (!ind)
{
fputs("ERROR: Unable to create index of elements and attributes!\n", stderr);
mxmlDelete(tree);
return (1);
}
if (ind->num_nodes != 3)
{
fprintf(stderr, "ERROR: Index of elements and attributes contains %d "
"nodes; expected 3!\n", ind->num_nodes);
mxmlIndexDelete(ind);
mxmlDelete(tree);
return (1);
}
mxmlIndexReset(ind);
if (!mxmlIndexFind(ind, "group", "string"))
{
fputs("ERROR: mxmlIndexFind for \"string\" failed!\n", stderr);
mxmlIndexDelete(ind);
mxmlDelete(tree);
return (1);
}
mxmlIndexDelete(ind);
/*
* Check the mxmlDelete() works properly...
*/
for (i = 0; i < 8; i ++)
{
if (tree->child)
mxmlDelete(tree->child);
else
{
fprintf(stderr, "ERROR: Child pointer prematurely NULL on child #%d\n",
i + 1);
mxmlDelete(tree);
return (1);
}
}
if (tree->child)
{
fputs("ERROR: Child pointer not NULL after deleting all children!\n", stderr);
return (1);
}
if (tree->last_child)
{
fputs("ERROR: Last child pointer not NULL after deleting all children!\n", stderr);
return (1);
}
mxmlDelete(tree);
/*
* Open the file...
*/
if (argv[1][0] == '<')
tree = mxmlLoadString(NULL, argv[1], type_cb);
else if ((fp = fopen(argv[1], "rb")) == NULL)
{
perror(argv[1]);
return (1);
}
else
{
/*
* Read the file...
*/
tree = mxmlLoadFile(NULL, fp, type_cb);
fclose(fp);
}
if (!tree)
{
fputs("Unable to read XML file!\n", stderr);
return (1);
}
if (!strcmp(argv[1], "test.xml"))
{
/*
* Verify that mxmlFindElement() and indirectly mxmlWalkNext() work
* properly...
*/
if ((node = mxmlFindElement(tree, tree, "choice", NULL, NULL,
MXML_DESCEND)) == NULL)
{
fputs("Unable to find first <choice> element in XML tree!\n", stderr);
mxmlDelete(tree);
return (1);
}
if ((node = mxmlFindElement(node, tree, "choice", NULL, NULL,
MXML_NO_DESCEND)) == NULL)
{
fputs("Unable to find second <choice> element in XML tree!\n", stderr);
mxmlDelete(tree);
return (1);
}
}
/*
* Print the XML tree...
*/
mxmlSaveFile(tree, stdout, whitespace_cb);
/*
* Save the XML tree to a string and print it...
*/
if (mxmlSaveString(tree, buffer, sizeof(buffer), whitespace_cb) > 0)
fputs(buffer, stderr);
/*
* Delete the tree...
*/
mxmlDelete(tree);
/*
* Read from/write to file descriptors...
*/
if (argv[1][0] != '<')
{
/*
* Open the file again...
*/
if ((fd = open(argv[1], O_RDONLY | O_BINARY)) < 0)
{
perror(argv[1]);
return (1);
}
/*
* Read the file...
*/
tree = mxmlLoadFd(NULL, fd, type_cb);
close(fd);
/*
* Create filename.xmlfd...
*/
snprintf(buffer, sizeof(buffer), "%sfd", argv[1]);
if ((fd = open(buffer, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, 0666)) < 0)
{
perror(buffer);
mxmlDelete(tree);
return (1);
}
/*
* Write the file...
*/
mxmlSaveFd(tree, fd, whitespace_cb);
close(fd);
/*
* Delete the tree...
*/
mxmlDelete(tree);
}
#endif
/*
* Return...
*/
return (0);
}
int32_t SearcherWorkerFactory::initilize(const char *path)
{
ini_context_t cfg;
const ini_section_t *grp = NULL;
const char *val = NULL;
const char *seconf = NULL;
uint32_t nval = 0;
int32_t ret = 0;
if (_ready) {
return KS_SUCCESS;
}
if (!_server)
{
TERR("initialize _server error.");
return KS_EFAILED;
}
_server->_type = FRAMEWORK::srv_type_searcher;
ret = ini_load_from_file(path, &cfg);
if (unlikely(ret != 0)) {
TERR("initialize SearcherWorkerFactory by `%s' error.",
SAFE_STRING(path));
return KS_EFAILED;
}
grp = &cfg.global;
if (unlikely(!grp)) {
TERR("invalid config file `%s' for SearcherWorkerFactory.",
SAFE_STRING(path));
ini_destroy(&cfg);
return KS_EFAILED;
}
//获得搜索xml文件句柄
val = ini_get_str_value1(grp, "module_config_path");
if (val && (val[0] != '\0')) {
FILE *fp = NULL;
if ((fp = fopen(val, "r")) == NULL) {
TERR("模块配置文件 %s 打开出错, 文件可能不存在.\n", val);
ini_destroy(&cfg);
return KS_EFAILED;
}
_pXMLTree = mxmlLoadFile(NULL, fp, MXML_NO_CALLBACK);
if (_pXMLTree == NULL) {
TERR("模块配置文件 %s 格式有错, 请修正您的配置文件.\n", val);
fclose(fp);
ini_destroy(&cfg);
return KS_EFAILED;
}
fclose(fp);
}
else {
TERR("search module config path is null");
ini_destroy(&cfg);
return KS_EFAILED;
}
//各个处理模块的初始化工作
if (index_lib::init(_pXMLTree) != KS_SUCCESS) {
TERR("init index lib failed!");
ini_destroy(&cfg);
return KS_EFAILED;
}
if (_qrewiter.init(_pXMLTree) != KS_SUCCESS){
TERR("init query rewriter failed!");
ini_destroy(&cfg);
return KS_EFAILED;
}
if (_qp.init(_pXMLTree) != KS_SUCCESS){
TERR("init query parser failed!");
ini_destroy(&cfg);
return KS_EFAILED;
}
if (_is.init(_pXMLTree) != KS_SUCCESS){
TERR("init index searcher failed!");
ini_destroy(&cfg);
return KS_EFAILED;
}
if (_stat.init(_pXMLTree) != KS_SUCCESS){
TWARN("init statistic failed!");
}
//get default value of format type
_ofmt_type = get_outfmt_type(_pXMLTree);
//get sort config
val = ini_get_str_value1(grp, "sort_config_path");
if (val && (val[0] != '\0')) {
if (_sort.init(val) != KS_SUCCESS) {
TERR("init sort failed! path = %s\n", val);
ini_destroy(&cfg);
return KS_EFAILED;
}
}
else {
TERR("sort config file is error!");
ini_destroy(&cfg);
return KS_EFAILED;
}
val = ini_get_str_value1(grp, "update_config_path");
if (val && (val[0] != '\0')) {
_pIndexUpdater = new UPDATE::IndexUpdater;
int32_t nRes = -1;
if ((nRes = _pIndexUpdater->init(val)) != 0) {
TERR("init IndexUpdater failed! errno=%d", nRes);
}
else if (pthread_create(&_updateTid, NULL, UPDATE::Updater::start, _pIndexUpdater) != 0) {
TERR("start updater thread failed!");
ini_destroy(&cfg);
return KS_EFAILED;
}
}
else {
TERR("update config path is null");
}
//获得detail_module.xml文件句柄
val = ini_get_str_value1(grp, "detail_module_config_path");
if (val && (val[0] != '\0')) {
FILE *fp = NULL;
if ((fp = fopen(val, "r")) == NULL) {
TERR("模块配置文件 %s 打开出错, 文件可能不存在.\n", val);
ini_destroy(&cfg);
return KS_EFAILED;
}
_pXMLTreeDetail= mxmlLoadFile(NULL, fp, MXML_NO_CALLBACK);
if (_pXMLTreeDetail == NULL) {
TERR("模块配置文件 %s 格式有错, 请修正您的配置文件.\n", val);
fclose(fp);
ini_destroy(&cfg);
return KS_EFAILED;
}
fclose(fp);
_detail = true;
}
else {
_detail = false;
}
if(_detail)
{
//初始化detail各模块
if(di_detail_init(_pXMLTreeDetail)!=KS_SUCCESS){
TERR("di_detail_init failed!");
ini_destroy(&cfg);
return KS_EFAILED;
}
}
ini_destroy(&cfg);
_ready = true;
return KS_SUCCESS;
}
bool Symbol_ParseFile(FILE *file) {
bool result = false, set_debug;
mxml_node_t *xml_tree = NULL;
mxml_node_t *xml_symbols = NULL;
mxml_node_t *xml_symbol = NULL;
const char *debug;
xml_tree = mxmlLoadFile(NULL, file, MXML_TEXT_CALLBACK);
if (xml_tree == NULL)
goto exit_error;
/* <symbols> root element */
xml_symbols = mxmlFindElement(
xml_tree, xml_tree, "symbols", NULL, NULL, MXML_DESCEND_FIRST);
if (xml_symbols == NULL)
goto exit_error;
debug = mxmlElementGetAttr(xml_symbols, "debug");
set_debug = debug != NULL && strcmp(debug, "on") == 0;
/* <symbol name=""> element within symbols */
xml_symbol = mxmlFindElement(
xml_symbols, xml_symbols, "symbol", NULL, NULL, MXML_DESCEND_FIRST);
while (xml_symbol != NULL) {
const char *name, *size_str, *offset_str;
mxml_node_t *xml_data = NULL, *xml_reloc = NULL;
symbol_t *symbol;
uint8_t *data, *mask;
name = mxmlElementGetAttr(xml_symbol, "name");
size_str = mxmlElementGetAttr(xml_symbol, "size");
offset_str = mxmlElementGetAttr(xml_symbol, "offset");
if (name == NULL)
goto next_symbol;
symbol = Symbol_AllocSymbol(name, strlen(name));
if (symbol == NULL)
goto exit_error;
symbol->debugging = set_debug;
if (size_str != NULL) {
if (sscanf(size_str, "%" FMT_SIZE "x", &symbol->size) != 1 &&
sscanf(size_str, "%" FMT_SIZE "u", &symbol->size) != 1)
goto next_symbol;
} else
symbol->size = 0;
if (offset_str != NULL) {
if (sscanf(offset_str, "%" FMT_SIZE "x", &symbol->offset) != 1 &&
sscanf(offset_str, "%" FMT_SIZE "d", &symbol->offset) != 1)
goto next_symbol;
} else
symbol->offset = 0;
/* <data>FF</data> */
xml_data = mxmlFindElement(
xml_symbol, xml_symbol, "data", NULL, NULL, MXML_DESCEND_FIRST);
if (xml_data != NULL) {
mxml_node_t *xml_value;
size_t data_size;
unsigned int i;
data_size = 0;
xml_value = xml_data->child;
while (xml_value != NULL &&
xml_value->type == MXML_TEXT &&
xml_value->value.text.string != NULL) {
for (i = 0; xml_value->value.text.string[i] != '\0'; i++) {
switch (xml_value->value.text.string[i]) {
case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
case 'a': case 'b': case 'c':
case 'd': case 'e': case 'f':
case 'A': case 'B': case 'C':
case 'D': case 'E': case 'F':
case '?':
data_size++;
break;
case ' ': case '\t': case '\r': case '\n':
break;
default:
goto next_symbol;
}
}
xml_value = xml_value->next;
}
/* symbol must be in bytes, so two hex digits per byte! */
if (data_size % 2 != 0)
goto next_symbol;
symbol->data = data = malloc(data_size);
symbol->data_size = data_size / 2;
symbol->mask = mask = data + (data_size / 2);
if (data == NULL)
goto next_symbol;
data_size = 0;
xml_value = xml_data->child;
while (xml_value != NULL &&
xml_value->type == MXML_TEXT &&
xml_value->value.text.string != NULL) {
for (i = 0; xml_value->value.text.string[i] != '\0'; i++) {
switch (xml_value->value.text.string[i]) {
case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
data[data_size / 2] =
(data[data_size / 2] << 4) +
(xml_value->value.text.string[i] - '0');
mask[data_size / 2] =
(mask[data_size / 2] << 4) + 0xf;
data_size++;
break;
case 'a': case 'b': case 'c':
case 'd': case 'e': case 'f':
data[data_size / 2] =
(data[data_size / 2] << 4) +
(xml_value->value.text.string[i] - 'a' + 10);
mask[data_size / 2] =
(mask[data_size / 2] << 4) + 0xf;
data_size++;
break;
case 'A': case 'B': case 'C':
case 'D': case 'E': case 'F':
data[data_size / 2] =
(data[data_size / 2] << 4) +
(xml_value->value.text.string[i] - 'A' + 10);
mask[data_size / 2] =
(mask[data_size / 2] << 4) + 0xf;
data_size++;
break;
case '?':
data[data_size / 2] =
(data[data_size / 2] << 4) + 0x0;
mask[data_size / 2] =
(mask[data_size / 2] << 4) + 0x0;
data_size++;
break;
case ' ': case '\t': case '\r': case '\n':
break;
default:
assert(false);
break;
}
}
xml_value = xml_value->next;
}
} else {
symbol->data = data = NULL;
symbol->mask = mask = NULL;
symbol->data_size = 0;
}
/* <reloc type="" offset="" symbol="" /> */
xml_reloc = mxmlFindElement(
xml_symbol, xml_symbol, "reloc", NULL, NULL, MXML_DESCEND_FIRST);
while (xml_reloc != NULL) {
const char *type_str, *offset_str, *symbol_str;
symbol_relocation_t *relocation;
unsigned char type = R_PPC_NONE;
size_t offset;
const uint8_t *relocation_mask = NULL;
int i;
type_str = mxmlElementGetAttr(xml_reloc, "type");
offset_str = mxmlElementGetAttr(xml_reloc, "offset");
symbol_str = mxmlElementGetAttr(xml_reloc, "symbol");
if (type_str == NULL || offset_str == NULL)
goto next_reloc;
for (i = 0; i < SYMBOL_RELOCATION_STRINGS_COUNT; i++) {
if (strcasecmp(
type_str, symbol_relocation_strings[i].name) == 0) {
type = symbol_relocation_strings[i].relocation;
relocation_mask = symbol_relocation_strings[i].mask;
break;
}
}
if (i == SYMBOL_RELOCATION_STRINGS_COUNT)
goto next_reloc;
if (sscanf(offset_str, "%" FMT_SIZE "x", &offset) != 1 &&
sscanf(offset_str, "%" FMT_SIZE "u", &offset) != 1)
goto next_reloc;
if (offset + 4 > symbol->size)
goto next_reloc;
if (offset >= symbol->offset && mask != NULL) {
mask[offset - symbol->offset + 0] &= relocation_mask[0];
mask[offset - symbol->offset + 1] &= relocation_mask[1];
mask[offset - symbol->offset + 2] &= relocation_mask[2];
mask[offset - symbol->offset + 3] &= relocation_mask[3];
}
if (symbol_str != NULL) {
relocation = Symbol_AddRelocation(
symbol, symbol_str, type, offset);
if (relocation == NULL)
goto exit_error;
}
next_reloc:
xml_reloc = mxmlFindElement(
xml_reloc, xml_symbol, "reloc", NULL, NULL, MXML_NO_DESCEND);
}
symbol->offset += symbol->data_size;
next_symbol:
xml_symbol = mxmlFindElement(
xml_symbol, xml_symbols, "symbol", NULL, NULL, MXML_NO_DESCEND);
}
result = true;
exit_error:
mxmlDelete(xml_tree);
return result;
}
skin* conf_read(char* filepath, int* skin_nb)
{
FILE *fp;
mxml_node_t *tree;
*skin_nb = 0;
fp = fopen(filepath, "r");
tree = mxmlLoadFile(NULL, fp, MXML_OPAQUE_CALLBACK);
if(tree == NULL){
printf("Error while reading the conf file\n");
exit(EXIT_FAILURE);
}
mxml_node_t *node_root = mxmlWalkNext(tree, tree, MXML_DESCEND); //tetris (hanchor node)
mxml_node_t *node_skins = mxmlFindElement(node_root, tree, "skins", NULL, NULL, MXML_DESCEND);
mxml_node_t *node_skin; //hanchor node
for (node_skin = mxmlFindElement(node_skins, node_skins, "skin", NULL, NULL, MXML_DESCEND);
node_skin != NULL;
node_skin = mxmlFindElement(node_skin, node_skins,"skin",NULL, NULL, MXML_DESCEND))
{
(*skin_nb)++;
}
skin* p_skin = malloc(*skin_nb * sizeof(skin));
mxml_node_t *node_res; //parse each skin child nodes
int i=0;
for (node_skin = mxmlFindElement(node_skins, node_skins, "skin", NULL, NULL, MXML_DESCEND);
node_skin != NULL;
node_skin = mxmlFindElement(node_skin, node_skins,"skin",NULL, NULL, MXML_NO_DESCEND))
{
p_skin[i].name = strdup(mxmlElementGetAttr(node_skin, "name"));
for(int j = 0; p_skin[i].name[j];j++)p_skin[i].name[j]= toupper(p_skin[i].name[j]);
node_res = mxmlFindElement(node_skin, node_skins,"gfx",NULL, NULL, MXML_DESCEND);
node_res = mxmlWalkNext(node_res, tree, MXML_DESCEND); //text
p_skin[i].gfx = strdup(node_res->value.opaque);
node_res = mxmlFindElement(node_skin, node_skins,"bg",NULL, NULL, MXML_DESCEND);
node_res = mxmlWalkNext(node_res, tree, MXML_DESCEND); //text
p_skin[i].bg = strdup(node_res->value.opaque);
node_res = mxmlFindElement(node_skin, node_skins,"menu",NULL, NULL, MXML_DESCEND);
node_res = mxmlWalkNext(node_res, tree, MXML_DESCEND); //text
p_skin[i].menu = strdup(node_res->value.opaque);
node_res = mxmlFindElement(node_skin, node_skins,"music",NULL, NULL, MXML_DESCEND);
node_res = mxmlWalkNext(node_res, tree, MXML_DESCEND); //text
p_skin[i].music = strdup(node_res->value.opaque);
i++;
}
fclose(fp);
return p_skin;
}
int main (int argc, char *argv[])
{
Log log;
FILE *inFp = 0;
FILE *outFp = 0;
mxml_node_t *outTree = 0; // hold the xml input to ICAT
mxml_node_t *inTree = 0; // Hold the parameter list
try
{
// Check if my assumption of type size are correct.
// ************************************************
if(sizeof(short) != 2 || sizeof(int) != 4 )
log.set("Compiler Test", "The integer sizes are not as expected", "(short 2 bytes; int 4 bytes)").printLevel(NXING_LOG_WARNING);
if(sizeof(float) != 4 ||sizeof(double) != 8)
log.set("Compiler Test", "The float sizes are not as expected", "(float 4 bytes; double 8 bytes)").printLevel(NXING_LOG_WARNING);
char mappingFl[NXING_BIG_SIZE] = "";
char nexusFl[NXING_BIG_SIZE] = "";
char outputFl[NXING_BIG_SIZE] = "";
if(argc < 3)
{
throw log.set("main", "Not enough input parameters!", "Needs 2 input files, mapping file and the NeXus file.", "And one output file.", NXING_ERR_WRONG_INPUT);
}
else
{
if(argv[1] != 0) strcpy(mappingFl, argv[1]);
if(argv[2] != 0) strcpy(nexusFl, argv[2]);
if(argv[3] != 0) strcpy(outputFl, argv[3]);
else strcpy(outputFl, "output.xml");
}
log.set("main", "input - mapping", mappingFl).printLevel(NXING_LOG_NORMAL);
log.set("main", "input - nexus ", nexusFl).printLevel(NXING_LOG_NORMAL);
log.set("main", "input - output ", outputFl).printLevel(NXING_LOG_NORMAL);
// Read input XML Parameters.
// **************************'
#ifndef MXML_WRAP
mxmlSetWrapMargin(0);
#endif
inFp = fopen(mappingFl, "r");
if( inFp == 0 ) throw log.set("main", "Can't open the parameter file!", mappingFl, "", NXING_ERR_CANT_OPEN_PARAM);
mxml_node_t *inNode; // hold the node to read from.
inTree = mxmlLoadFile(NULL, inFp, MXML_TEXT_CALLBACK);
fclose(inFp);
inFp = 0;
if(inTree != 0) log.set("main", "The mapping file has been read!", mappingFl).printLevel(NXING_LOG_ALL);
// Create XML output to ICAT.
// **************************
outFp = fopen(outputFl, "w");
if( outFp == 0 ) throw log.set("main", "Can't open the output file!", outputFl, "", NXING_ERR_CANT_OPEN_OUTPUT);
if(inTree->type == MXML_ELEMENT && (strncmp(inTree->value.element.name, "?xml", 4) == 0)){
outTree = mxmlNewElement(MXML_NO_PARENT, inTree->value.element.name);
}
log.set("main", "Output Created, first tag added!", inTree->value.element.name).printLevel(NXING_LOG_DEBUG);
//
// Open the neXus file.
// ********************
NxClass nx(nexusFl);
//if(nx.isNotOK) throw log.set("Can't open the neXus file!", nexusFl, nx.status);
log.set("main", "NeXµs file read!", nexusFl, "", nx.status).printLevel(NXING_LOG_DEBUG);
/*
* Parse the parameter file, read the neXus file and populate the XML output.
*/
log.set("main", "Parsing the mapping file!").printLevel(NXING_LOG_DEBUG);
inNode = mxmlWalkNext(inTree, inTree, MXML_DESCEND);
parseXml(inNode, &outTree, nx);
/*
* Save the output file
*/
mxmlSaveFile(outTree, outFp, whitespace_cb);
log.set("main", "Output file Saved!", outputFl).printLevel(NXING_LOG_DEBUG);
/*
* Close the files
*/
fclose(outFp);
/*
* Delete the xml Trees
*/
mxmlDelete(inTree);
mxmlDelete(outTree);
exit(0);
}
catch(Log log)
{
log.printLevel(NXING_LOG_ERROR);
if(inFp != 0) fclose(inFp);
if(outFp != 0) fclose(outFp);
if(inTree != 0) mxmlDelete(inTree);
if(outTree != 0) mxmlDelete(outTree);
exit(0);
}
}
mxml_node_t *EventsXML::getTree() {
#include "events_xml.h" // defines and initializes char events_xml[] and int events_xml_len
char path[PATH_MAX];
mxml_node_t *xml = NULL;
FILE *fl;
// Avoid unused variable warning
(void)events_xml_len;
// Load the provided or default events xml
if (gSessionData->mEventsXMLPath) {
strncpy(path, gSessionData->mEventsXMLPath, PATH_MAX);
fl = fopen_cloexec(path, "r");
if (fl) {
xml = mxmlLoadFile(NULL, fl, MXML_NO_CALLBACK);
fclose(fl);
}
}
if (xml == NULL) {
logg->logMessage("Unable to locate events.xml, using default");
xml = mxmlLoadString(NULL, (const char *)events_xml, MXML_NO_CALLBACK);
}
// Append additional events XML
if (gSessionData->mEventsXMLAppend) {
fl = fopen_cloexec(gSessionData->mEventsXMLAppend, "r");
if (fl == NULL) {
logg->logError("Unable to open additional events XML %s", gSessionData->mEventsXMLAppend);
handleException();
}
mxml_node_t *append = mxmlLoadFile(NULL, fl, MXML_NO_CALLBACK);
fclose(fl);
mxml_node_t *events = mxmlFindElement(xml, xml, "events", NULL, NULL, MXML_DESCEND);
if (!events) {
logg->logError("Unable to find <events> node in the events.xml, please ensure the first two lines of events XML starts with:\n"
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
"<events>");
handleException();
}
XMLList *categoryList = NULL;
XMLList *eventList = NULL;
{
// Make list of all categories in xml
mxml_node_t *node = xml;
while (true) {
node = mxmlFindElement(node, xml, "category", NULL, NULL, MXML_DESCEND);
if (node == NULL) {
break;
}
categoryList = new XMLList(categoryList, node);
}
// Make list of all events in xml
node = xml;
while (true) {
node = mxmlFindElement(node, xml, "event", NULL, NULL, MXML_DESCEND);
if (node == NULL) {
break;
}
eventList = new XMLList(eventList, node);
}
}
// Handle events
for (mxml_node_t *node = mxmlFindElement(append, append, "event", NULL, NULL, MXML_DESCEND),
*next = mxmlFindElement(node, append, "event", NULL, NULL, MXML_DESCEND);
node != NULL;
node = next, next = mxmlFindElement(node, append, "event", NULL, NULL, MXML_DESCEND)) {
const char *const category = mxmlElementGetAttr(mxmlGetParent(node), "name");
const char *const title = mxmlElementGetAttr(node, "title");
const char *const name = mxmlElementGetAttr(node, "name");
if (category == NULL || title == NULL || name == NULL) {
logg->logError("Not all event XML nodes have the required title and name and parent name attributes");
handleException();
}
// Replace any duplicate events
for (XMLList *event = eventList; event != NULL; event = event->getPrev()) {
const char *const category2 = mxmlElementGetAttr(mxmlGetParent(event->getNode()), "name");
const char *const title2 = mxmlElementGetAttr(event->getNode(), "title");
const char *const name2 = mxmlElementGetAttr(event->getNode(), "name");
if (category2 == NULL || title2 == NULL || name2 == NULL) {
logg->logError("Not all event XML nodes have the required title and name and parent name attributes");
handleException();
}
if (strcmp(category, category2) == 0 && strcmp(title, title2) == 0 && strcmp(name, name2) == 0) {
logg->logMessage("Replacing counter %s %s: %s", category, title, name);
mxml_node_t *parent = mxmlGetParent(event->getNode());
mxmlDelete(event->getNode());
mxmlAdd(parent, MXML_ADD_AFTER, MXML_ADD_TO_PARENT, node);
event->setNode(node);
break;
}
}
}
// Handle categories
for (mxml_node_t *node = strcmp(mxmlGetElement(append), "category") == 0 ? append : mxmlFindElement(append, append, "category", NULL, NULL, MXML_DESCEND),
*next = mxmlFindElement(node, append, "category", NULL, NULL, MXML_DESCEND);
node != NULL;
node = next, next = mxmlFindElement(node, append, "category", NULL, NULL, MXML_DESCEND)) {
// After replacing duplicate events, a category may be empty
if (mxmlGetFirstChild(node) == NULL) {
continue;
}
const char *const name = mxmlElementGetAttr(node, "name");
if (name == NULL) {
logg->logError("Not all event XML categories have the required name attribute");
handleException();
}
// Merge identically named categories
bool merged = false;
for (XMLList *category = categoryList; category != NULL; category = category->getPrev()) {
const char *const name2 = mxmlElementGetAttr(category->getNode(), "name");
if (name2 == NULL) {
logg->logError("Not all event XML categories have the required name attribute");
handleException();
}
if (strcmp(name, name2) == 0) {
logg->logMessage("Merging category %s", name);
while (true) {
mxml_node_t *child = mxmlGetFirstChild(node);
if (child == NULL) {
break;
}
mxmlAdd(category->getNode(), MXML_ADD_AFTER, mxmlGetLastChild(category->getNode()), child);
}
merged = true;
break;
}
}
if (merged) {
continue;
}
// Add new categories
logg->logMessage("Appending category %s", name);
mxmlAdd(events, MXML_ADD_AFTER, mxmlGetLastChild(events), node);
}
XMLList::free(eventList);
XMLList::free(categoryList);
mxmlDelete(append);
}
return xml;
}
void write_brlan(char *infile, char* outfile)
{
int i;
for(i = 0; i < 16; i++)
{
memset(tag_types_list[i], 0, 24);
memset(tag_types_rlmc_list[i], 0, 24);
memset(tag_types_rlvc_list[i], 0, 24);
}
strcpy(tag_types_list[0], "X Translation");
strcpy(tag_types_list[1], "Y Translation");
strcpy(tag_types_list[2], "Z Translation");
strcpy(tag_types_list[3], "X Flip");
strcpy(tag_types_list[4], "Y Flip");
strcpy(tag_types_list[5], "Angle");
strcpy(tag_types_list[6], "X Zoom");
strcpy(tag_types_list[7], "Y Zoom");
strcpy(tag_types_list[8], "Width");
strcpy(tag_types_list[9], "Height");
strcpy(tag_types_list[10], "0x0A");
strcpy(tag_types_list[11], "0x0B");
strcpy(tag_types_list[12], "0x0C");
strcpy(tag_types_list[13], "0x0D");
strcpy(tag_types_list[14], "0x0E");
strcpy(tag_types_list[15], "0x0F");
strcpy(tag_types_rlmc_list[0], "0x00");
strcpy(tag_types_rlmc_list[1], "0x01");
strcpy(tag_types_rlmc_list[2], "0x02");
strcpy(tag_types_rlmc_list[3], "0x03");
strcpy(tag_types_rlmc_list[4], "Blackcolor R");
strcpy(tag_types_rlmc_list[5], "Blackcolor G");
strcpy(tag_types_rlmc_list[6], "Blackcolor B");
strcpy(tag_types_rlmc_list[7], "Blackcolor A");
strcpy(tag_types_rlmc_list[8], "Whitecolor R");
strcpy(tag_types_rlmc_list[9], "Whitecolor G");
strcpy(tag_types_rlmc_list[10], "Whitecolor B");
strcpy(tag_types_rlmc_list[11], "Whitecolor A");
strcpy(tag_types_rlmc_list[12], "0x0C");
strcpy(tag_types_rlmc_list[13], "0x0D");
strcpy(tag_types_rlmc_list[14], "0x0E");
strcpy(tag_types_rlmc_list[15], "0x0F");
strcpy(tag_types_rlvc_list[0], "Top Left R");
strcpy(tag_types_rlvc_list[1], "Top Left G");
strcpy(tag_types_rlvc_list[2], "Top Left B");
strcpy(tag_types_rlvc_list[3], "Top Left A");
strcpy(tag_types_rlvc_list[4], "Top Right R");
strcpy(tag_types_rlvc_list[5], "Top Right G");
strcpy(tag_types_rlvc_list[6], "Top Right B");
strcpy(tag_types_rlvc_list[7], "Top Right A");
strcpy(tag_types_rlvc_list[8], "Bottom Left R");
strcpy(tag_types_rlvc_list[9], "Bottom Left G");
strcpy(tag_types_rlvc_list[10], "Bottom Left B");
strcpy(tag_types_rlvc_list[11], "Bottom Left A");
strcpy(tag_types_rlvc_list[12], "Bottom Right R");
strcpy(tag_types_rlvc_list[13], "Bottom Right G");
strcpy(tag_types_rlvc_list[14], "Bottom Right B");
strcpy(tag_types_rlvc_list[15], "Bottom Right A");
FILE* fpx = fopen(infile, "r");
if(fpx == NULL) {
printf("xmlan couldn't be opened!\n");
exit(1);
}
mxml_node_t *hightree = mxmlLoadFile(NULL, fpx, MXML_TEXT_CALLBACK);
if(hightree == NULL) {
printf("Couldn't open hightree!\n");
exit(1);
}
mxml_node_t *tree = mxmlFindElement(hightree, hightree, "xmlan", NULL, NULL, MXML_DESCEND);
if(hightree == NULL) {
printf("Couldn't get tree!\n");
exit(1);
}
mxml_node_t *node;
FILE* fp = fopen(outfile, "wb+");
if(fpx == NULL) {
printf("destination brlan couldn't be opened!\n");
exit(1);
}
u16 blobcount = 0;
brlan_header rlanhead;
rlanhead.magic[0] = 'R';
rlanhead.magic[1] = 'L';
rlanhead.magic[2] = 'A';
rlanhead.magic[3] = 'N';
rlanhead.unk1 = 0xFEFF0008;
rlanhead.file_size = 0;
rlanhead.pai1_offset = sizeof(brlan_header);
rlanhead.pai1_count = 1;
WriteBRLANHeader(rlanhead, fp);
brlan_pai1_header_type1 paihead;
paihead.magic[0] = 'p';
paihead.magic[1] = 'a';
paihead.magic[2] = 'i';
paihead.magic[3] = '1';
paihead.size = 0;
char temp[256];
if(mxmlElementGetAttr(tree, "framesize") != NULL)
strcpy(temp, mxmlElementGetAttr(tree, "framesize"));
else{
printf("No framesize attribute found!\nDefaulting to 20.");
strcpy(temp, "20");
}
paihead.framesize = atoi(temp);
memset(temp, 0, 256);
if(mxmlElementGetAttr(tree, "flags") != NULL)
{
strcpy(temp, mxmlElementGetAttr(tree, "flags"));
} else {
printf("No flags attribute found!\nDefaulting to 1.");
paihead.flags = 1;
}
paihead.flags = atoi(temp);
paihead.unk1 = 0;
paihead.num_timgs = 0;
paihead.num_entries = 0;
paihead.entry_offset = sizeof(brlan_pai1_header_type1);
WriteBRLANPaiHeader(paihead, fp);
u32 totaltagsize = 0;
u16 timgcount = 0;
u32 totaltimgize = 0;
u32 timgnumber = 0x0;
for(node = mxmlFindElement(tree, tree, "timg", NULL, NULL, MXML_DESCEND); node != NULL; node = mxmlFindElement(node, tree, "timg", NULL, NULL, MXML_DESCEND))
{
timgnumber++;
}
u32 imageoffsets[timgnumber];
u32 imagefileoffset = ftell(fp);
for( i = 0; i < timgnumber; i++) imageoffsets[i] = imagefileoffset;
WriteBRLANOffsets(imageoffsets, timgnumber, fp);
for(node = mxmlFindElement(tree, tree, "timg", NULL, NULL, MXML_DESCEND); node != NULL; node = mxmlFindElement(node, tree, "timg", NULL, NULL, MXML_DESCEND)) {
timgcount++;
imageoffsets[timgcount-1] = ftell(fp) - imageoffsets[timgcount-1];
if(mxmlElementGetAttr(node, "name") != NULL)
strcpy(temp, mxmlElementGetAttr(node, "name"));
else{
printf("No name attribute found!\n");
exit(1);
}
fwrite(temp, strlen(temp) + 1, 1, fp);
totaltimgize += strlen(temp) + 1;
}
if ((totaltimgize % 4) != 0)
{
u8 blank[3] = {0x0, 0x0, 0x0};
fwrite(blank, (4 - (totaltimgize % 4)), 1, fp);
totaltimgize += (4 - (totaltimgize % 4));
}
u32 tempoOffset = ftell(fp);
fseek(fp, imagefileoffset, SEEK_SET);
WriteBRLANOffsets(imageoffsets, timgnumber, fp);
fseek(fp, tempoOffset, SEEK_SET);
u32 panecount = 0x0;
for(node = mxmlFindElement(tree, tree, "pane", NULL, NULL, MXML_DESCEND); node != NULL; node = mxmlFindElement(node, tree, "pane", NULL, NULL, MXML_DESCEND))
{
panecount++;
}
u32 paneoffsets[panecount];
u32 tagoffset = ftell(fp);
for(i = 0; i < panecount; i++) paneoffsets[i] = 0x10;
WriteBRLANOffsets(paneoffsets, panecount, fp);
for(node = mxmlFindElement(tree, tree, "pane", NULL, NULL, MXML_DESCEND); node != NULL; node = mxmlFindElement(node, tree, "pane", NULL, NULL, MXML_DESCEND))
{
blobcount++;
paneoffsets[blobcount-1] = ftell(fp) - paneoffsets[blobcount-1];
create_tag_from_xml(tree, node, fp);
totaltagsize = ftell(fp) - tagoffset;
}
u32 fileSize = ftell(fp);
fseek(fp, tagoffset, SEEK_SET);
WriteBRLANOffsets(paneoffsets, blobcount, fp);
paihead.num_timgs = timgcount;
paihead.entry_offset = sizeof(brlan_pai1_header_type1) + totaltimgize + (4*paihead.num_timgs);
paihead.num_entries = blobcount;
fseek(fp, 0, SEEK_END);
paihead.size = fileSize - rlanhead.pai1_offset;
rlanhead.file_size = fileSize;
fseek(fp, 0, SEEK_SET);
WriteBRLANHeader(rlanhead, fp);
WriteBRLANPaiHeader(paihead, fp);
}
void main(void)
{
FILE *fp;
char str[128];
const char *xml_path = "0:\\Zbin\\Utilities\\mxmltest\\test.xml";
fp = fopen(xml_path, "r");
if (fp == NULL)
{
sprintf(str, "Can't open file: %s", xml_path);
ShowMSG(1, (int)str);
return;
}
mxml_node_t *tree = mxmlLoadFile(NULL, fp, MXML_TEXT_CALLBACK);
fclose(fp);
if (tree == NULL)
{
ShowMSG(1, (int)"mxmlLoadFile = NULL");
return;
}
const char *log_path = "0:\\Zbin\\Log\\mxmltest.log";
fp = fopen(log_path, "a");
if (fp == NULL)
{
sprintf(str, "Can't open file: %s", log_path);
ShowMSG(1, (int)str);
mxmlDelete(tree);
return;
}
mxml_node_t *node = tree;
mxml_node_t *next = NULL;
while (node != NULL)
{
switch (mxmlGetType(node))
{
case MXML_ELEMENT:
sprintf(str, "MXML_ELEMENT = %s\n", mxmlGetElement(node));
fwrite(str, sizeof(char), strlen(str), fp);
break;
case MXML_TEXT:
sprintf(str, "MXML_TEXT = %s\n", mxmlGetText(node, 0));
fwrite(str, sizeof(char), strlen(str), fp);
break;
}
next = mxmlGetFirstChild(node);
if (next != NULL)
{
node = next;
}
else
{
next = mxmlGetNextSibling(node);
if (next == NULL)
{
next = mxmlWalkNext(node, NULL, MXML_DESCEND);
}
node = next;
}
}
fclose(fp);
mxmlDelete(tree);
}
game* game_load(char* file)
{
game* p_game = malloc(sizeof(game));
FILE *fp = NULL;
mxml_node_t *mxml_xml = NULL;
mxml_node_t *node = NULL; //parse throught the xml
mxml_node_t *node_i = NULL;
fp = fopen(file, "r");
mxml_xml = mxmlLoadFile(NULL, fp, MXML_OPAQUE_CALLBACK);
mxml_node_t *node_root = mxmlWalkNext(mxml_xml, mxml_xml, MXML_DESCEND); //state (hanchor node)
//UNIT
mxml_node_t* node_unit = mxmlFindElement(node_root, mxml_xml, "unit", NULL, NULL, MXML_DESCEND);
p_game->p_unit = unit_load_xml(mxmlElementGetAttr(node_unit, "src"));
unit_init(p_game->p_unit);
mxml_node_t* node_location = mxmlFindElement(node_unit, mxml_xml, "location", NULL, NULL, MXML_DESCEND);
p_game->p_unit->p_sprite->x = atoi(mxmlElementGetAttr(node_location, "x"));
p_game->p_unit->p_sprite->y = atoi(mxmlElementGetAttr(node_location, "y"));
node = mxmlFindElement(node_unit, mxml_xml, "HP", NULL, NULL, MXML_DESCEND);
node = mxmlWalkNext(node, mxml_xml, MXML_DESCEND); //text
if(node)p_game->p_unit->HP = atoi(node->value.opaque);
node = mxmlFindElement(node_unit, mxml_xml, "MP", NULL, NULL, MXML_DESCEND);
node = mxmlWalkNext(node, mxml_xml, MXML_DESCEND); //text
if(node)p_game->p_unit->MP = atoi(node->value.opaque);
node = mxmlFindElement(node_unit, mxml_xml, "XP", NULL, NULL, MXML_DESCEND);
node = mxmlWalkNext(node, mxml_xml, MXML_DESCEND); //text
if(node)p_game->p_unit->XP = atoi(node->value.opaque);
node = mxmlFindElement(node_unit, mxml_xml, "gold", NULL, NULL, MXML_DESCEND);
node = mxmlWalkNext(node, mxml_xml, MXML_DESCEND); //text
if(node)p_game->p_unit->gold = atoi(node->value.opaque);
p_game->name = (char*)strdup("Legend of bozo");
if(mxmlElementGetAttr(node_location, "file")){
char* name = strdup(strrchr (mxmlElementGetAttr(node_location, "file"), '/') + 1);
p_game->context = calloc(strlen(name) + 1, sizeof(char));
strcpy(p_game->context, name);
free(name);name=NULL;
p_game->nb_maps = map_load_xml_all(mxmlElementGetAttr(node_location, "file"), &p_game->p_map);
p_game->cur_map = map_get_index(mxmlElementGetAttr(node_location, "name"), p_game->p_map, p_game->nb_maps);
}else{
printf("The node location do not have a file attribut, in the xml file %s\n", file);
exit(EXIT_FAILURE);
}
//load ennemies
char* ennemie_path = calloc(strlen("./res/entities/ennemies/") + strlen(p_game->context) + 1, sizeof(char));
strcpy(ennemie_path, "./res/entities/ennemies/");
strcat(ennemie_path, p_game->context);
p_game->ennemie_nb = ennemie_load_xml_name(ennemie_path, mxmlElementGetAttr(node_location, "name"), &p_game->p_ennemie);
free(ennemie_path);ennemie_path=NULL;
//load NPCs
char* NPC_path = calloc(strlen("./res/entities/NPCs/") + strlen(p_game->context) + 1, sizeof(char));
strcpy(NPC_path, "./res/entities/NPCs/");
strcat(NPC_path, p_game->context);
p_game->NPC_nb = NPC_load_xml_name(NPC_path, mxmlElementGetAttr(node_location, "name"), &p_game->p_NPC);
free(NPC_path);NPC_path=NULL;
p_game->sound_on = 1;
//VARS
p_game->vars=NULL;
mxml_node_t* node_vars = mxmlFindElement(node_root, mxml_xml, "vars", NULL, NULL, MXML_DESCEND);
for (node_i = mxmlFindElement(node_vars, mxml_xml, "var", NULL, NULL, MXML_DESCEND);
node_i != NULL;
node_i = mxmlFindElement(node_i, mxml_xml, "var", NULL, NULL, MXML_DESCEND))
{
var* p_var = malloc(sizeof(var));
p_var->name = (char*)strdup(mxmlElementGetAttr(node_i, "name"));
p_var->value = (char*)strdup(mxmlElementGetAttr(node_i, "value"));
p_game->vars = linked_list_push_front(p_game->vars , p_var);
}
mxmlDelete(node_i);
mxmlDelete(node);
mxmlDelete(mxml_xml);
fclose(fp);
return p_game;
}
bool vrpn_libusb::loadConfigFile(std::string & configFile)
{
FILE * fp = NULL;
mxml_node_t * tree;
fp = fopen(configFile.c_str(), "r");
if(!fp)
{
std::cerr << "Unable to open config file: " << configFile << std::endl;
return false;
}
tree = mxmlLoadFile(NULL, fp, MXML_TEXT_CALLBACK);
fclose(fp);
if(!tree)
{
std::cerr << "Unable to parse XML file: " << configFile << std::endl;
return false;
}
mxml_node_t * node = mxmlFindElement(tree, tree, "USB", NULL, NULL, MXML_DESCEND);
if(!node)
{
mxmlDelete(tree);
std::cerr << "No USB tag present in config file." << std::endl;
return false;
}
const char * attribute = NULL;
attribute = mxmlElementGetAttr(node, "entry");
_entryNum = attribute ? atoi(attribute) : 0;
attribute = mxmlElementGetAttr(node, "config");
_configNum = attribute ? atoi(attribute) : 0;
attribute = mxmlElementGetAttr(node, "interface");
_interfaceNum = attribute ? atoi(attribute) : 0;
attribute = mxmlElementGetAttr(node, "altSetting");
_altSettingNum = attribute ? atoi(attribute) : 0;
attribute = mxmlElementGetAttr(node, "endpoint");
_endpointNum = attribute ? atoi(attribute) : 0;
attribute = mxmlElementGetAttr(node, "printPacket");
_printPacket = (bool)atoi(attribute);
node = mxmlFindElement(tree, tree, "Device", NULL, NULL, MXML_DESCEND);
if(node)
{
attribute = mxmlElementGetAttr(node, "vendorID");
if(attribute)
{
_vendorID = atoi(attribute);
}
attribute = mxmlElementGetAttr(node, "productID");
if(attribute)
{
_productID = atoi(attribute);
}
}
node = mxmlFindElement(tree, tree, "Buttons", NULL, NULL, MXML_DESCEND);
if(node)
{
mxml_node_t * buttonNode;
for(buttonNode = mxmlFindElement(node, node, "ButtonGroup", NULL, NULL, MXML_DESCEND); buttonNode != NULL; buttonNode = mxmlFindElement(buttonNode, node, "ButtonGroup", NULL, NULL, MXML_DESCEND))
{
ButtonGroup * bg = new ButtonGroup;
bg->value = 0;
attribute = mxmlElementGetAttr(buttonNode, "packetOffset");
bg->packetOffset = attribute ? (unsigned int)atoi(attribute) : 0;
attribute = mxmlElementGetAttr(buttonNode, "numButtons");
bg->numButtons = attribute ? (unsigned int)atoi(attribute) : 0;
if(!bg->numButtons)
{
std::cerr << "Warning: numButtons set to 0." << std::endl;
}
_buttonGroups.push_back(bg);
}
}
node = mxmlFindElement(tree, tree, "Valuators", NULL, NULL, MXML_DESCEND);
if(node)
{
mxml_node_t * valuatorNode;
for(valuatorNode = mxmlFindElement(node, node, "Valuator", NULL, NULL, MXML_DESCEND); valuatorNode != NULL; valuatorNode = mxmlFindElement(valuatorNode, node, "Valuator", NULL, NULL, MXML_DESCEND))
{
Valuator * valuator = new Valuator;
attribute = mxmlElementGetAttr(valuatorNode, "packetOffset");
valuator->packetOffset = attribute ? (unsigned int)atoi(attribute) : 0;
attribute = mxmlElementGetAttr(valuatorNode, "signed");
valuator->isSigned = (bool)atoi(attribute);
int defZero, defMin, defMax;
if(valuator->isSigned)
{
defZero = 0;
defMin = -128;
defMax = 127;
}
else
{
defZero = 127;
defMin = 0;
defMax = 255;
}
const char * zeroMin;
const char * zeroMax;
zeroMin = mxmlElementGetAttr(valuatorNode, "zeroMin");
zeroMax = mxmlElementGetAttr(valuatorNode, "zeroMax");
if(zeroMin && zeroMax)
{
valuator->zeroMin = atoi(zeroMin);
valuator->zeroMax = atoi(zeroMax);
}
else
{
attribute = mxmlElementGetAttr(valuatorNode, "zero");
if(attribute)
{
valuator->zeroMin = atoi(attribute);
valuator->zeroMax = atoi(attribute);
}
else
{
valuator->zeroMin = valuator->zeroMax = defZero;
}
}
attribute = mxmlElementGetAttr(valuatorNode, "min");
valuator->min = attribute ? atoi(attribute) : defMin;
attribute = mxmlElementGetAttr(valuatorNode, "max");
valuator->max = attribute ? atoi(attribute) : defMax;
attribute = mxmlElementGetAttr(valuatorNode, "timeout");
valuator->timeout = atof(attribute);
valuator->value = valuator->zeroMin;
_valuators.push_back(valuator);
}
}
return true;
}
/***
* TODO: LOOK AT THIS SECTION 2/21/12
* Parses through an XML file and sets the watt color of individual components?
* Called on Button Action Event....
*/
void GreenLight::setPowerColors(bool displayPower)
{
std::map< std::string, std::map< std::string, int > > componentWattsMap;
/***
* If the switch is off, revert all components colors back to their default color(?)
*/
if (!displayPower)
{
std::set< Component *>::iterator sit;
for (sit = _components.begin(); sit != _components.end(); sit++)
(*sit)->defaultColor();
return;
}
// Display power per component
FILE *fp = fopen(cvr::ConfigManager::getEntry("local",
"Plugin.GreenLight.Power", "").c_str(), "r");
if (!fp)
{ //If there is no valid entry? file?
std::cerr << "Error (setComponentColors): Cannot open \""
<< cvr::ConfigManager::getEntry("local", "Plugin.GreenLight.Power", "")
<< "\"." << std::endl;
_displayPowerCheckbox->setValue(false);
return;
}
mxml_node_t * xmlTree = mxmlLoadFile(NULL, fp, MXML_TEXT_CALLBACK);
mxml_node_t * measurements =
mxmlFindElement(xmlTree,xmlTree,"measurements",NULL,NULL,MXML_DESCEND_FIRST);
if (measurements == NULL)
{
std::cerr << "Warning: No <measurements> tag in xml power file. Aborting." << std::endl;
return;
}
mxml_node_t * sensor = mxmlFindElement(measurements,measurements,"sensor",
NULL,NULL,MXML_DESCEND_FIRST);
if (sensor)
{ // interpret xml
do
{
mxml_node_t * nameNode = mxmlFindElement(sensor,sensor,"name",
NULL,NULL,MXML_DESCEND_FIRST);
mxml_node_t * timeNode = mxmlFindElement(sensor,sensor,"time",
NULL,NULL,MXML_DESCEND_FIRST);
mxml_node_t * valueNode = mxmlFindElement(sensor,sensor,"value",
NULL,NULL,MXML_DESCEND_FIRST);
if (nameNode == NULL || nameNode->child->value.text.whitespace == 1)
{
std::cerr << "Error parsing power xml file (bad name on sensor)." << std::endl;
continue;
}
std::string name = nameNode->child->value.text.string;
if (timeNode == NULL || timeNode->child == NULL || timeNode->child->next == NULL)
{
std::cerr << "Error parsing power xml file for \"" << name <<"\" time." << std::endl;
continue;
}
std::string time = timeNode->child->value.text.string;
time += " ";
time += timeNode->child->next->value.text.string;
if (valueNode == NULL || valueNode->child->value.text.whitespace == 1)
{
std::cerr << "Error parsing power xml file for \"" << name <<"\" value." << std::endl;
continue;
}
std::string value = valueNode->child->value.text.string;
int wattage = utl::intFromString(value);
std::map< std::string, std::map< std::string, int > >::iterator mit;
if ((mit = componentWattsMap.find(name)) == componentWattsMap.end())
{
std::map<std::string, int> newMap;
newMap[time] = wattage;
componentWattsMap[name] = newMap;
}
else
{
std::map< std::string, int >::iterator tit;
if ((tit = mit->second.find(time)) == mit->second.end())
mit->second[time] = wattage;
else
tit->second += wattage;
}
} while ((sensor = mxmlWalkNext(sensor,measurements,MXML_NO_DESCEND)) != NULL);
}
std::set< Component * >::iterator sit;
for (sit = _components.begin(); sit != _components.end(); sit++)
{
std::list< osg::Vec3 > colors;
std::list< osg::Vec4 > colors4;
std::map< std::string, std::map< std::string, int > >::iterator cit;
if ((cit = componentWattsMap.find((*sit)->name)) != componentWattsMap.end())
{
std::list< int > watts;
int minWatt = 0, maxWatt = 0;
std::map< std::string, int >::iterator mit;
for (mit = cit->second.begin(); mit!= cit->second.end(); mit++)
{
watts.push_back( mit->second );
if (mit->second != 0 && (mit->second < minWatt || minWatt == 0))
minWatt = mit->second;
if (mit->second > maxWatt)
maxWatt = mit->second;
}
std::list< int >::iterator lit;
for (lit = watts.begin(); lit != watts.end(); lit++)
{
// if the magnifyRange checkbox is set to true.. use minWatt/maxWatt as the color,
// otherwise, use the current iteration's (sit) Component's color value..
if (_magnifyRangeCheckbox != NULL && _magnifyRangeCheckbox->getValue())
{
colors.push_back( wattColor(*lit, minWatt, maxWatt) );
colors4.push_back( wattColor2(*lit, minWatt, maxWatt) );
}
else
{
colors.push_back( wattColor(*lit, (*sit)->minWattage, (*sit)->maxWattage) );
colors4.push_back( wattColor2(*lit, (*sit)->minWattage, (*sit)->maxWattage) );
}
currentAnimationRef = 0;
}
}
else
{
colors.push_back( wattColor(0, (*sit)->minWattage, (*sit)->maxWattage) );
colors4.push_back( wattColor2(0, (*sit)->minWattage, (*sit)->maxWattage) );
}
// Set color of components to the vector list of colors.
// ORIGINAL CALL:: //(*sit)->setColor( colors );
(*sit)->setColor( colors4 );
}
}
int AmbaPMPage_set_params (HDF *hdf) {
int ret_code = 0;
char* file_name;
mxml_node_t *tree = NULL;
mxml_node_t *pnode = NULL;
mxml_node_t *vnode = NULL;
FILE* LOG;
file_name = hdf_get_value(hdf, "PUT.FileName", "");
send_buffer->cmd_id = SET_PRVACY_MASK;
PRIVACY_MASK *pm_in = (PRIVACY_MASK *)send_buffer->data;
if (!hdf) {
return -1;
}
do{
LOG = fopen(file_name, "r");
if (!LOG) {
ret_code = -2;
break;
}
tree = mxmlLoadFile (NULL, LOG, MXML_TEXT_CALLBACK);
if (!tree) {
ret_code= -3;
break;
}
//privacymask
pnode = mxmlFindElement(tree, tree, "privacymask", NULL, NULL, MXML_DESCEND);
if (!pnode) {
ret_code= -4;
break;
}
//pm_action
vnode = mxmlFindElement(pnode, pnode, "pm_action", NULL, NULL, MXML_DESCEND);
if(vnode) {
pm_in->action = atoi(mxmlElementGetAttr (vnode, "ul"));
} else {
ret_code= -5;
break;
}
//pm_id
vnode = mxmlFindElement(pnode, pnode, "pm_id", NULL, NULL, MXML_DESCEND);
if(vnode) {
pm_in->id = atoi(mxmlElementGetAttr (vnode, "ul"));
} else {
ret_code= -6;
break;
}
//pm_left
vnode = mxmlFindElement(pnode, pnode, "pm_left", NULL, NULL, MXML_DESCEND);
if(vnode) {
pm_in->left= atoi(mxmlElementGetAttr (vnode, "ul"));
} else {
ret_code= -7;
break;
}
//pm_top
vnode = mxmlFindElement(pnode, pnode, "pm_top", NULL, NULL, MXML_DESCEND);
if(vnode) {
pm_in->top = atoi(mxmlElementGetAttr (vnode, "ul"));
} else {
ret_code= -8;
break;
}
//pm_w
vnode = mxmlFindElement(pnode, pnode, "pm_w", NULL, NULL, MXML_DESCEND);
if(vnode) {
pm_in->width = atoi(mxmlElementGetAttr (vnode, "ul"));
} else {
ret_code= -9;
break;
}
//pm_h
vnode = mxmlFindElement(pnode, pnode, "pm_h", NULL, NULL, MXML_DESCEND);
if(vnode) {
pm_in->height = atoi(mxmlElementGetAttr (vnode, "ul"));
} else {
ret_code= -10;
break;
}
#if 0
//pm_color
vnode = mxmlFindElement(pnode, pnode, "pm_color", NULL, NULL, MXML_DESCEND);
if(vnode) {
pm_in->color = atoi(mxmlElementGetAttr (vnode, "ul"));
} else {
ret_code= -10;
break;
}
pm_in->unit = 0;
#endif
} while(0);
//check point validity, but not check ret code
if (LOG) {
fclose(LOG);
remove(file_name);
}
if (tree) {
mxmlDelete(tree);
}
return ret_code ;
}
int /* O - Exit status */
main(int argc, /* I - Number of command-line args */
char *argv[]) /* I - Command-line args */
{
int i; /* Looping var */
FILE *fp; /* File to read */
int fd; /* File descriptor */
mxml_node_t *tree, /* XML tree */
*node; /* Node which should be in test.xml */
mxml_index_t *ind; /* XML index */
char buffer[16384]; /* Save string */
static const char *types[] = /* Strings for node types */
{
"MXML_ELEMENT",
"MXML_INTEGER",
"MXML_OPAQUE",
"MXML_REAL",
"MXML_TEXT"
};
/*
* Check arguments...
*/
if (argc != 2)
{
fputs("Usage: testmxml filename.xml\n", stderr);
return (1);
}
/*
* Test the basic functionality...
*/
tree = mxmlNewElement(MXML_NO_PARENT, "element");
if (!tree)
{
fputs("ERROR: No parent node in basic test!\n", stderr);
return (1);
}
if (tree->type != MXML_ELEMENT)
{
fprintf(stderr, "ERROR: Parent has type %s (%d), expected MXML_ELEMENT!\n",
tree->type < MXML_ELEMENT || tree->type > MXML_TEXT ?
"UNKNOWN" : types[tree->type], tree->type);
mxmlDelete(tree);
return (1);
}
if (strcmp(tree->value.element.name, "element"))
{
fprintf(stderr, "ERROR: Parent value is \"%s\", expected \"element\"!\n",
tree->value.element.name);
mxmlDelete(tree);
return (1);
}
mxmlNewInteger(tree, 123);
mxmlNewOpaque(tree, "opaque");
mxmlNewReal(tree, 123.4f);
mxmlNewText(tree, 1, "text");
mxmlLoadString(tree, "<group type='string'>string string string</group>",
MXML_NO_CALLBACK);
mxmlLoadString(tree, "<group type='integer'>1 2 3</group>",
MXML_INTEGER_CALLBACK);
mxmlLoadString(tree, "<group type='real'>1.0 2.0 3.0</group>",
MXML_REAL_CALLBACK);
mxmlLoadString(tree, "<group>opaque opaque opaque</group>",
MXML_OPAQUE_CALLBACK);
node = tree->child;
if (!node)
{
fputs("ERROR: No first child node in basic test!\n", stderr);
mxmlDelete(tree);
return (1);
}
if (node->type != MXML_INTEGER)
{
fprintf(stderr, "ERROR: First child has type %s (%d), expected MXML_INTEGER!\n",
node->type < MXML_ELEMENT || node->type > MXML_TEXT ?
"UNKNOWN" : types[node->type], node->type);
mxmlDelete(tree);
return (1);
}
if (node->value.integer != 123)
{
fprintf(stderr, "ERROR: First child value is %d, expected 123!\n",
node->value.integer);
mxmlDelete(tree);
return (1);
}
node = node->next;
if (!node)
{
fputs("ERROR: No second child node in basic test!\n", stderr);
mxmlDelete(tree);
return (1);
}
if (node->type != MXML_OPAQUE)
{
fprintf(stderr, "ERROR: Second child has type %s (%d), expected MXML_OPAQUE!\n",
node->type < MXML_ELEMENT || node->type > MXML_TEXT ?
"UNKNOWN" : types[node->type], node->type);
mxmlDelete(tree);
return (1);
}
if (!node->value.opaque || strcmp(node->value.opaque, "opaque"))
{
fprintf(stderr, "ERROR: Second child value is \"%s\", expected \"opaque\"!\n",
node->value.opaque ? node->value.opaque : "(null)");
mxmlDelete(tree);
return (1);
}
node = node->next;
if (!node)
{
fputs("ERROR: No third child node in basic test!\n", stderr);
mxmlDelete(tree);
return (1);
}
if (node->type != MXML_REAL)
{
fprintf(stderr, "ERROR: Third child has type %s (%d), expected MXML_REAL!\n",
node->type < MXML_ELEMENT || node->type > MXML_TEXT ?
"UNKNOWN" : types[node->type], node->type);
mxmlDelete(tree);
return (1);
}
if (node->value.real != 123.4f)
{
fprintf(stderr, "ERROR: Third child value is %f, expected 123.4!\n",
node->value.real);
mxmlDelete(tree);
return (1);
}
node = node->next;
if (!node)
{
fputs("ERROR: No fourth child node in basic test!\n", stderr);
mxmlDelete(tree);
return (1);
}
if (node->type != MXML_TEXT)
{
fprintf(stderr, "ERROR: Fourth child has type %s (%d), expected MXML_TEXT!\n",
node->type < MXML_ELEMENT || node->type > MXML_TEXT ?
"UNKNOWN" : types[node->type], node->type);
mxmlDelete(tree);
return (1);
}
if (!node->value.text.whitespace ||
!node->value.text.string || strcmp(node->value.text.string, "text"))
{
fprintf(stderr, "ERROR: Fourth child value is %d,\"%s\", expected 1,\"text\"!\n",
node->value.text.whitespace,
node->value.text.string ? node->value.text.string : "(null)");
mxmlDelete(tree);
return (1);
}
for (i = 0; i < 4; i ++)
{
node = node->next;
if (!node)
{
fprintf(stderr, "ERROR: No group #%d child node in basic test!\n", i + 1);
mxmlDelete(tree);
return (1);
}
if (node->type != MXML_ELEMENT)
{
fprintf(stderr, "ERROR: Group child #%d has type %s (%d), expected MXML_ELEMENT!\n",
i + 1, node->type < MXML_ELEMENT || node->type > MXML_TEXT ?
"UNKNOWN" : types[node->type], node->type);
mxmlDelete(tree);
return (1);
}
}
/*
* Test indices...
*/
ind = mxmlIndexNew(tree, NULL, NULL);
if (!ind)
{
fputs("ERROR: Unable to create index of all nodes!\n", stderr);
mxmlDelete(tree);
return (1);
}
if (ind->num_nodes != 5)
{
fprintf(stderr, "ERROR: Index of all nodes contains %d "
"nodes; expected 5!\n", ind->num_nodes);
mxmlIndexDelete(ind);
mxmlDelete(tree);
return (1);
}
mxmlIndexReset(ind);
if (!mxmlIndexFind(ind, "group", NULL))
{
fputs("ERROR: mxmlIndexFind for \"group\" failed!\n", stderr);
mxmlIndexDelete(ind);
mxmlDelete(tree);
return (1);
}
mxmlIndexDelete(ind);
ind = mxmlIndexNew(tree, "group", NULL);
if (!ind)
{
fputs("ERROR: Unable to create index of groups!\n", stderr);
mxmlDelete(tree);
return (1);
}
if (ind->num_nodes != 4)
{
fprintf(stderr, "ERROR: Index of groups contains %d "
"nodes; expected 4!\n", ind->num_nodes);
mxmlIndexDelete(ind);
mxmlDelete(tree);
return (1);
}
mxmlIndexReset(ind);
if (!mxmlIndexEnum(ind))
{
fputs("ERROR: mxmlIndexEnum failed!\n", stderr);
mxmlIndexDelete(ind);
mxmlDelete(tree);
return (1);
}
mxmlIndexDelete(ind);
ind = mxmlIndexNew(tree, NULL, "type");
if (!ind)
{
fputs("ERROR: Unable to create index of type attributes!\n", stderr);
mxmlDelete(tree);
return (1);
}
if (ind->num_nodes != 3)
{
fprintf(stderr, "ERROR: Index of type attributes contains %d "
"nodes; expected 3!\n", ind->num_nodes);
mxmlIndexDelete(ind);
mxmlDelete(tree);
return (1);
}
mxmlIndexReset(ind);
if (!mxmlIndexFind(ind, NULL, "string"))
{
fputs("ERROR: mxmlIndexFind for \"string\" failed!\n", stderr);
mxmlIndexDelete(ind);
mxmlDelete(tree);
return (1);
}
mxmlIndexDelete(ind);
ind = mxmlIndexNew(tree, "group", "type");
if (!ind)
{
fputs("ERROR: Unable to create index of elements and attributes!\n", stderr);
mxmlDelete(tree);
return (1);
}
if (ind->num_nodes != 3)
{
fprintf(stderr, "ERROR: Index of elements and attributes contains %d "
"nodes; expected 3!\n", ind->num_nodes);
mxmlIndexDelete(ind);
mxmlDelete(tree);
return (1);
}
mxmlIndexReset(ind);
if (!mxmlIndexFind(ind, "group", "string"))
{
fputs("ERROR: mxmlIndexFind for \"string\" failed!\n", stderr);
mxmlIndexDelete(ind);
mxmlDelete(tree);
return (1);
}
mxmlIndexDelete(ind);
/*
* Check the mxmlDelete() works properly...
*/
for (i = 0; i < 8; i ++)
{
if (tree->child)
mxmlDelete(tree->child);
else
{
fprintf(stderr, "ERROR: Child pointer prematurely NULL on child #%d\n",
i + 1);
mxmlDelete(tree);
return (1);
}
}
if (tree->child)
{
fputs("ERROR: Child pointer not NULL after deleting all children!\n", stderr);
return (1);
}
if (tree->last_child)
{
fputs("ERROR: Last child pointer not NULL after deleting all children!\n", stderr);
return (1);
}
mxmlDelete(tree);
/*
* Open the file...
*/
if (argv[1][0] == '<')
tree = mxmlLoadString(NULL, argv[1], type_cb);
else if ((fp = fopen(argv[1], "rb")) == NULL)
{
perror(argv[1]);
return (1);
}
else
{
/*
* Read the file...
*/
tree = mxmlLoadFile(NULL, fp, type_cb);
fclose(fp);
}
if (!tree)
{
fputs("Unable to read XML file!\n", stderr);
return (1);
}
if (!strcmp(argv[1], "test.xml"))
{
/*
* Verify that mxmlFindElement() and indirectly mxmlWalkNext() work
* properly...
*/
if ((node = mxmlFindElement(tree, tree, "choice", NULL, NULL,
MXML_DESCEND)) == NULL)
{
fputs("Unable to find first <choice> element in XML tree!\n", stderr);
mxmlDelete(tree);
return (1);
}
if ((node = mxmlFindElement(node, tree, "choice", NULL, NULL,
MXML_NO_DESCEND)) == NULL)
{
fputs("Unable to find second <choice> element in XML tree!\n", stderr);
mxmlDelete(tree);
return (1);
}
}
/*
* Print the XML tree...
*/
mxmlSaveFile(tree, stdout, whitespace_cb);
/*
* Save the XML tree to a string and print it...
*/
if (mxmlSaveString(tree, buffer, sizeof(buffer), whitespace_cb) > 0)
fputs(buffer, stderr);
/*
* Delete the tree...
*/
mxmlDelete(tree);
/*
* Read from/write to file descriptors...
*/
if (argv[1][0] != '<')
{
/*
* Open the file again...
*/
if ((fd = open(argv[1], O_RDONLY | O_BINARY)) < 0)
{
perror(argv[1]);
return (1);
}
/*
* Read the file...
*/
tree = mxmlLoadFd(NULL, fd, type_cb);
close(fd);
/*
* Create filename.xmlfd...
*/
snprintf(buffer, sizeof(buffer), "%sfd", argv[1]);
if ((fd = open(buffer, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, 0666)) < 0)
{
perror(buffer);
mxmlDelete(tree);
return (1);
}
/*
* Write the file...
*/
mxmlSaveFd(tree, fd, whitespace_cb);
close(fd);
/*
* Delete the tree...
*/
mxmlDelete(tree);
}
/*
* Test SAX methods...
*/
memset(event_counts, 0, sizeof(event_counts));
if (argv[1][0] == '<')
tree = mxmlSAXLoadString(NULL, argv[1], type_cb, sax_cb, NULL);
else if ((fp = fopen(argv[1], "rb")) == NULL)
{
perror(argv[1]);
return (1);
}
else
{
/*
* Read the file...
*/
tree = mxmlSAXLoadFile(NULL, fp, type_cb, sax_cb, NULL);
fclose(fp);
}
if (!strcmp(argv[1], "test.xml"))
{
if (event_counts[MXML_SAX_CDATA] != 1)
{
fprintf(stderr, "MXML_SAX_CDATA seen %d times, expected 1 times!\n",
event_counts[MXML_SAX_CDATA]);
return (1);
}
if (event_counts[MXML_SAX_COMMENT] != 1)
{
fprintf(stderr, "MXML_SAX_COMMENT seen %d times, expected 1 times!\n",
event_counts[MXML_SAX_COMMENT]);
return (1);
}
if (event_counts[MXML_SAX_DATA] != 61)
{
fprintf(stderr, "MXML_SAX_DATA seen %d times, expected 61 times!\n",
event_counts[MXML_SAX_DATA]);
return (1);
}
if (event_counts[MXML_SAX_DIRECTIVE] != 1)
{
fprintf(stderr, "MXML_SAX_DIRECTIVE seen %d times, expected 1 times!\n",
event_counts[MXML_SAX_DIRECTIVE]);
return (1);
}
if (event_counts[MXML_SAX_ELEMENT_CLOSE] != 20)
{
fprintf(stderr, "MXML_SAX_ELEMENT_CLOSE seen %d times, expected 20 times!\n",
event_counts[MXML_SAX_ELEMENT_CLOSE]);
return (1);
}
if (event_counts[MXML_SAX_ELEMENT_OPEN] != 20)
{
fprintf(stderr, "MXML_SAX_ELEMENT_OPEN seen %d times, expected 20 times!\n",
event_counts[MXML_SAX_ELEMENT_OPEN]);
return (1);
}
}
/*
* Return...
*/
return (0);
}
int BCF_Read(bcf_t* bcf, const char* filename)
{
FILE *fp;
mxml_node_t *node, *text;
int i;
if(bcf->filename != NULL) {
free(bcf->filename);
}
bcf->filename = strdup(filename);
fp = fopen(filename, "r");
if(fp == NULL) {
fprintf(stderr, "Error opening config file %s for reading.\n", filename);
return -1;
}
bcf->root = mxmlLoadFile(NULL, fp, MXML_TEXT_CALLBACK);
fclose(fp);
/* Now walk through the file and get all the children */
for(i = 0, node = mxmlFindElement(bcf->root, bcf->root,
"child",
NULL,
NULL,
MXML_DESCEND);
node != NULL;
node = mxmlFindElement(node, bcf->root,
"child",
NULL,
NULL,
MXML_DESCEND), i++
)
{
text = mxmlGetFirstChild(node);
bcf->entries[i] = strdup(mxmlGetText(text, NULL));
}
bcf->num = i;
/* Now read all the dongles */
for(i = 0, node = mxmlFindElement(bcf->root, bcf->root,
"dongle",
NULL,
NULL,
MXML_DESCEND);
node != NULL;
node = mxmlFindElement(node, bcf->root,
"dongle",
NULL,
NULL,
MXML_DESCEND), i++
)
{
text = mxmlGetFirstChild(node);
bcf->dongles[i] = strdup(mxmlGetText(text, NULL));
}
bcf->numDongles = i;
/* Clean everything up */
mxmlDelete(bcf->root);
bcf->root = NULL;
return 0;
}
std::unique_ptr<mxml_node_t, void (*)(mxml_node_t *)> getTree(lib::Span<const GatorCpu> clusters)
{
#include "events_xml.h" // defines and initializes char events_xml[] and int events_xml_len
char path[PATH_MAX];
mxml_node_t *xml = NULL;
FILE *fl;
// Avoid unused variable warning
(void) events_xml_len;
// Load the provided or default events xml
if (gSessionData.mEventsXMLPath) {
strncpy(path, gSessionData.mEventsXMLPath, PATH_MAX);
fl = lib::fopen_cloexec(path, "r");
if (fl) {
xml = mxmlLoadFile(NULL, fl, MXML_NO_CALLBACK);
if (xml == NULL) {
logg.logError("Unable to parse %s", gSessionData.mEventsXMLPath);
handleException();
}
fclose(fl);
}
}
if (xml == NULL) {
logg.logMessage("Unable to locate events.xml, using default");
xml = mxmlLoadString(NULL, reinterpret_cast<const char *>(events_xml), MXML_NO_CALLBACK);
}
// Append additional events XML
if (gSessionData.mEventsXMLAppend) {
fl = lib::fopen_cloexec(gSessionData.mEventsXMLAppend, "r");
if (fl == NULL) {
logg.logError("Unable to open additional events XML %s", gSessionData.mEventsXMLAppend);
handleException();
}
mxml_node_t *append = mxmlLoadFile(NULL, fl, MXML_NO_CALLBACK);
if (append == NULL) {
logg.logError("Unable to parse %s", gSessionData.mEventsXMLAppend);
handleException();
}
fclose(fl);
mxml_node_t *events = mxmlFindElement(xml, xml, TAG_EVENTS, NULL, NULL, MXML_DESCEND);
if (!events) {
logg.logError("Unable to find <events> node in the events.xml, please ensure the first two lines of events XML starts with:\n"
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
"<events>");
handleException();
}
XMLList *categoryList = NULL;
XMLList *eventList = NULL;
XMLList *counterSetList = NULL;
{
// Make list of all categories in xml
mxml_node_t *node = xml;
while (true) {
node = mxmlFindElement(node, xml, TAG_CATEGORY, NULL, NULL, MXML_DESCEND);
if (node == NULL) {
break;
}
categoryList = new XMLList(categoryList, node);
}
// Make list of all events in xml
node = xml;
while (true) {
node = mxmlFindElement(node, xml, TAG_EVENT, NULL, NULL, MXML_DESCEND);
if (node == NULL) {
break;
}
eventList = new XMLList(eventList, node);
}
// Make list of all counter_sets in xml
node = xml;
while (true) {
node = mxmlFindElement(node, xml, TAG_COUNTER_SET, NULL, NULL, MXML_DESCEND);
if (node == NULL) {
break;
}
counterSetList = new XMLList(counterSetList, node);
}
}
// Handle counter_sets
for (mxml_node_t *node =
strcmp(mxmlGetElement(append), TAG_COUNTER_SET) == 0 ?
append : mxmlFindElement(append, append, TAG_COUNTER_SET, NULL, NULL, MXML_DESCEND),
*next = mxmlFindElement(node, append, TAG_COUNTER_SET, NULL, NULL, MXML_DESCEND); node != NULL;
node = next, next = mxmlFindElement(node, append, TAG_COUNTER_SET, NULL, NULL, MXML_DESCEND)) {
const char * const name = mxmlElementGetAttr(node, ATTR_NAME);
if (name == NULL) {
logg.logError("Not all event XML counter_sets have the required name attribute");
handleException();
}
// Replace any duplicate counter_sets
bool replaced = false;
for (XMLList *counterSet = counterSetList; counterSet != NULL; counterSet = counterSet->getPrev()) {
const char * const name2 = mxmlElementGetAttr(counterSet->getNode(), ATTR_NAME);
if (name2 == NULL) {
logg.logError("Not all event XML nodes have the required title and name and parent name attributes");
handleException();
}
if (strcmp(name, name2) == 0) {
logg.logMessage("Replacing counter %s", name);
mxml_node_t *parent = mxmlGetParent(counterSet->getNode());
mxmlDelete(counterSet->getNode());
mxmlAdd(parent, MXML_ADD_AFTER, MXML_ADD_TO_PARENT, node);
counterSet->setNode(node);
replaced = true;
break;
}
}
if (replaced) {
continue;
}
// Add new counter_sets
logg.logMessage("Appending counter_set %s", name);
mxmlAdd(events, MXML_ADD_AFTER, mxmlGetLastChild(events), node);
}
// Handle events
for (mxml_node_t *node = mxmlFindElement(append, append, TAG_EVENT, NULL, NULL, MXML_DESCEND),
*next = mxmlFindElement(node, append, TAG_EVENT, NULL, NULL, MXML_DESCEND); node != NULL;
node = next, next = mxmlFindElement(node, append, TAG_EVENT, NULL, NULL, MXML_DESCEND)) {
const char * const category = mxmlElementGetAttr(mxmlGetParent(node), ATTR_NAME);
const char * const title = mxmlElementGetAttr(node, ATTR_TITLE);
const char * const name = mxmlElementGetAttr(node, ATTR_NAME);
if (category == NULL || title == NULL || name == NULL) {
logg.logError("Not all event XML nodes have the required title and name and parent name attributes");
handleException();
}
// Replace any duplicate events
for (XMLList *event = eventList; event != NULL; event = event->getPrev()) {
const char * const category2 = mxmlElementGetAttr(mxmlGetParent(event->getNode()), ATTR_NAME);
const char * const title2 = mxmlElementGetAttr(event->getNode(), ATTR_TITLE);
const char * const name2 = mxmlElementGetAttr(event->getNode(), ATTR_NAME);
if (category2 == NULL || title2 == NULL || name2 == NULL) {
logg.logError("Not all event XML nodes have the required title and name and parent name attributes");
handleException();
}
if (strcmp(category, category2) == 0 && strcmp(title, title2) == 0 && strcmp(name, name2) == 0) {
logg.logMessage("Replacing counter %s %s: %s", category, title, name);
mxml_node_t *parent = mxmlGetParent(event->getNode());
mxmlDelete(event->getNode());
mxmlAdd(parent, MXML_ADD_AFTER, MXML_ADD_TO_PARENT, node);
event->setNode(node);
break;
}
}
}
// Handle categories
for (mxml_node_t *node =
strcmp(mxmlGetElement(append), TAG_CATEGORY) == 0 ?
append : mxmlFindElement(append, append, TAG_CATEGORY, NULL, NULL, MXML_DESCEND),
*next = mxmlFindElement(node, append, TAG_CATEGORY, NULL, NULL, MXML_DESCEND); node != NULL;
node = next, next = mxmlFindElement(node, append, TAG_CATEGORY, NULL, NULL, MXML_DESCEND)) {
// After replacing duplicate events, a category may be empty
if (mxmlGetFirstChild(node) == NULL) {
continue;
}
const char * const name = mxmlElementGetAttr(node, ATTR_NAME);
if (name == NULL) {
logg.logError("Not all event XML category nodes have the required name attribute");
handleException();
}
// Merge identically named categories
bool merged = false;
for (XMLList *category = categoryList; category != NULL; category = category->getPrev()) {
const char * const name2 = mxmlElementGetAttr(category->getNode(), ATTR_NAME);
if (name2 == NULL) {
logg.logError("Not all event XML category nodes have the required name attribute");
handleException();
}
if (strcmp(name, name2) == 0) {
logg.logMessage("Merging category %s", name);
while (true) {
mxml_node_t *child = mxmlGetFirstChild(node);
if (child == NULL) {
break;
}
mxmlAdd(category->getNode(), MXML_ADD_AFTER, mxmlGetLastChild(category->getNode()), child);
}
merged = true;
break;
}
}
if (merged) {
continue;
}
// Add new categories
logg.logMessage("Appending category %s", name);
mxmlAdd(events, MXML_ADD_AFTER, mxmlGetLastChild(events), node);
}
XMLList::free(eventList);
XMLList::free(categoryList);
XMLList::free(counterSetList);
mxmlDelete(append);
}
// Resolve ${cluster}
for (mxml_node_t *node = mxmlFindElement(xml, xml, TAG_EVENT, NULL, NULL, MXML_DESCEND), *next = mxmlFindElement(
node, xml, TAG_EVENT, NULL, NULL, MXML_DESCEND); node != NULL;
node = next, next = mxmlFindElement(node, xml, TAG_EVENT, NULL, NULL, MXML_DESCEND)) {
const char *counter = mxmlElementGetAttr(node, ATTR_COUNTER);
if (counter != NULL && strncmp(counter, CLUSTER_VAR, sizeof(CLUSTER_VAR) - 1) == 0) {
for (const GatorCpu & cluster : clusters) {
mxml_node_t *n = mxmlNewElement(mxmlGetParent(node), TAG_EVENT);
copyMxmlElementAttrs(n, node);
char buf[1 << 7];
snprintf(buf, sizeof(buf), "%s%s", cluster.getPmncName(),
counter + sizeof(CLUSTER_VAR) - 1);
mxmlElementSetAttr(n, ATTR_COUNTER, buf);
}
mxmlDelete(node);
}
}
return {xml, &mxmlDelete};
}
int AmbaIQPage_set_params (HDF *hdf) {
int ret_code = 0;
char* file_name;
FILE* LOG;
mxml_node_t *tree = NULL;
mxml_node_t *pnode = NULL;
mxml_node_t *vnode = NULL;
file_name = hdf_get_value(hdf, "PUT.FileName", "");
send_buffer->cmd_id = SET_IQ;
IMG_QUALITY *iq = (IMG_QUALITY *)send_buffer->data;
if (!hdf) {
return -1;
}
do{
LOG = fopen(file_name, "r");
if (!LOG) {
ret_code = -2;
break;
}
tree = mxmlLoadFile (NULL, LOG, MXML_TEXT_CALLBACK);
if (!tree) {
ret_code = -18;
break;
}
//iq
pnode = mxmlFindElement(tree, tree, "imagequality", NULL, NULL, MXML_DESCEND);
if (!pnode) {
ret_code= -3;
break;
}
//wb
vnode = mxmlFindElement(pnode, pnode, "wb", NULL, NULL, MXML_DESCEND);
if(vnode) {
iq->wbc = atoi(mxmlElementGetAttr (vnode, "ul"));
} else {
ret_code= -4;
break;
}
//shuttermax
vnode = mxmlFindElement(pnode, pnode, "shuttermax", NULL, NULL, MXML_DESCEND);
if(vnode) {
iq->shutter_max = atoi(mxmlElementGetAttr (vnode, "ul"));
} else {
ret_code= -5;
break;
}
//shuttermin
vnode = mxmlFindElement(pnode, pnode, "shuttermin", NULL, NULL, MXML_DESCEND);
if(vnode) {
iq->shutter_min = atoi(mxmlElementGetAttr (vnode, "ul"));
} else {
ret_code= -6;
break;
}
//sharpness
vnode = mxmlFindElement(pnode, pnode, "sharpness", NULL, NULL, MXML_DESCEND);
if(vnode) {
iq->shapenness = atoi(mxmlElementGetAttr (vnode, "ul"));
} else {
ret_code= -7;
break;
}
//contrast
vnode = mxmlFindElement(pnode, pnode, "contrast", NULL, NULL, MXML_DESCEND);
if(vnode) {
iq->contrast = atoi(mxmlElementGetAttr (vnode, "ul"));
} else {
ret_code= -7;
break;
}
//brightness
vnode = mxmlFindElement(pnode, pnode, "brightness", NULL, NULL, MXML_DESCEND);
if(vnode) {
iq->brightness = atoi(mxmlElementGetAttr (vnode, "ul"));
} else {
ret_code= -9;
break;
}
//saturation
vnode = mxmlFindElement(pnode, pnode, "saturation", NULL, NULL, MXML_DESCEND);
if(vnode) {
iq->saturation = atoi(mxmlElementGetAttr (vnode, "ul"));
} else {
ret_code= -10;
break;
}
//maxgain
vnode = mxmlFindElement(pnode, pnode, "maxgain", NULL, NULL, MXML_DESCEND);
if(vnode) {
iq->max_gain = atoi(mxmlElementGetAttr (vnode, "ul"));
} else {
ret_code= -11;
break;
}
//antiflicker
vnode = mxmlFindElement(pnode, pnode, "antiflicker", NULL, NULL, MXML_DESCEND);
if(vnode) {
iq->antiflicker = atoi(mxmlElementGetAttr (vnode, "ul"));
} else {
ret_code= -12;
break;
}
//irismode
vnode = mxmlFindElement(pnode, pnode, "irismode", NULL, NULL, MXML_DESCEND);
if(vnode) {
iq->dc_iris_mode = atoi(mxmlElementGetAttr (vnode, "ul"));
} else {
ret_code= -13;
break;
}
//exptargetfac
vnode = mxmlFindElement(pnode, pnode, "exptargetfac", NULL, NULL, MXML_DESCEND);
if(vnode) {
iq->exposure_target_factor = atoi(mxmlElementGetAttr (vnode, "ul"));
} else {
ret_code= -15;
break;
}
//compensation
vnode = mxmlFindElement(pnode, pnode, "compensation", NULL, NULL, MXML_DESCEND);
if(vnode) {
iq->backlight_comp = atoi(mxmlElementGetAttr (vnode, "ul"));
} else {
ret_code= -16;
break;
}
//exposure
vnode = mxmlFindElement(pnode, pnode, "exposure", NULL, NULL, MXML_DESCEND);
if(vnode) {
iq->exposure_mode = atoi(mxmlElementGetAttr (vnode, "ul"));
} else {
ret_code= -17;
break;
}
//filter
vnode = mxmlFindElement(pnode, pnode, "filter", NULL, NULL, MXML_DESCEND);
if(vnode) {
iq->denoise_filter = atoi(mxmlElementGetAttr (vnode, "ul"));
} else {
ret_code= -18;
break;
}
//dnmode
vnode = mxmlFindElement(pnode, pnode, "dnmode", NULL, NULL, MXML_DESCEND);
if(vnode) {
iq->dn_mode = atoi(mxmlElementGetAttr (vnode, "ul"));
} else {
ret_code= -19;
break;
}
} while(0);
//check point validity, but not check ret code
if (LOG) {
fclose(LOG);
remove(file_name);
}
if (tree) {
mxmlDelete(tree);
}
return ret_code ;
}
bool OpenXMLFile(char *filename) {
//if (xmldebug) dbg_time1();
if (xml_loaded)
return false;
gameinfo = gameinfo_reset;
nodedata=NULL;
nodetree=NULL;
nodeid=NULL;
nodeidtmp=NULL;
nodefound=NULL;
char* strresult = strstr(filename,".zip");
if (strresult == NULL) {
/* Load XML file */
FILE *filexml;
filexml = fopen(filename, "rb");
if (!filexml)
return false;
nodetree = mxmlLoadFile(NULL, filexml, MXML_OPAQUE_CALLBACK);
fclose(filexml);
} else {
/* load zipped XML file */
unzFile unzfile = unzOpen(filename);
if (unzfile == NULL)
return false;
unzOpenCurrentFile(unzfile);
unz_file_info zipfileinfo;
unzGetCurrentFileInfo(unzfile, &zipfileinfo, NULL, 0, NULL, 0, NULL, 0);
int zipfilebuffersize = zipfileinfo.uncompressed_size;
if (zipfilebuffersize >= xmlmaxsize) {
unzCloseCurrentFile(unzfile);
unzClose(unzfile);
return false;
}
char * zipfilebuffer = malloc(zipfilebuffersize);
memset(zipfilebuffer, 0, zipfilebuffersize);
if (zipfilebuffer == NULL) {
unzCloseCurrentFile(unzfile);
unzClose(unzfile);
return false;
}
unzReadCurrentFile(unzfile, zipfilebuffer, zipfilebuffersize);
unzCloseCurrentFile(unzfile);
unzClose(unzfile);
nodetree = mxmlLoadString(NULL, zipfilebuffer, MXML_OPAQUE_CALLBACK);
free(zipfilebuffer);
}
if (nodetree == NULL)
return false;
nodedata = mxmlFindElement(nodetree, nodetree, "datafile", NULL, NULL, MXML_DESCEND);
if (nodedata == NULL) {
return false;
} else {
//if (xmldebug) xmlloadtime = dbg_time2(NULL);
xml_loaded = true;
return true;
}
}
