[1650] | 1 | -- tolua: basic utility functions |
---|
| 2 | -- Written by Waldemar Celes |
---|
| 3 | -- TeCGraf/PUC-Rio |
---|
| 4 | -- Jul 1998 |
---|
| 5 | -- Last update: Apr 2003 |
---|
| 6 | -- $Id: $ |
---|
| 7 | |
---|
| 8 | -- This code is free software; you can redistribute it and/or modify it. |
---|
| 9 | -- The software provided hereunder is on an "as is" basis, and |
---|
| 10 | -- the author has no obligation to provide maintenance, support, updates, |
---|
| 11 | -- enhancements, or modifications. |
---|
| 12 | |
---|
| 13 | |
---|
| 14 | -- Basic C types and their corresponding Lua types |
---|
| 15 | -- All occurrences of "char*" will be replaced by "_cstring", |
---|
| 16 | -- and all occurrences of "void*" will be replaced by "_userdata" |
---|
| 17 | _basic = { |
---|
[2710] | 18 | ['void'] = '', |
---|
| 19 | ['char'] = 'number', |
---|
| 20 | ['int'] = 'number', |
---|
| 21 | ['short'] = 'number', |
---|
| 22 | ['long'] = 'number', |
---|
| 23 | ['unsigned'] = 'number', |
---|
| 24 | ['float'] = 'number', |
---|
| 25 | ['double'] = 'number', |
---|
| 26 | ['_cstring'] = 'string', |
---|
| 27 | ['_userdata'] = 'userdata', |
---|
| 28 | ['char*'] = 'string', |
---|
| 29 | ['void*'] = 'userdata', |
---|
| 30 | ['bool'] = 'boolean', |
---|
| 31 | ['lua_Object'] = 'value', |
---|
| 32 | ['LUA_VALUE'] = 'value', -- for compatibility with tolua 4.0 |
---|
| 33 | ['lua_State*'] = 'state', |
---|
| 34 | ['_lstate'] = 'state', |
---|
| 35 | ['lua_Function'] = 'value', |
---|
[1650] | 36 | } |
---|
| 37 | |
---|
| 38 | _basic_ctype = { |
---|
[2710] | 39 | number = "lua_Number", |
---|
| 40 | string = "const char*", |
---|
| 41 | userdata = "void*", |
---|
| 42 | boolean = "bool", |
---|
| 43 | value = "int", |
---|
| 44 | state = "lua_State*", |
---|
[1650] | 45 | } |
---|
| 46 | |
---|
| 47 | -- functions the are used to do a 'raw push' of basic types |
---|
| 48 | _basic_raw_push = {} |
---|
| 49 | |
---|
| 50 | -- List of user defined types |
---|
| 51 | -- Each type corresponds to a variable name that stores its tag value. |
---|
| 52 | _usertype = {} |
---|
| 53 | |
---|
| 54 | -- List of types that have to be collected |
---|
| 55 | _collect = {} |
---|
| 56 | |
---|
| 57 | -- List of types |
---|
| 58 | _global_types = {n=0} |
---|
| 59 | _global_types_hash = {} |
---|
| 60 | |
---|
| 61 | -- list of classes |
---|
| 62 | _global_classes = {} |
---|
| 63 | |
---|
| 64 | -- List of enum constants |
---|
| 65 | _global_enums = {} |
---|
| 66 | |
---|
| 67 | -- List of auto renaming |
---|
| 68 | _renaming = {} |
---|
| 69 | function appendrenaming (s) |
---|
[2710] | 70 | local b,e,old,new = strfind(s,"%s*(.-)%s*@%s*(.-)%s*$") |
---|
| 71 | if not b then |
---|
| 72 | error("#Invalid renaming syntax; it should be of the form: pattern@pattern") |
---|
| 73 | end |
---|
| 74 | tinsert(_renaming,{old=old, new=new}) |
---|
[1650] | 75 | end |
---|
| 76 | |
---|
| 77 | function applyrenaming (s) |
---|
[2710] | 78 | for i=1,getn(_renaming) do |
---|
| 79 | local m,n = gsub(s,_renaming[i].old,_renaming[i].new) |
---|
| 80 | if n ~= 0 then |
---|
| 81 | return m |
---|
| 82 | end |
---|
| 83 | end |
---|
| 84 | return nil |
---|
[1650] | 85 | end |
---|
| 86 | |
---|
| 87 | -- Error handler |
---|
| 88 | function tolua_error (s,f) |
---|
[2710] | 89 | if _curr_code then |
---|
| 90 | print("***curr code for error is "..tostring(_curr_code)) |
---|
| 91 | print(debug.traceback()) |
---|
| 92 | end |
---|
| 93 | local out = _OUTPUT |
---|
| 94 | _OUTPUT = _STDERR |
---|
| 95 | if strsub(s,1,1) == '#' then |
---|
| 96 | write("\n** tolua: "..strsub(s,2)..".\n\n") |
---|
| 97 | if _curr_code then |
---|
| 98 | local _,_,s = strfind(_curr_code,"^%s*(.-\n)") -- extract first line |
---|
| 99 | if s==nil then s = _curr_code end |
---|
| 100 | s = gsub(s,"_userdata","void*") -- return with 'void*' |
---|
| 101 | s = gsub(s,"_cstring","char*") -- return with 'char*' |
---|
| 102 | s = gsub(s,"_lstate","lua_State*") -- return with 'lua_State*' |
---|
| 103 | write("Code being processed:\n"..s.."\n") |
---|
| 104 | end |
---|
| 105 | else |
---|
| 106 | if not f then f = "(f is nil)" end |
---|
| 107 | print("\n** tolua internal error: "..f..s..".\n\n") |
---|
| 108 | return |
---|
| 109 | end |
---|
| 110 | _OUTPUT = out |
---|
[1650] | 111 | end |
---|
| 112 | |
---|
| 113 | function warning (msg) |
---|
[3127] | 114 | if flags.q then |
---|
| 115 | return |
---|
| 116 | end |
---|
[2710] | 117 | local out = _OUTPUT |
---|
| 118 | _OUTPUT = _STDERR |
---|
| 119 | write("\n** tolua warning: "..msg..".\n\n") |
---|
| 120 | _OUTPUT = out |
---|
[1650] | 121 | end |
---|
| 122 | |
---|
| 123 | -- register an user defined type: returns full type |
---|
| 124 | function regtype (t) |
---|
[2710] | 125 | --if isbasic(t) then |
---|
| 126 | -- return t |
---|
| 127 | --end |
---|
| 128 | local ft = findtype(t) |
---|
[1650] | 129 | |
---|
[2710] | 130 | if not _usertype[ft] then |
---|
| 131 | return appendusertype(t) |
---|
| 132 | end |
---|
| 133 | return ft |
---|
[1650] | 134 | end |
---|
| 135 | |
---|
| 136 | -- return type name: returns full type |
---|
| 137 | function typevar(type) |
---|
[2710] | 138 | if type == '' or type == 'void' then |
---|
| 139 | return type |
---|
| 140 | else |
---|
| 141 | local ft = findtype(type) |
---|
| 142 | if ft then |
---|
| 143 | return ft |
---|
| 144 | end |
---|
| 145 | _usertype[type] = type |
---|
| 146 | return type |
---|
| 147 | end |
---|
[1650] | 148 | end |
---|
| 149 | |
---|
| 150 | -- check if basic type |
---|
| 151 | function isbasic (type) |
---|
[2710] | 152 | local t = gsub(type,'const ','') |
---|
| 153 | local m,t = applytypedef('', t) |
---|
| 154 | local b = _basic[t] |
---|
| 155 | if b then |
---|
| 156 | return b,_basic_ctype[b] |
---|
| 157 | end |
---|
| 158 | return nil |
---|
[1650] | 159 | end |
---|
| 160 | |
---|
| 161 | -- split string using a token |
---|
| 162 | function split (s,t) |
---|
[2710] | 163 | local l = {n=0} |
---|
| 164 | local f = function (s) |
---|
| 165 | l.n = l.n + 1 |
---|
| 166 | l[l.n] = s |
---|
| 167 | return "" |
---|
| 168 | end |
---|
| 169 | local p = "%s*(.-)%s*"..t.."%s*" |
---|
| 170 | s = gsub(s,"^%s+","") |
---|
| 171 | s = gsub(s,"%s+$","") |
---|
| 172 | s = gsub(s,p,f) |
---|
| 173 | l.n = l.n + 1 |
---|
| 174 | l[l.n] = gsub(s,"(%s%s*)$","") |
---|
| 175 | return l |
---|
[1650] | 176 | end |
---|
| 177 | |
---|
| 178 | -- splits a string using a pattern, considering the spacial cases of C code (templates, function parameters, etc) |
---|
| 179 | -- pattern can't contain the '^' (as used to identify the begining of the line) |
---|
| 180 | -- also strips whitespace |
---|
| 181 | function split_c_tokens(s, pat) |
---|
| 182 | |
---|
[2710] | 183 | s = string.gsub(s, "^%s*", "") |
---|
| 184 | s = string.gsub(s, "%s*$", "") |
---|
[1650] | 185 | |
---|
[2710] | 186 | local token_begin = 1 |
---|
| 187 | local token_end = 1 |
---|
| 188 | local ofs = 1 |
---|
| 189 | local ret = {n=0} |
---|
[1650] | 190 | |
---|
[2710] | 191 | function add_token(ofs) |
---|
[1650] | 192 | |
---|
[2710] | 193 | local t = string.sub(s, token_begin, ofs) |
---|
| 194 | t = string.gsub(t, "^%s*", "") |
---|
| 195 | t = string.gsub(t, "%s*$", "") |
---|
| 196 | ret.n = ret.n + 1 |
---|
| 197 | ret[ret.n] = t |
---|
| 198 | end |
---|
[1650] | 199 | |
---|
[2710] | 200 | while ofs <= string.len(s) do |
---|
[1650] | 201 | |
---|
[2710] | 202 | local sub = string.sub(s, ofs, -1) |
---|
| 203 | local b,e = string.find(sub, "^"..pat) |
---|
| 204 | if b then |
---|
| 205 | add_token(ofs-1) |
---|
| 206 | ofs = ofs+e |
---|
| 207 | token_begin = ofs |
---|
| 208 | else |
---|
| 209 | local char = string.sub(s, ofs, ofs) |
---|
| 210 | if char == "(" or char == "<" then |
---|
[1650] | 211 | |
---|
[2710] | 212 | local block |
---|
| 213 | if char == "(" then block = "^%b()" end |
---|
| 214 | if char == "<" then block = "^%b<>" end |
---|
[1650] | 215 | |
---|
[2710] | 216 | b,e = string.find(sub, block) |
---|
| 217 | if not b then |
---|
| 218 | -- unterminated block? |
---|
| 219 | ofs = ofs+1 |
---|
| 220 | else |
---|
| 221 | ofs = ofs + e |
---|
| 222 | end |
---|
[1650] | 223 | |
---|
[2710] | 224 | else |
---|
| 225 | ofs = ofs+1 |
---|
| 226 | end |
---|
| 227 | end |
---|
[1650] | 228 | |
---|
[2710] | 229 | end |
---|
| 230 | add_token(ofs) |
---|
| 231 | --if ret.n == 0 then |
---|
[1650] | 232 | |
---|
[2710] | 233 | -- ret.n=1 |
---|
| 234 | -- ret[1] = "" |
---|
| 235 | --end |
---|
[1650] | 236 | |
---|
[2710] | 237 | return ret |
---|
[1650] | 238 | |
---|
| 239 | end |
---|
| 240 | |
---|
| 241 | -- concatenate strings of a table |
---|
| 242 | function concat (t,f,l,jstr) |
---|
[2710] | 243 | jstr = jstr or " " |
---|
| 244 | local s = '' |
---|
| 245 | local i=f |
---|
| 246 | while i<=l do |
---|
| 247 | s = s..t[i] |
---|
| 248 | i = i+1 |
---|
| 249 | if i <= l then s = s..jstr end |
---|
| 250 | end |
---|
| 251 | return s |
---|
[1650] | 252 | end |
---|
| 253 | |
---|
| 254 | -- concatenate all parameters, following output rules |
---|
| 255 | function concatparam (line, ...) |
---|
[2710] | 256 | local i=1 |
---|
| 257 | while i<=arg.n do |
---|
| 258 | if _cont and not strfind(_cont,'[%(,"]') and |
---|
| 259 | strfind(arg[i],"^[%a_~]") then |
---|
| 260 | line = line .. ' ' |
---|
| 261 | end |
---|
| 262 | line = line .. arg[i] |
---|
| 263 | if arg[i] ~= '' then |
---|
| 264 | _cont = strsub(arg[i],-1,-1) |
---|
| 265 | end |
---|
| 266 | i = i+1 |
---|
| 267 | end |
---|
| 268 | if strfind(arg[arg.n],"[%/%)%;%{%}]$") then |
---|
| 269 | _cont=nil line = line .. '\n' |
---|
| 270 | end |
---|
| 271 | return line |
---|
[1650] | 272 | end |
---|
| 273 | |
---|
| 274 | -- output line |
---|
| 275 | function output (...) |
---|
[2710] | 276 | local i=1 |
---|
| 277 | while i<=arg.n do |
---|
| 278 | if _cont and not strfind(_cont,'[%(,"]') and |
---|
| 279 | strfind(arg[i],"^[%a_~]") then |
---|
| 280 | write(' ') |
---|
| 281 | end |
---|
| 282 | write(arg[i]) |
---|
| 283 | if arg[i] ~= '' then |
---|
| 284 | _cont = strsub(arg[i],-1,-1) |
---|
| 285 | end |
---|
| 286 | i = i+1 |
---|
| 287 | end |
---|
| 288 | if strfind(arg[arg.n],"[%/%)%;%{%}]$") then |
---|
| 289 | _cont=nil write('\n') |
---|
| 290 | end |
---|
[1650] | 291 | end |
---|
| 292 | |
---|
| 293 | function get_property_methods(ptype, name) |
---|
| 294 | |
---|
[2710] | 295 | if get_property_methods_hook and get_property_methods_hook(ptype,name) then |
---|
| 296 | return get_property_methods_hook(ptype, name) |
---|
| 297 | end |
---|
[1650] | 298 | |
---|
[2710] | 299 | if ptype == "default" then -- get_name, set_name |
---|
| 300 | return "get_"..name, "set_"..name |
---|
| 301 | end |
---|
[1650] | 302 | |
---|
[2710] | 303 | if ptype == "qt" then -- name, setName |
---|
| 304 | return name, "set"..string.upper(string.sub(name, 1, 1))..string.sub(name, 2, -1) |
---|
| 305 | end |
---|
[1650] | 306 | |
---|
[2710] | 307 | if ptype == "overload" then -- name, name |
---|
| 308 | return name,name |
---|
| 309 | end |
---|
[1650] | 310 | |
---|
[2710] | 311 | return nil |
---|
[1650] | 312 | end |
---|
| 313 | |
---|
| 314 | -------------- the hooks |
---|
| 315 | |
---|
| 316 | -- called right after processing the $[ichl]file directives, |
---|
| 317 | -- right before processing anything else |
---|
| 318 | -- takes the package object as the parameter |
---|
| 319 | function preprocess_hook(p) |
---|
[2710] | 320 | -- p.code has all the input code from the pkg |
---|
[1650] | 321 | end |
---|
| 322 | |
---|
| 323 | |
---|
| 324 | -- called for every $ifile directive |
---|
| 325 | -- takes a table with a string called 'code' inside, the filename, and any extra arguments |
---|
| 326 | -- passed to $ifile. no return value |
---|
| 327 | function include_file_hook(t, filename, ...) |
---|
| 328 | |
---|
| 329 | end |
---|
| 330 | |
---|
| 331 | -- called after processing anything that's not code (like '$renaming', comments, etc) |
---|
| 332 | -- and right before parsing the actual code. |
---|
| 333 | -- takes the Package object with all the code on the 'code' key. no return value |
---|
| 334 | function preparse_hook(package) |
---|
| 335 | |
---|
| 336 | end |
---|
| 337 | |
---|
[3127] | 338 | -- called before starting output |
---|
| 339 | function pre_output_hook(package) |
---|
[1650] | 340 | |
---|
[3127] | 341 | end |
---|
| 342 | |
---|
[1650] | 343 | -- called after writing all the output. |
---|
| 344 | -- takes the Package object |
---|
| 345 | function post_output_hook(package) |
---|
| 346 | |
---|
| 347 | end |
---|
| 348 | |
---|
| 349 | |
---|
| 350 | -- called from 'get_property_methods' to get the methods to retrieve a property |
---|
| 351 | -- according to its type |
---|
| 352 | function get_property_methods_hook(property_type, name) |
---|
| 353 | |
---|
| 354 | end |
---|
| 355 | |
---|
| 356 | -- called from ClassContainer:doparse with the string being parsed |
---|
| 357 | -- return nil, or a substring |
---|
| 358 | function parser_hook(s) |
---|
| 359 | |
---|
[2710] | 360 | return nil |
---|
[1650] | 361 | end |
---|
| 362 | |
---|
[3127] | 363 | -- called from classFunction:supcode, before the call to the function is output |
---|
| 364 | function pre_call_hook(f) |
---|
[1650] | 365 | |
---|
[3127] | 366 | end |
---|
| 367 | |
---|
| 368 | -- called from classFunction:supcode, after the call to the function is output |
---|
| 369 | function post_call_hook(f) |
---|
| 370 | |
---|
| 371 | end |
---|
| 372 | |
---|
| 373 | -- called before the register code is output |
---|
| 374 | function pre_register_hook(package) |
---|
| 375 | |
---|
| 376 | end |
---|
| 377 | |
---|
| 378 | -- called to output an error message |
---|
[3129] | 379 | function output_error_hook(str, arg) |
---|
| 380 | return string.format(str, arg) |
---|
[3127] | 381 | end |
---|
| 382 | |
---|
| 383 | -- custom pushers |
---|
| 384 | |
---|
| 385 | _push_functions = {} |
---|
| 386 | _is_functions = {} |
---|
| 387 | _to_functions = {} |
---|
| 388 | |
---|
| 389 | _base_push_functions = {} |
---|
| 390 | _base_is_functions = {} |
---|
| 391 | _base_to_functions = {} |
---|
| 392 | |
---|
| 393 | local function search_base(t, funcs) |
---|
| 394 | local class = _global_classes[t] |
---|
| 395 | |
---|
| 396 | while class do |
---|
| 397 | if funcs[class.type] then |
---|
| 398 | return funcs[class.type] |
---|
| 399 | end |
---|
| 400 | class = _global_classes[class.btype] |
---|
| 401 | end |
---|
| 402 | return nil |
---|
| 403 | end |
---|
| 404 | |
---|
| 405 | function get_push_function(t) |
---|
| 406 | return _push_functions[t] or search_base(t, _base_push_functions) or "tolua_pushusertype" |
---|
| 407 | end |
---|
| 408 | |
---|
| 409 | function get_to_function(t) |
---|
| 410 | return _to_functions[t] or search_base(t, _base_to_functions) or "tolua_tousertype" |
---|
| 411 | end |
---|
| 412 | |
---|
| 413 | function get_is_function(t) |
---|
| 414 | return _is_functions[t] or search_base(t, _base_is_functions) or "tolua_isusertype" |
---|
| 415 | end |
---|
| 416 | |
---|