Changeset a06e6af in nscp


Ignore:
Timestamp:
02/02/12 07:02:05 (17 months ago)
Author:
Michael Medin <michael@…>
Branches:
master, 0.4.0, 0.4.1, 0.4.2
Children:
a8c6e93
Parents:
c5ec0c8
Message:

2012-02-01 MickeM

  • Implemented full settings API for LuaScript? (next RC will have to wait till next weekend)
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • changelog

    rc5ec0c8 ra06e6af  
    55 * Fixa dependonservice LanManWorkStation (old win) 
    66 * Fix RtlStringFromGUID problem on NT4 
     7 
     82012-02-01 MickeM 
     9 * Implemented full settings API for LuaScript (next RC will have to wait till next weekend) 
    710 
    8112012-01-31 MickeM 

  • modules/LUAScript/CMakeLists.txt

    rd66ccee ra06e6af  
    1919    "${TARGET}.h" 
    2020    "${TARGET}.def" 
     21    lua_wrappers.hpp 
     22    script_wrapper.hpp 
    2123 
    2224    ${NSCP_DEF_PLUGIN_HPP} 

  • modules/LUAScript/LUAScript.cpp

    rc5ec0c8 ra06e6af  
    6868    BOOST_FOREACH(script_container &script, scripts_) { 
    6969      try { 
    70         boost::shared_ptr<script_wrapper::lua_script> instance = script_wrapper::lua_script::create_instance(get_core(), get_id(), registry, script.alias, script.script.string()); 
    71         instance->pre_load(); 
    72         instances_.push_back(instance); 
     70        instances_.push_back(script_wrapper::lua_script::create_instance(get_core(), get_id(), registry, script.alias, script.script.string())); 
    7371      } catch (const lua_wrappers::LUAException &e) { 
    7472        NSC_LOG_ERROR_STD(_T("Could not load script ") + script.to_wstring() + _T(": ") + e.getMessage()); 
    … …  
    149147  bool error = false; 
    150148  registry->clear(); 
    151   for (script_list::const_iterator cit = instances_.begin(); cit != instances_.end() ; ++cit) { 
     149  BOOST_FOREACH(script_instance i, instances_) { 
    152150    try { 
    153       (*cit)->reload(); 
     151      i->reload(); 
    154152    } catch (const lua_wrappers::LUAException &e) { 
    155153      error = true; 
    156       message += _T("Exception when reloading script: ") + (*cit)->get_wscript() + _T(": ") + e.getMessage(); 
    157       NSC_LOG_ERROR_STD(_T("Exception when reloading script: ") + (*cit)->get_wscript() + _T(": ") + e.getMessage()); 
     154      message += _T("Exception when reloading script: ") + i->get_wscript() + _T(": ") + e.getMessage(); 
     155      NSC_LOG_ERROR_STD(_T("Exception when reloading script: ") + i->get_wscript() + _T(": ") + e.getMessage()); 
    158156    } catch (...) { 
    159157      error = true; 
    160       message += _T("Unhandeled Exception when reloading script: ") + (*cit)->get_wscript(); 
    161       NSC_LOG_ERROR_STD(_T("Unhandeled Exception when reloading script: ") + (*cit)->get_wscript()); 
     158      message += _T("Unhandeled Exception when reloading script: ") + i->get_wscript(); 
     159      NSC_LOG_ERROR_STD(_T("Unhandeled Exception when reloading script: ") + i->get_wscript()); 
    162160    } 
    163161  } 

  • modules/LUAScript/LUAScript.h

    rc5ec0c8 ra06e6af  
    3636  boost::shared_ptr<lua_wrappers::lua_registry> registry; 
    3737  script_container::list_type scripts_; 
    38   typedef std::list<boost::shared_ptr<script_wrapper::lua_script> > script_list; 
     38  typedef boost::shared_ptr<script_wrapper::lua_script> script_instance; 
     39  typedef std::list<script_instance> script_list; 
    3940  script_list instances_; 
    4041  boost::filesystem::wpath root_; 

  • modules/LUAScript/lua_wrappers.hpp

    rc5ec0c8 ra06e6af  
    2727    } 
    2828    inline lua_State* get_state() const { 
     29      int i = lua_gettop(L); 
    2930      return L; 
    3031    } 
    … …  
    5354        return strEx::itos(lua_tonumber(L, pos)); 
    5455      return _T("<NOT_A_STRING>"); 
     56    } 
     57    int get_int(int pos = -1) { 
     58      if (pos == -1) 
     59        pos = lua_gettop(L); 
     60      if (pos == 0) 
     61        return 0; 
     62      if (is_string(pos)) 
     63        return strEx::stoi(utf8::cvt<std::wstring>(lua_tostring(L, pos))); 
     64      if (is_number(pos)) 
     65        return lua_tonumber(L, pos); 
     66      return 0; 
    5567    } 
    5668    boolean get_boolean(int pos = -1) { 
    … …  
    110122        return _T("<EMPTY>"); 
    111123      ret = get_string(top); 
     124      pop(); 
     125      return ret; 
     126    } 
     127    int pop_int() { 
     128      int ret; 
     129      int top = lua_gettop(L); 
     130      if (top == 0) 
     131        return 0; 
     132      ret = get_int(top); 
    112133      pop(); 
    113134      return ret; 
    … …  
    160181      return type; 
    161182    } 
     183    std::wstring get_type_as_string(int pos = -1) { 
     184      if (pos == -1) 
     185        pos = lua_gettop(L); 
     186      if (pos == 0) 
     187        return _T("<EMPTY>"); 
     188      switch (lua_type(L, pos)) { 
     189        case LUA_TNUMBER:  
     190          return _T("<NUMBER>"); 
     191        case LUA_TSTRING: 
     192          return _T("<STRING>"); 
     193        case LUA_TBOOLEAN: 
     194          return _T("<TABLE>"); 
     195        case LUA_TLIGHTUSERDATA: 
     196          return _T("<LIGHTUSERDATA>"); 
     197        case LUA_TTABLE: 
     198          return _T("<TABLE>"); 
     199      } 
     200      return _T("<UNKNOWN>"); 
     201    } 
     202 
    162203    inline bool is_string(int pos = -1) { 
    163204      return type(pos) == LUA_TSTRING; 
    … …  
    198239      lua_pushboolean(L, b?TRUE:FALSE); 
    199240    } 
     241    void push_int(int b) { 
     242      lua_pushinteger(L, b); 
     243    } 
    200244    void push_string(std::string s) { 
    201245      lua_pushstring(L, s.c_str()); 
    … …  
    215259    inline bool empty() { 
    216260      return size() == 0; 
     261    } 
     262    void log_stack() { 
     263      int args = size(); 
     264      NSC_DEBUG_MSG_STD(_T("Invalid lua stack state, dumping stack")); 
     265      for (int i=1;i<args+1;i++) { 
     266        NSC_DEBUG_MSG_STD(get_type_as_string(i) +_T(": ") + get_string(i)); 
     267      } 
    217268    } 
    218269 
    … …  
    243294    } 
    244295 
     296    inline void openlibs() { 
     297      luaL_openlibs(L); 
     298    } 
     299 
     300    inline int loadfile(std::string script) { 
     301      return luaL_loadfile(L, script.c_str()); 
     302    } 
     303 
     304    int pcall(int nargs, int nresults, int errfunc) { 
     305      return lua_pcall(L, nargs, nresults, errfunc); 
     306    } 
     307 
     308 
     309    std::string inline op_string(int pos, std::string def = "") { 
     310      return luaL_optstring(L, pos, def.c_str()); 
     311    } 
     312    std::wstring inline op_wstring(int pos, std::string def = "") { 
     313      return utf8::cvt<std::wstring>(op_string(pos, def)); 
     314    } 
     315    std::wstring inline op_wstring(int pos, std::wstring def) { 
     316      return op_wstring(pos, utf8::cvt<std::string>(def)); 
     317    } 
     318    std::string inline string(int pos) { 
     319      return luaL_checkstring(L, pos); 
     320    } 
     321    std::wstring inline wstring(int pos) { 
     322      return utf8::cvt<std::wstring>(string(pos)); 
     323    } 
     324 
     325    boolean inline checkbool(int pos) { 
     326      return lua_toboolean(L, pos); 
     327    } 
     328    int inline op_int(int pos, int def = 0) { 
     329      return luaL_optinteger(L, pos, def); 
     330    } 
     331    int inline checkint(int pos) { 
     332      return luaL_checkint(L, pos); 
     333    } 
    245334  }; 
    246335 
    … …  
    314403    typedef std::map<std::wstring,function_container> function_map; 
    315404    function_map functions; 
     405    function_map channels; 
    316406  public: 
    317407    NSCAPI::nagiosReturn on_query(const std::wstring & target, const std::wstring & command, std::list<std::wstring> & arguments, std::wstring & message, std::wstring & perf)  
    … …  
    362452    } 
    363453 
    364     bool has_command(const std::wstring & command)  
    365     { 
    366       NSC_DEBUG_MSG_STD(_T("Looking for command: ") + command); 
     454    bool has_command(const std::wstring & command) { 
    367455      return functions.find(command) != functions.end(); 
    368456    } 
    369457    void register_query(const std::wstring &command, boost::shared_ptr<lua_script_instance> instance, int func_ref) { 
    370       NSC_DEBUG_MSG_STD(_T("Registring command: ") + command); 
    371458      function_container c; 
    372459      c.func_ref = func_ref; 
    … …  
    375462    } 
    376463 
    377     void clear()  
    378     { 
    379       throw std::exception("The method or operation is not implemented."); 
    380     } 
     464    void clear() { 
     465      functions.clear(); 
     466      // DO we need to release reference here? 
     467    } 
     468 
     469    void register_subscription(const std::wstring &channel, boost::shared_ptr<lua_script_instance> instance, int func_ref) { 
     470      function_container c; 
     471      c.func_ref = func_ref; 
     472      c.instance = instance; 
     473      channels[channel] = c; 
     474    } 
     475 
     476    void register_cmdline(const std::wstring &command, boost::shared_ptr<lua_script_instance> instance, int func_ref) { 
     477      function_container c; 
     478      c.func_ref = func_ref; 
     479      c.instance = instance; 
     480      channels[command] = c; 
     481    } 
     482 
     483 
    381484 
    382485 

  • modules/LUAScript/script_wrapper.hpp

    rc5ec0c8 ra06e6af  
    117117  class registry_wrapper : public base_script_object { 
    118118  private: 
    119     //registry_wrapper(const registry_wrapper &other) {} 
    120     //registry_wrapper& operator=(const registry_wrapper &other) {} 
    121  
    122   public: 
    123  
    124     registry_wrapper(lua_State *L) : base_script_object(L) { 
    125       NSC_DEBUG_MSG(_T("create (from LUA)")); 
    126     } 
    127     /* 
    128     registry_wrapper(nscapi::core_wrapper* core, unsigned int plugin_id) : core(core), plugin_id(plugin_id) { 
    129       NSC_DEBUG_MSG(_T("create (from c++)")); 
    130     } 
    131     static boost::shared_ptr<registry_wrapper> create(unsigned int plugin_id) { 
    132       return boost::shared_ptr<registry_wrapper>(new registry_wrapper(nscapi::plugin_singleton->get_core(), plugin_id)); 
    133     } 
    134     */ 
     119 
     120  public: 
     121 
     122    registry_wrapper(lua_State *L) : base_script_object(L) {} 
    135123 
    136124    static const char className[]; 
    … …  
    138126 
    139127    int register_function(lua_State *L) { 
    140       NSC_DEBUG_MSG(_T("register_function")); 
    141       return 0; 
     128      lua_wrappers::lua_wrapper lua(L); 
     129      NSC_LOG_ERROR_STD(_T("Unsupported API called: exec")); 
     130      return lua.error("Unsupported API called: exec"); 
    142131    } 
    143132    int register_simple_function(lua_State *L) { 
    144       NSC_DEBUG_MSG(_T("register_simple_function")); 
    145133      lua_wrapper lua(L); 
    146134      std::wstring description; 
    … …  
    167155    } 
    168156    int register_cmdline(lua_State *L) { 
    169       NSC_DEBUG_MSG(_T("register_cmdline")); 
    170       return 0; 
     157      lua_wrappers::lua_wrapper lua(L); 
     158      NSC_LOG_ERROR_STD(_T("Unsupported API called: exec")); 
     159      return lua.error("Unsupported API called: exec"); 
    171160    } 
    172161    int register_simple_cmdline(lua_State *L) { 
    173       NSC_DEBUG_MSG(_T("register_simple_cmdline")); 
     162      lua_wrapper lua(L); 
     163      std::wstring name; 
     164      if (lua.is_string()) { 
     165        name = lua.pop_string(); 
     166        lua_getglobal(L, utf8::cvt<std::string>(name).c_str()); 
     167      } 
     168      if (!lua.is_function()) 
     169        return lua.error("Invalid argument not a function: " + utf8::cvt<std::string>(name)); 
     170 
     171      int func_ref = luaL_ref(L, LUA_REGISTRYINDEX); 
     172 
     173      if (func_ref == 0) 
     174        return lua.error("Invalid function: " + utf8::cvt<std::string>(name)); 
     175      std::wstring script = lua.pop_string(); 
     176      get_instance()->get_registry()->register_cmdline(script, get_instance(), func_ref); 
    174177      return 0; 
    175178    } 
    176179    int subscription(lua_State *L) { 
    177       NSC_DEBUG_MSG(_T("subscription")); 
    178       return 0; 
     180      lua_wrappers::lua_wrapper lua(L); 
     181      NSC_LOG_ERROR_STD(_T("Unsupported API called: exec")); 
     182      return lua.error("Unsupported API called: exec"); 
    179183    } 
    180184    int simple_subscription(lua_State *L) { 
    181       NSC_DEBUG_MSG(_T("simple_subscription")); 
     185      lua_wrapper lua(L); 
     186      std::wstring name; 
     187      if (lua.is_string()) { 
     188        name = lua.pop_string(); 
     189        lua_getglobal(L, utf8::cvt<std::string>(name).c_str()); 
     190      } 
     191      if (!lua.is_function()) 
     192        return lua.error("Invalid argument not a function: " + utf8::cvt<std::string>(name)); 
     193 
     194      int func_ref = luaL_ref(L, LUA_REGISTRYINDEX); 
     195 
     196      if (func_ref == 0) 
     197        return lua.error("Invalid function: " + utf8::cvt<std::string>(name)); 
     198      std::wstring channel = lua.pop_string(); 
     199      get_instance()->get_core()->registerSubmissionListener(get_instance()->get_plugin_id(), channel); 
     200      get_instance()->get_registry()->register_subscription(channel, get_instance(), func_ref); 
    182201      return 0; 
    183202    } 
    … …  
    207226    static const Luna<settings_wrapper>::RegType methods[]; 
    208227 
    209  
    210  
    211228    int get_section(lua_State *L) { 
    212229      lua_wrapper lua(L); 
    213       int nargs = lua.size(); 
    214       if (nargs > 1) 
    215         return lua.error("Incorrect syntax: get_section([<section>]);"); 
    216       std::wstring v; 
    217       if (nargs > 0) 
    218         v = lua.pop_string(); 
     230      std::wstring v = lua.op_wstring(1); 
    219231      try { 
    220232        lua.push_array(get_instance()->get_core()->getSettingsSection(v)); 
    … …  
    226238    int get_string(lua_State *L) { 
    227239      lua_wrapper lua(L); 
    228       int nargs = lua.size(); 
    229 //      if (nargs < 2 || nargs > 3) { 
    230 //        return lua.error("Incorrect syntax: get_string(<section>, <key>[, <default value>]);" + utf8::cvt<std::string>(lua.dump_stack())); 
    231 //      } 
    232       std::wstring v; 
    233       if (nargs > 2) 
    234         v = lua.pop_string(); 
    235       std::wstring k = lua.pop_string(); 
    236       std::wstring s = lua.pop_string(); 
    237       if (nargs > 1) 
    238         lua.pop_string(); 
     240      std::wstring s = lua.wstring(1); 
     241      std::wstring k = lua.wstring(2); 
     242      std::wstring v = lua.op_wstring(3); 
    239243      lua.push_string(get_instance()->get_core()->getSettingsString(s, k, v)); 
    240244      return 1; 
    241245    } 
    242246    int set_string(lua_State *L) { 
    243       NSC_DEBUG_MSG(_T("set_string")); 
     247      lua_wrapper lua(L); 
     248      std::wstring s = lua.wstring(1); 
     249      std::wstring k = lua.wstring(2); 
     250      std::wstring v = lua.wstring(3); 
     251      get_instance()->get_core()->SetSettingsString(s, k, v); 
    244252      return 0; 
    245253    } 
    246254    int get_bool(lua_State *L) { 
    247255      lua_wrapper lua(L); 
    248       int nargs = lua.size(); 
    249       if (nargs < 2 || nargs > 3) 
    250         return lua.error("Incorrect syntax: get_string(<section>, <key>[, <default value>]);"); 
    251       bool v; 
    252       if (nargs > 2) 
    253         v = lua.pop_boolean(); 
    254       std::wstring k = lua.pop_string(); 
    255       std::wstring s = lua.pop_string(); 
     256      std::wstring s = lua.wstring(1); 
     257      std::wstring k = lua.wstring(2); 
     258      bool v = lua.checkbool(3); 
    256259      lua.push_boolean(get_instance()->get_core()->getSettingsInt(s, k, v?1:0)==1); 
    257260      return 1; 
    258261    } 
    259262    int set_bool(lua_State *L) { 
    260       NSC_DEBUG_MSG(_T("set_bool")); 
     263      lua_wrapper lua(L); 
     264      std::wstring s = lua.wstring(1); 
     265      std::wstring k = lua.wstring(2); 
     266      bool v = lua.checkbool(3); 
     267      get_instance()->get_core()->SetSettingsInt(s, k, v?1:0); 
    261268      return 0; 
    262269    } 
    263270    int get_int(lua_State *L) { 
    264       NSC_DEBUG_MSG(_T("get_int")); 
    265       return 0; 
     271      lua_wrapper lua(L); 
     272      std::wstring s = lua.wstring(1); 
     273      std::wstring k = lua.wstring(2); 
     274      int v = lua.checkint(3); 
     275      lua.push_int(get_instance()->get_core()->getSettingsInt(s, k, v)); 
     276      return 1; 
    266277    } 
    267278    int set_int(lua_State *L) { 
    268       NSC_DEBUG_MSG(_T("set_int")); 
     279      lua_wrapper lua(L); 
     280      std::wstring s = lua.wstring(1); 
     281      std::wstring k = lua.wstring(2); 
     282      int v = lua.checkint(3); 
     283      get_instance()->get_core()->SetSettingsInt(s, k, v); 
    269284      return 0; 
    270285    } 
    271286    int save(lua_State *L) { 
    272       NSC_DEBUG_MSG(_T("save")); 
     287      get_instance()->get_core()->settings_save(); 
    273288      return 0; 
    274289    } 
    275290    int register_path(lua_State *L) { 
    276       NSC_DEBUG_MSG(_T("register_path")); 
    277       return 0; 
    278     } 
     291      lua_wrapper lua(L); 
     292      std::wstring path = lua.wstring(1); 
     293      std::wstring title = lua.wstring(1); 
     294      std::wstring description = lua.wstring(1); 
     295      get_instance()->get_core()->settings_register_path(path, title, description, false); 
     296      return 0; 
     297    } 
     298    NSCAPI::settings_type script_wrapper::settings_wrapper::get_type(std::string stype) { 
     299      if (stype == "string" || stype == "str" || stype == "s") 
     300        return NSCAPI::key_string; 
     301      if (stype == "integer" || stype == "int" || stype == "i") 
     302        return NSCAPI::key_integer; 
     303      if (stype == "bool" || stype == "b") 
     304        return NSCAPI::key_bool; 
     305      NSC_LOG_ERROR_STD(_T("Invalid settings type")); 
     306      return NSCAPI::key_string; 
     307    } 
     308 
    279309    int register_key(lua_State *L) { 
    280       NSC_DEBUG_MSG(_T("register_key")); 
     310      lua_wrapper lua(L); 
     311      std::wstring path = lua.wstring(1); 
     312      std::wstring key = lua.wstring(1); 
     313      std::wstring stype = lua.wstring(1); 
     314      NSCAPI::settings_type type = get_type(stype); 
     315      std::wstring title = lua.wstring(1); 
     316      std::wstring description = lua.wstring(1); 
     317      std::wstring defaultValue = lua.wstring(1); 
     318      get_instance()->get_core()->settings_register_key(path, key, type, title, description, defaultValue, false); 
    281319      return 0; 
    282320    } 
    … …  
    380418  class lua_script : public script_instance, public boost::enable_shared_from_this<lua_script>  { 
    381419    lua_script(nscapi::core_wrapper* core, const int plugin_id, boost::shared_ptr<lua_wrappers::lua_registry> registry, const std::string alias, const std::string script)  
    382       : script_instance(core, plugin_id, registry, alias, script) { 
    383       load(); 
    384     } 
     420      : script_instance(core, plugin_id, registry, alias, script) {} 
    385421  public: 
    386422 
    387423    static boost::shared_ptr<lua_script> create_instance(nscapi::core_wrapper* core, const int plugin_id, boost::shared_ptr<lua_wrappers::lua_registry> registry, const std::wstring alias, const std::wstring script) { 
    388424      boost::shared_ptr<lua_script> instance(new lua_script(core, plugin_id, registry, utf8::cvt<std::string>(alias), utf8::cvt<std::string>(script))); 
    389       if (instance) 
     425      if (instance) { 
    390426        instance->init(); 
     427        instance->load(); 
     428      } 
    391429      return instance; 
    392430    } 
    … …  
    396434 
    397435    void load() { 
    398       int i = lua_gettop(get_lua_state()); 
    399       luaL_openlibs(get_lua_state()); 
    400       i = lua_gettop(get_lua_state()); 
     436      lua_wrappers::lua_wrapper lua(get_lua_state()); 
     437      lua.openlibs(); 
    401438      nsclient_wrapper::luaopen(get_lua_state()); 
    402       i = lua_gettop(get_lua_state()); 
    403       if (luaL_loadfile(get_lua_state(), get_script().c_str()) != 0) { 
    404         throw lua_wrappers::LUAException(_T("Failed to load script: ") + get_wscript() + _T(": ") + utf8::cvt<std::wstring>(lua_tostring(get_lua_state(), -1))); 
    405       } 
     439      if (lua.loadfile(get_script()) != 0) 
     440        throw lua_wrappers::LUAException(_T("Failed to load script: ") + get_wscript() + _T(": ") + lua.pop_string()); 
     441      if (lua.pcall(0, 0, 0) != 0) 
     442        throw lua_wrappers::LUAException(_T("Failed to execute script: ") + get_wscript() + _T(": ") + lua.pop_string()); 
    406443    } 
    407444    std::wstring get_wscript() const { 
    … …  
    412449      unload(); 
    413450      load(); 
    414       pre_load(); 
    415     } 
    416     void pre_load() { 
    417       if (lua_pcall(get_lua_state(), 0, 0, 0) != 0) { 
    418         throw lua_wrappers::LUAException(_T("Failed to parse script: ") + get_wscript() + _T(": ") + utf8::cvt<std::wstring>(lua_tostring(get_lua_state(), -1))); 
    419       } 
    420     } 
    421  
    422  
    423 /* 
    424     NSCAPI::nagiosReturn handleCommand(lua_handler *handler, std::wstring function, std::wstring cmd, std::list<std::wstring> arguments, std::wstring &msg, std::wstring &perf) { 
    425       lua_manager::set_handler(L, handler); 
    426       lua_manager::set_script(L, this); 
    427       lua_wrapper lua(L); 
    428       int nargs = lua.size(); 
    429       lua_getglobal(L, utf8::cvt<std::string>(function).c_str()); 
    430       if (!lua_isfunction(L, -1)) { 
    431         lua_pop(L, 1); // remove function from LUA stack 
    432         throw lua_wrappers::LUAException(_T("Failed to run script: ") + get_wscript() + _T(": Function not found: handle")); 
    433       } 
    434       lua.push_string(cmd);  
    435       lua.push_array(arguments); 
    436  
    437       if (lua_pcall(L, 2, LUA_MULTRET, 0) != 0) { 
    438         std::wstring err = lua.pop_string(); 
    439         NSC_LOG_ERROR_STD(_T("Failed to call main function in script: ") + get_wscript() + _T(": ") + err); 
    440         return NSCAPI::returnUNKNOWN; 
    441       } 
    442       return extract_return(L, lua.size(), msg, perf); 
    443     } 
    444     */ 
    445   }; 
    446  
    447  
    448  
    449  
    450  
     451    } 
     452  }; 
    451453} 

  • version.hpp

    rc5ec0c8 ra06e6af  
    11#ifndef VERSION_HPP 
    22#define VERSION_HPP 
    3 #define PRODUCTVER     0,4,0,130 
    4 #define STRPRODUCTVER  "0,4,0,130" 
    5 #define STRPRODUCTDATE "2012-01-26" 
     3#define PRODUCTVER     0,4,0,131 
     4#define STRPRODUCTVER  "0,4,0,131" 
     5#define STRPRODUCTDATE "2012-01-31" 
    66#endif // VERSION_HPP 

  • version.txt

    rc5ec0c8 ra06e6af  
    11version=0.4.0 
    2 build=130 
    3 date=2012-01-26 
     2build=131 
     3date=2012-01-31 
Note: See TracChangeset for help on using the changeset viewer.