src/livemlparser.cpp

   1 /**
   2  * LiveML - LiveML is screen(graphic) controling library using XML.
   3  *
   4  * LGPL License
   5  * Copyright (C) 2010 Nothan
   6  * http://github.com/nothan/liveml/
   7  * All rights reserved.
   8  *
   9  *  This library is free software; you can redistribute it and/or
  10  *  modify it under the terms of the GNU Library General Public
  11  *  License as published by the Free Software Foundation; either
  12  *  version 2 of the License, or (at your option) any later version.
  13  *
  14  *  This library is distributed in the hope that it will be useful,
  15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  *  Library General Public License for more details.
  18  *
  19  *  You should have received a copy of the GNU Library General Public
  20  *  License along with this library; if not, write to the Free
  21  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  22  *
  23  * Nothan
  24  * private@nothan.xrea.jp
  25  *
  26  * Tsuioku Denrai
  27  * http://tsuioku-denrai.xrea.jp/
  28  */
  29
  30 #include "livemlparser.h"
  31
  32 namespace lmlTag
  33 {
  34   LML_TAGFUNC(liveml)
  35   {
  36     return true;
  37   }
  38
  39   LML_TAGFUNC(actor)
  40   {
  41     LiveMLParser &p = (LiveMLParser&)parser;
  42     ActorParser *actor = p.actorContainer.add(p.getCurrentTag());
  43     p.setCurrentActor(actor);
  44     actor->eventContainer.resize(p.eventTypeContainer.size());
  45
  46     return true;
  47   }
  48
  49   LML_TAGFUNC(event)
  50   {
  51     LiveMLParser &p = (LiveMLParser&)parser;
  52     TagType *rt = p.getParentTag()->type;
  53     EventContainer *ec = NULL;
  54
  55     size_t et = p.eventTypeContainer.getId(param.getString(0));
  56
  57     if (!p.eventTypeContainer.has(et))
  58     {
  59       return false;
  60     }
  61
  62     ec = &p.getCurrentActor()->eventContainer;
  63     if (ec == NULL)
  64     {
  65       return false;
  66     }
  67
  68     DCODE(printf("added event[%s]\n", param.getString(0));)
  69     ec->get(et)->tag = p.getCurrentTag();
  70
  71     return true;
  72   }
  73
  74   LML_TAGFUNC(action)
  75   {
  76     LiveMLParser &p = (LiveMLParser&)parser;
  77     TagType *rt = p.getParentTag()->type;
  78     ActionContainer *ac = NULL;
  79
  80     ac = &p.getCurrentActor()->actionContainer;
  81     if (rt->getName() == "liveml")
  82     {
  83       ac = &p.actionContainer;
  84     }
  85     if (ac == NULL)
  86     {
  87       return false;
  88     }
  89
  90     DCODE(printf("added action[%s]\n", param.getString(0));)
  91     ac->add(p.getCurrentTag());
  92
  93     return true;
  94   }
  95
  96   LML_TAGFUNC(include)
  97   {
  98     LiveMLParser &p = (LiveMLParser&)parser;
  99     Tag *t = p.getCurrentTag();
 100     p.setCurrentTag(NULL);
 101     bool result = p.loadFile(param.getString(0));
 102     p.setCurrentTag(t);
 103
 104     return result;
 105   }
 106 }
 107
 108 // parameter types
 109 PARAMFUNC(LiveMLParser::paramText)
 110 {
 111   return text_encode((char*)value, variableEncoder, (void*)&((LiveMLParser&)parser).variableContainer);
 112 }
 113
 114 PARAMFUNC(LiveMLParser::paramNumeric)
 115 {
 116   return calcu_encode((char*)value, variableEncoder, (void*)&((LiveMLParser&)parser).variableContainer);
 117 }
 118
 119 PARAMFUNC(LiveMLParser::paramVar)
 120 {
 121   // name to id
 122   variable_size &id = *(variable_size*)malloc(sizeof(variable_size));
 123   id = LiveMLParser::variableEncoder(value, (void*)&((LiveMLParser&)parser).variableContainer);
 124
 125   return &id;
 126 }
 127
 128 PARAMFUNC(LiveMLParser::paramActor)
 129 {
 130   size_t &id = *(size_t*)malloc(sizeof(size_t));
 131   id = ((LiveMLParser&)parser).actorTypeContainer.getId(value);
 132
 133   return &id;
 134 }
 135
 136 // encode variables
 137 variable_size LiveMLParser::variableEncoder(const char *name, void *work)
 138 {
 139   VariableContainer *variableContainer = (VariableContainer*)work;
 140   variable_size scope = VAR_SCOPE_LOCAL;
 141
 142   DCODE(printf("LiveMLParser::variableEncoder(%s)\n", name);)
 143
 144   if (name[1] == '.')
 145   {
 146     switch (*name)
 147     {
 148     case 'm': // member
 149       scope = VAR_SCOPE_MEMBER;
 150       break;
 151     case 'g': // global
 152       scope = VAR_SCOPE_GLOBAL;
 153       break;
 154     case 'p': // parent
 155       scope = VAR_SCOPE_PARENT;
 156       break;
 157     }
 158     name += 2;
 159   }
 160
 161   variable_size id = variableContainer->add(scope, name);
 162
 163   DCODE(printf("'%s' is %d\n", name, id);)
 164
 165   return id;
 166 }
 167
 168 size_t LiveMLParser::addEventType(const char *name)
 169 {
 170   eventTypeContainer.add(name);
 171
 172   return eventTypeContainer.getId(name);
 173 }
 174
 175 LiveMLParser::LiveMLParser(void) :
 176 PARAM_TEXT(registerParameterType(paramText)),
 177 PARAM_NUMERIC(registerParameterType(paramNumeric)),
 178 PARAM_VAR(registerParameterType(paramVar)),
 179 PARAM_ACTOR(registerParameterType(paramActor))
 180 {
 181   TagType *reg = _tagTypeContainer.add("liveml");
 182   reg->setFunction(lmlTag::liveml);
 183
 184   ParameterOption *po;
 185
 186   // actor
 187   reg = addTagType("actor");
 188   reg->setFunction(lmlTag::actor);
 189   po = reg->addParameter();
 190   po->set(0, PARAM_STRING, "name");
 191   po = reg->addParameter();
 192   po->set(1, PARAM_ACTOR, "type");
 193
 194   // print
 195   reg = addTagType("print");
 196   po = reg->addParameter();
 197   po->set(0, PARAM_TEXT);
 198
 199   // active
 200   reg = addTagType("active");
 201   po = reg->addParameter();
 202   po->set(0, PARAM_TEXT);
 203   po = reg->addParameter();
 204   po->set(1, PARAM_VAR, "val");
 205
 206   // event
 207   reg = addTagType("event");
 208   reg->setFunction(lmlTag::event);
 209   po = reg->addParameter();
 210   po->set(0, PARAM_STRING, "type");
 211
 212   // action
 213   reg = addTagType("action");
 214   reg->setFunction(lmlTag::action);
 215   po = reg->addParameter();
 216   po->set(0, PARAM_STRING, "name");
 217
 218   // callAction
 219   reg = addTagType("callAction");
 220   po = reg->addParameter();
 221   po->set(0, PARAM_TEXT);
 222   po = reg->addParameter();
 223   po->set(1, PARAM_NUMERIC, "target");
 224
 225   // callEvent
 226   reg = addTagType("callEvent");
 227   po = reg->addParameter();
 228   po->set(0, PARAM_TEXT);
 229   po = reg->addParameter();
 230   po->set(1, PARAM_NUMERIC, "target");
 231
 232   // include
 233   reg = addTagType("include");
 234   reg->setFunction(lmlTag::include);
 235   po = reg->addParameter();
 236   po->set(0, PARAM_STRING);
 237
 238   // repeat
 239   reg = addTagType("repeat");
 240   po = reg->addParameter();
 241   po->set(0, PARAM_CLOSE_TAG);
 242   po = reg->addParameter();
 243   po->set(1, PARAM_NUMERIC, "count");
 244
 245   // continue
 246   reg = addTagType("continue");
 247   po = reg->addParameter();
 248   po->set(0, PARAM_PARENT_TAG);
 249
 250   // break
 251   reg = addTagType("break");
 252   po = reg->addParameter();
 253   po->set(0, PARAM_PARENT_TAG);
 254
 255   // if
 256   reg = addTagType("if");
 257   po = reg->addParameter();
 258   po->set(0, PARAM_CLOSE_TAG);
 259   po = reg->addParameter();
 260   po->set(1, PARAM_NUMERIC, "case");
 261
 262   // wait
 263   reg = addTagType("wait");
 264   po = reg->addParameter();
 265   po->set(0, PARAM_NUMERIC);
 266
 267   // exit
 268   reg = addTagType("exit");
 269
 270   // val
 271   reg = addTagType("val");
 272   po = reg->addParameter();
 273   po->set(0, PARAM_VAR, "name");
 274   po = reg->addParameter();
 275   po->set(1, PARAM_NUMERIC);
 276
 277   registerEventType();
 278   registerActorType();
 279 }
 280
 281 void LiveMLParser::registerEventType(void)
 282 {
 283   eventTypeContainer.add("init");
 284   eventTypeContainer.add("release");
 285 }
 286
 287 void LiveMLParser::registerActorType(void)
 288 {
 289   actorTypeContainer.add("general");
 290   actorTypeContainer.add("director");
 291 }