diff options
| author | onefang | 2025-05-28 10:42:37 +1000 |
|---|---|---|
| committer | onefang | 2025-05-28 10:42:37 +1000 |
| commit | 298d75d46ba6bd26646c9c6a51aa0c932fadeb33 (patch) | |
| tree | 913519a0e25f7a6c40d81aafae14145d98434102 | |
| parent | Neaten up the white space. (diff) | |
| download | JackOnAllDevices-master.zip JackOnAllDevices-master.tar.gz JackOnAllDevices-master.tar.bz2 JackOnAllDevices-master.tar.xz | |
| -rwxr-xr-x | PolygLua.lua | 405 | ||||
| -rwxr-xr-x | aataaj.lua | 2 | ||||
| -rwxr-xr-x | test_.lua | 186 |
3 files changed, 1 insertions, 592 deletions
diff --git a/PolygLua.lua b/PolygLua.lua deleted file mode 100755 index 17abd88..0000000 --- a/PolygLua.lua +++ /dev/null | |||
| @@ -1,405 +0,0 @@ | |||
| 1 | #!/usr/bin/env luajit | ||
| 2 | |||
| 3 | --[[ PolygLua. Gluing things onto Lua, making it a polyglot language. | ||
| 4 | |||
| 5 | TODO - Make the parsing recursive. So the command '--fancy' could have it's own options table. | ||
| 6 | --fancy option0 opt1=foo 'Random string!' --somethingElse | ||
| 7 | When to stop and hand back? First time we see a ' -bar' or ' --foo'? | ||
| 8 | |||
| 9 | TODO - Add some sort of alias mechanism for the #! thing. _.bash'echo "This is bash."':Do() | ||
| 10 | The user can define their own aliases in a table, with defaults for bash, sh, luajit, and maybe some others. | ||
| 11 | Then extend it to changing language on the fly _.bash'echo "This is bash."':luajit("print('This is Lua.')"):Do() | ||
| 12 | |||
| 13 | TODO - APT also has +/- for adding and removing option values into an options entry. | ||
| 14 | Not sure if that is being used. | ||
| 15 | |||
| 16 | ]] | ||
| 17 | |||
| 18 | -- Most of this _ stuff was copied from apt-panopticon. | ||
| 19 | local _ = {} | ||
| 20 | _.version = '0.0 crap' | ||
| 21 | |||
| 22 | |||
| 23 | _.verbosity = 2 | ||
| 24 | local log = function(v, t, s) | ||
| 25 | if v <= _.verbosity then | ||
| 26 | if 3 <= _.verbosity then t = os.date('!%F %T') .. ' ' .. t end | ||
| 27 | print(t .. ': ' .. s) | ||
| 28 | end | ||
| 29 | io.flush() | ||
| 30 | end | ||
| 31 | |||
| 32 | -- This sets the global values, here and in the caller. The "_G." part isn't needed, it's just there to make things more obvious to the reader. | ||
| 33 | _G.D = function(s) log(4, 'DEBUG ', s) end | ||
| 34 | _G.I = function(s) log(3, 'INFO ', s) end | ||
| 35 | _G.T = function(s) log(2, 'TIMEOUT ', s) end | ||
| 36 | _G.W = function(s) log(1, 'WARNING ', s) end | ||
| 37 | _G.E = function(s) log(0, 'ERROR ', s) end | ||
| 38 | _G.C = function(s) log(-1, 'CRITICAL ', s) end | ||
| 39 | |||
| 40 | |||
| 41 | local optionsCommon = | ||
| 42 | { | ||
| 43 | help = {help = 'Print the help text.', | ||
| 44 | func = function(self, options, a, args, i, name) | ||
| 45 | for i,v in ipairs{'/usr/share/doc/' .. name, '/usr/local/share/doc/' .. name, './'} do | ||
| 46 | local p = v .. 'README.md' | ||
| 47 | local h = io.open(p, 'r') | ||
| 48 | if nil ~= h then | ||
| 49 | D('Found README file '.. p) | ||
| 50 | Help = h:read('*a') | ||
| 51 | h:close() | ||
| 52 | end | ||
| 53 | end | ||
| 54 | |||
| 55 | print(Help) | ||
| 56 | _.usage(args, options, true) | ||
| 57 | os.exit(0) | ||
| 58 | end | ||
| 59 | }, | ||
| 60 | version = {help = 'Print the version details.', | ||
| 61 | func = function(self, options, a, args, i) | ||
| 62 | print('This is version ' ..Version .. ' of ' .. args[0]) | ||
| 63 | os.exit(0) | ||
| 64 | end | ||
| 65 | }, | ||
| 66 | ['-q'] = {help = 'Decrease verbosity level.', | ||
| 67 | func = function(self, options, a, args, i) | ||
| 68 | if _.verbosity > -1 then _.verbosity = _.verbosity - 1 end | ||
| 69 | print('New verbosity level is ' .. _.verbosity) | ||
| 70 | end | ||
| 71 | }, | ||
| 72 | ['-v'] = {help = 'Increase verbosity level.', | ||
| 73 | func = function(self, options, a, args, i) | ||
| 74 | if _.verbosity < 4 then _.verbosity = _.verbosity + 1 end | ||
| 75 | print('New verbosity level is ' .. _.verbosity) | ||
| 76 | end | ||
| 77 | }, | ||
| 78 | } | ||
| 79 | |||
| 80 | _.usage = function(args, options, all) | ||
| 81 | local h = '' | ||
| 82 | for k, v in pairs(options) do | ||
| 83 | if 'table' == type(v) then h = h .. k .. ' | ' end | ||
| 84 | end | ||
| 85 | for k, v in pairs(optionsCommon) do | ||
| 86 | if 'table' == type(v) then h = h .. k .. ' | ' end | ||
| 87 | end | ||
| 88 | print('Usage: ' .. args[0] .. ' {' .. string.sub(h, 1, -2) .. '}') | ||
| 89 | if true == all then | ||
| 90 | for k, v in pairs(options) do | ||
| 91 | if 'table' == type(v) then | ||
| 92 | if nil ~= v.help then print(k .. '\t\t' .. v.help) end | ||
| 93 | end | ||
| 94 | end | ||
| 95 | for k, v in pairs(optionsCommon) do | ||
| 96 | if 'table' == type(v) then | ||
| 97 | if nil ~= v.help then print(k .. '\t\t' .. v.help) end | ||
| 98 | end | ||
| 99 | end | ||
| 100 | end | ||
| 101 | end | ||
| 102 | |||
| 103 | _.parse = function(args, options, name) | ||
| 104 | local o = nil | ||
| 105 | |||
| 106 | local doIt = function(name, val, a, args, i) | ||
| 107 | local o = options[name] | ||
| 108 | if nil == o then o = optionsCommon[name] end | ||
| 109 | if nil ~= o then | ||
| 110 | if nil ~= val then o.value = val; D(name .. ' = ' .. tostring(val)) end | ||
| 111 | if nil ~= o.func then o:func(options, a, args, i, name) end | ||
| 112 | end | ||
| 113 | return o | ||
| 114 | end | ||
| 115 | |||
| 116 | if nil ~= name then | ||
| 117 | for i,v in ipairs{'/etc/', '~/.', './.'} do | ||
| 118 | local p = v .. name .. '.conf.lua' | ||
| 119 | local h = io.open(p, 'r') | ||
| 120 | if nil ~= h then | ||
| 121 | D('Found configuration file '.. p) | ||
| 122 | h:close() | ||
| 123 | local ar = dofile(p) | ||
| 124 | for k, w in pairs(ar) do | ||
| 125 | if nil == doIt(k, w, k .. '=' .. tostring(w), args, i) then W('config variable not found ' .. k .. ' = ' .. tostring(w)) end | ||
| 126 | end | ||
| 127 | end | ||
| 128 | end | ||
| 129 | end | ||
| 130 | |||
| 131 | if 0 ~= #args then | ||
| 132 | for i,a in ipairs(args) do | ||
| 133 | D('Argument ' .. i .. ' = ' .. a) | ||
| 134 | local ds = 0 | ||
| 135 | if ('-' == a:sub(1, 1)) and ('-' ~= a:sub(2, 2)) then ds = 1 end | ||
| 136 | if '--' == a:sub(1, 2) then ds = 2; a = a:sub(3, -1) end | ||
| 137 | local s, e = a:find('=', 1, true) | ||
| 138 | local k , v | ||
| 139 | if not s then | ||
| 140 | e = 0 | ||
| 141 | v = nil | ||
| 142 | else | ||
| 143 | v = a:sub(e + 1, -1) | ||
| 144 | end | ||
| 145 | k = a:sub(1, e - 1) | ||
| 146 | if 1 == ds then | ||
| 147 | for j = 2, #k do | ||
| 148 | o = doIt('-' .. k:sub(j, j), v, a, args, i) | ||
| 149 | end | ||
| 150 | else | ||
| 151 | o = doIt(k, v, a, args, i) | ||
| 152 | end | ||
| 153 | end | ||
| 154 | end | ||
| 155 | |||
| 156 | if nil == o then | ||
| 157 | _.usage(args, options) | ||
| 158 | os.exit(0) | ||
| 159 | end | ||
| 160 | end | ||
| 161 | |||
| 162 | _.runnable = function(c) | ||
| 163 | return ( 0 == __('which ' .. c):Do().status ) | ||
| 164 | end | ||
| 165 | |||
| 166 | _.running = function(c) | ||
| 167 | return ( 1 ~= tonumber(__('pgrep -u $USER -cf ' .. c):Do().lines[1]) ) | ||
| 168 | end | ||
| 169 | |||
| 170 | _.exists = function(f) | ||
| 171 | local h = io.open(f, 'r') | ||
| 172 | if nil == h then return false else h:close(); return true end | ||
| 173 | end | ||
| 174 | |||
| 175 | |||
| 176 | _.killEmAll = function(all) | ||
| 177 | for i,l in ipairs(all) do | ||
| 178 | local c = 0 | ||
| 179 | while 0 ~= tonumber(__('pgrep -u $USER -xc ' .. l):Do().lines[1]) do | ||
| 180 | local s = 'TERM' | ||
| 181 | if c > 1 then s = 'KILL'; __('sleep ' .. c):Do() end | ||
| 182 | __('pkill -' .. s .. ' -u $USER -x ' .. l):log():Do() | ||
| 183 | c = c + 1 | ||
| 184 | end | ||
| 185 | end | ||
| 186 | end | ||
| 187 | |||
| 188 | |||
| 189 | _.readCmd = function(cmd) | ||
| 190 | local result = {} | ||
| 191 | local output = io.popen(cmd) | ||
| 192 | if nil ~= output then | ||
| 193 | for l in output:lines() do | ||
| 194 | table.insert(result, l) | ||
| 195 | end | ||
| 196 | end | ||
| 197 | -- While this does return the same things as os.execute(), it's just as useless. | ||
| 198 | output:close() | ||
| 199 | return result | ||
| 200 | end | ||
| 201 | |||
| 202 | |||
| 203 | _G.__ = function(c) | ||
| 204 | local exe = {status = 0, lines = {}, logging = false, showing = false, cmd = '', command = c, isScript = false, script = ''} | ||
| 205 | local n = 0 | ||
| 206 | |||
| 207 | exe.cmd = '{ ' | ||
| 208 | if 'table' == type(c) then | ||
| 209 | for i, l in ipairs(c) do | ||
| 210 | n = n + 1 | ||
| 211 | exe.cmd = exe.cmd .. l .. ' ; ' | ||
| 212 | end | ||
| 213 | elseif 'string' == type(c) then | ||
| 214 | exe.isScript = (n == 0) and ('#!' == c:sub(1,2)) | ||
| 215 | for l in string.gmatch(c, '\n*([^\n]+)\n*') do | ||
| 216 | if '' ~= l then | ||
| 217 | if exe.isScript then | ||
| 218 | if '' == exe.script then | ||
| 219 | exe.scriptFile = os.tmpname() | ||
| 220 | D('Creating temporary script file at ' .. exe.scriptFile) | ||
| 221 | exe.cmd = exe.cmd .. l:sub(3) .. ' ' .. exe.scriptFile .. ' ; ' | ||
| 222 | -- PHP wants this to be executable. | ||
| 223 | __('chmod u+x ' .. exe.scriptFile) | ||
| 224 | end | ||
| 225 | exe.script = exe.script .. l .. '\n' | ||
| 226 | else | ||
| 227 | n = n + 1 | ||
| 228 | exe.cmd = exe.cmd .. l .. ' ; ' | ||
| 229 | end | ||
| 230 | end | ||
| 231 | end | ||
| 232 | end | ||
| 233 | if exe.isScript then | ||
| 234 | local a, e = io.open(exe.scriptFile, 'w') | ||
| 235 | if nil == a then E('Could not open ' .. exe.scriptFile .. ' - ' .. e) else | ||
| 236 | a:write(exe.script) | ||
| 237 | a:close() | ||
| 238 | end | ||
| 239 | exe.cmd = exe.cmd .. 'rm ' .. exe.scriptFile .. ' ; ' | ||
| 240 | end | ||
| 241 | exe.cmd = exe.cmd .. ' } ' | ||
| 242 | if 1 == n then exe.cmd = c end | ||
| 243 | |||
| 244 | |||
| 245 | function exe:Nice(c) | ||
| 246 | if nil == c then | ||
| 247 | self.cmd = 'ionice -c3 nice -n 19 ' .. self.cmd | ||
| 248 | else | ||
| 249 | self.cmd = self.cmd .. ' ionice -c3 nice -n 19 ' .. c .. ' ' | ||
| 250 | end | ||
| 251 | return self | ||
| 252 | end | ||
| 253 | |||
| 254 | function exe:timeout(c) | ||
| 255 | -- timeout returns a status of - command status if --preserve-status; "128+9" (actually 137) if --kill-after ends up being done; 124 if it had to TERM; command status if all went well. | ||
| 256 | -- --kill-after means "send KILL after TERM fails". | ||
| 257 | if nil == c then | ||
| 258 | self.cmd = 'timeout --kill-after=10.0 --foreground 42.0s ' .. self.cmd | ||
| 259 | else | ||
| 260 | self.cmd = 'timeout --kill-after=10.0 --foreground ' .. c .. ' ' .. self.cmd | ||
| 261 | end | ||
| 262 | return self | ||
| 263 | end | ||
| 264 | |||
| 265 | function exe:log() self.logging = true return self end | ||
| 266 | function exe:show() self.showing = true return self end | ||
| 267 | -- Should be called "then" but that's a reserved word. | ||
| 268 | function exe:Then(c) if nil == c then c = '' else c = ' ' .. c end self.cmd = self.cmd .. '; ' .. c .. ' ' return self end | ||
| 269 | function exe:And(c) if nil == c then c = '' else c = ' ' .. c end self.cmd = self.cmd .. ' && ' .. c .. ' ' return self end | ||
| 270 | function exe:Or(c) if nil == c then c = '' else c = ' ' .. c end self.cmd = self.cmd .. ' || ' .. c .. ' ' return self end | ||
| 271 | function exe:noErr() self.cmd = self.cmd .. ' 2>/dev/null ' return self end | ||
| 272 | function exe:noOut() self.cmd = self.cmd .. ' 1>/dev/null ' return self end | ||
| 273 | function exe:wait(w) self.cmd = self.cmd .. ' && touch ' .. w .. ' ' return self end | ||
| 274 | |||
| 275 | function exe:Do() | ||
| 276 | --[[ "The condition expression of a control structure can return any | ||
| 277 | value. Both false and nil are considered false. All values different | ||
| 278 | from nil and false are considered true (in particular, the number 0 | ||
| 279 | and the empty string are also true)." | ||
| 280 | says the docs, I beg to differ.]] | ||
| 281 | if true == self.logging then D(' executing - ' .. self.cmd) end | ||
| 282 | --[[ Damn os.execute() | ||
| 283 | Lua 5.1 says it returns "a status code, which is system-dependent" | ||
| 284 | Lua 5.2 says it returns true/nil, "exit"/"signal", the status code. | ||
| 285 | I'm getting 7168 or 0. No idea what the fuck that is. | ||
| 286 | local ok, rslt, status = os.execute(s) | ||
| 287 | ]] | ||
| 288 | self.lines = _.readCmd(self.cmd .. '; echo "$?"', 'r') | ||
| 289 | -- The last line will be the command's returned status, fish that out and collect everything else in lines. | ||
| 290 | self.status = tonumber(self.lines[#self.lines]) | ||
| 291 | self.lines[#self.lines] = nil | ||
| 292 | if true == self.showing then for i, l in ipairs(self.lines) do I(l) end end | ||
| 293 | |||
| 294 | if (nil == self.status) then D('STATUS |' .. 'NIL' .. '| ' .. self.command) | ||
| 295 | elseif (137 == self.status) or (124 == self.status) then T('timeout killed ' .. self.status .. ' ' .. self.command) | ||
| 296 | elseif (0 ~= self.status) then D('STATUS |' .. self.status .. '| ' .. self.command) | ||
| 297 | end | ||
| 298 | |||
| 299 | return self | ||
| 300 | end | ||
| 301 | |||
| 302 | function exe:fork(after, host) | ||
| 303 | -- The host part is from apt-panopticon, likely needed there, but makes no sense here. | ||
| 304 | -- if nil ~= host then self.cmd = self.cmd .. '; r=$?; if [ $r -ge 124 ]; then echo "$r ' .. host .. ' failed forked command ' .. string.gsub(self.cmd, '"', "'") .. '"; fi' end | ||
| 305 | if nil == after then after = '' end | ||
| 306 | if '' ~= after then after = ' ; ' .. after end | ||
| 307 | self.cmd = '{ ' .. self.cmd .. after .. ' ; } & ' | ||
| 308 | if true == self.logging then D(' forking - ' .. self.cmd) end | ||
| 309 | os.execute(self.cmd) | ||
| 310 | return self | ||
| 311 | end | ||
| 312 | |||
| 313 | function exe:forkOnce() | ||
| 314 | if _.running(self.command) then | ||
| 315 | D('Already running ' .. self.command) | ||
| 316 | else | ||
| 317 | self:fork() | ||
| 318 | end | ||
| 319 | end | ||
| 320 | |||
| 321 | return exe | ||
| 322 | end | ||
| 323 | |||
| 324 | |||
| 325 | |||
| 326 | _.who = __[[whoami]]:noErr():Do().lines[1] | ||
| 327 | _.dir = __[[pwd]]:noErr():Do().lines[1] | ||
| 328 | |||
| 329 | |||
| 330 | |||
| 331 | if (arg[0] == './PolygLua.lua') or (arg[0] == 'PolygLua.lua') then | ||
| 332 | local function goAway(txt) | ||
| 333 | local luas = __'ls -d1 /usr/share/lua/*':noErr():Do() | ||
| 334 | for i,l in ipairs(luas.lines) do | ||
| 335 | local lua = '/usr/local/share/lua/' .. l:sub(16) .. '/PolygLua.lua' | ||
| 336 | if _.exists(lua) then | ||
| 337 | if 'root' == _.who then | ||
| 338 | print(txt .. ' ' .. lua) | ||
| 339 | __('rm ' .. lua):Do() | ||
| 340 | end | ||
| 341 | end | ||
| 342 | end | ||
| 343 | end | ||
| 344 | |||
| 345 | local options = | ||
| 346 | { | ||
| 347 | install = | ||
| 348 | { | ||
| 349 | help = 'Command to install PolygLua.lua', | ||
| 350 | func = function(self, options, a, args, i) | ||
| 351 | if 'root' ~= _.who then | ||
| 352 | E'Need to be root user to install.' | ||
| 353 | else | ||
| 354 | print('INSTALLING PolygLua.lua!!!') | ||
| 355 | |||
| 356 | local luas = __'ls -d1 /usr/share/lua/*':noErr():Do() | ||
| 357 | for i,l in ipairs(luas.lines) do | ||
| 358 | local lua = '/usr/local/share/lua/' .. l:sub(16) .. '/PolygLua.lua' | ||
| 359 | if _.exists(lua) then | ||
| 360 | print(lua .. ' installed') | ||
| 361 | else | ||
| 362 | if 'root' == _.who then | ||
| 363 | print('Installing ' .. lua) | ||
| 364 | __('mkdir -p /usr/local/share/lua/' .. l:sub(16) .. ' ; ln -s ' .. _.dir .. '/PolygLua.lua ' .. lua):Do() | ||
| 365 | else | ||
| 366 | print(lua .. ' NOT installed') | ||
| 367 | end | ||
| 368 | end | ||
| 369 | end | ||
| 370 | |||
| 371 | end | ||
| 372 | end | ||
| 373 | }, | ||
| 374 | uninstall = | ||
| 375 | { | ||
| 376 | help = 'Command to uninstall PolygLua.lua', | ||
| 377 | func = function(self, options, a, args, i) | ||
| 378 | if 'root' ~= _.who then | ||
| 379 | E'Need to be root user to uninstall.' | ||
| 380 | else | ||
| 381 | print('UNINSTALLING PolygLua.lua!!!') | ||
| 382 | goAway('Uninstalling') | ||
| 383 | end | ||
| 384 | end | ||
| 385 | }, | ||
| 386 | purge = | ||
| 387 | { | ||
| 388 | help = 'Command to purge PolygLua.lua', | ||
| 389 | func = function(self, options, a, args, i) | ||
| 390 | if 'root' ~= _.who then | ||
| 391 | E'Need to be root user to purge.' | ||
| 392 | else | ||
| 393 | print('PURGING PolygLua.lua!!!') | ||
| 394 | goAway('Purging') | ||
| 395 | end | ||
| 396 | end | ||
| 397 | }, | ||
| 398 | } | ||
| 399 | |||
| 400 | _.parse(arg, options) | ||
| 401 | end | ||
| 402 | |||
| 403 | |||
| 404 | |||
| 405 | return _ | ||
| @@ -14,7 +14,7 @@ | |||
| 14 | ### END INIT INFO | 14 | ### END INIT INFO |
| 15 | ]] | 15 | ]] |
| 16 | 16 | ||
| 17 | local _ = require 'PolygLua' | 17 | local _ = require 'polygLua' |
| 18 | Version = '0.0 crap' | 18 | Version = '0.0 crap' |
| 19 | 19 | ||
| 20 | local function goAway() | 20 | local function goAway() |
diff --git a/test_.lua b/test_.lua deleted file mode 100755 index 9e1931a..0000000 --- a/test_.lua +++ /dev/null | |||
| @@ -1,186 +0,0 @@ | |||
| 1 | #!/usr/bin/env luajit | ||
| 2 | |||
| 3 | if type(jit) == 'table' then | ||
| 4 | print(arg[0] .. ' is being run by ' .. jit.version .. ' under ' .. jit.os .. ' on a ' .. jit.arch .. '. Lua version ' .. _VERSION) | ||
| 5 | else | ||
| 6 | print(arg[0] .. ' is being run by Lua version ' .. _VERSION) | ||
| 7 | end | ||
| 8 | |||
| 9 | |||
| 10 | local _ = require 'PolygLua' | ||
| 11 | |||
| 12 | |||
| 13 | I'Starting from the top.' | ||
| 14 | |||
| 15 | Help = [[ | ||
| 16 | This is part of the blah blah blah... | ||
| 17 | ]] | ||
| 18 | |||
| 19 | Version = '0.0 crap' | ||
| 20 | |||
| 21 | local options = | ||
| 22 | { | ||
| 23 | start = {help = 'Command to start the scanning process, for Sys V init.', value = 'blah'}, | ||
| 24 | -- restart = {start}, | ||
| 25 | -- ['force-reload'] = {start}, | ||
| 26 | status = {help = 'Command to check the status of the scanning process, for Sys V init.',}, | ||
| 27 | stop = {help = 'Command to stop the scanning process, for Sys V init.',}, | ||
| 28 | JACK = {help = 'Command to start the JACK stuff, for users.',}, | ||
| 29 | STOP = {help = 'Command to stop the JACK stuff, for users.', | ||
| 30 | func = function(self, options, a, args, i) | ||
| 31 | --[=[ | ||
| 32 | _.killEmAll{'qsynth'} | ||
| 33 | __[[ | ||
| 34 | a2j_control --stop | ||
| 35 | sleep 2 | ||
| 36 | a2j_control --exit | ||
| 37 | sleep 2 | ||
| 38 | ]]:Do() | ||
| 39 | _.killEmAll{'alsa_in', 'alsa_out', 'zita-a2j', 'zita-j2a', 'aseqjoy', 'jack-plumbing'} | ||
| 40 | __[[ | ||
| 41 | sleep 2 | ||
| 42 | jack_control stop | ||
| 43 | sleep 2 | ||
| 44 | jack_control exit | ||
| 45 | sleep 2 | ||
| 46 | ]]:Do() | ||
| 47 | _.killEmAll{'jmcore', 'qjackctl'} | ||
| 48 | -- Catia is python, and no easy way to kill it. | ||
| 49 | -- Also it keeps jackdbus alive, no matter how hard you kill it. | ||
| 50 | __'pkill -TERM -u $USER -f catia':Do() | ||
| 51 | __'sleep 2':Do() | ||
| 52 | _.killEmAll{'jackdbus', 'a2jmidid'} | ||
| 53 | ]=] | ||
| 54 | end | ||
| 55 | }, | ||
| 56 | install = | ||
| 57 | { | ||
| 58 | help = 'Command to install aataaj.lua', | ||
| 59 | func = function(self, options, a, args, i) | ||
| 60 | local w = __[[whoami]]:noErr():Do().lines[1] | ||
| 61 | local d = __[[pwd]]:noErr():Do().lines[1] | ||
| 62 | if 'root' ~= w then | ||
| 63 | E'Need to be root user to install.' | ||
| 64 | else | ||
| 65 | print('INSTALLING!!!') | ||
| 66 | __[[#!/bin/bash | ||
| 67 | echo "Installing PolygLua" | ||
| 68 | ./PolygLua.lua -vvvv | ||
| 69 | ]]:log():show():Do() | ||
| 70 | end | ||
| 71 | os.exit(0) | ||
| 72 | end | ||
| 73 | }, | ||
| 74 | } | ||
| 75 | options['restart'] = options['start'] | ||
| 76 | options['force-reload'] = options['start'] | ||
| 77 | |||
| 78 | print('start = ' .. options.start.value) | ||
| 79 | _.parse(arg, options, 'test_') | ||
| 80 | print('start = ' .. options.start.value) | ||
| 81 | print('stop = ' .. options.stop.value) | ||
| 82 | |||
| 83 | |||
| 84 | |||
| 85 | __[[ | ||
| 86 | echo -n "This'll print forking later. " | ||
| 87 | date | ||
| 88 | sleep 2 | ||
| 89 | ]]:log():show():fork('echo -n "later is "; date') | ||
| 90 | print('') | ||
| 91 | |||
| 92 | |||
| 93 | local GUI = 'qjackctl' | ||
| 94 | if _.runnable'catia' then GUI = 'catia' end | ||
| 95 | local speaker = 'espeak' | ||
| 96 | if _.runnable'espeak-ng' then speaker = 'espeak-ng' end | ||
| 97 | print('' .. GUI .. ' ' .. speaker) | ||
| 98 | print('') | ||
| 99 | |||
| 100 | for i,l in ipairs(__'free -h':log():Do().lines) do | ||
| 101 | print(l) | ||
| 102 | end | ||
| 103 | print('') | ||
| 104 | |||
| 105 | for i,l in ipairs(__'uname -a\nfree -h':log():Do().lines) do | ||
| 106 | print(l) | ||
| 107 | end | ||
| 108 | print('') | ||
| 109 | |||
| 110 | __'uname -a':log():Then'free -h':show():Do() | ||
| 111 | print('') | ||
| 112 | |||
| 113 | __{'uname -a', 'free -h'}:log():show():Do() | ||
| 114 | print('') | ||
| 115 | |||
| 116 | |||
| 117 | print(__[[#!/bin/NoSuchCommand | ||
| 118 | echo "Should not print." | ||
| 119 | ]]:log():show():Do().status) | ||
| 120 | print('') | ||
| 121 | |||
| 122 | __[[#!/bin/bash | ||
| 123 | echo "G'day world from bash." | ||
| 124 | ]]:log():show():Do() | ||
| 125 | print('') | ||
| 126 | |||
| 127 | print(__[[#!/usr/bin/tcc -run | ||
| 128 | #include <tcclib.h> | ||
| 129 | |||
| 130 | int main() | ||
| 131 | { | ||
| 132 | printf("G'day world from C.\n"); | ||
| 133 | return 1; | ||
| 134 | } | ||
| 135 | ]]:log():show():Do().status) | ||
| 136 | print('') | ||
| 137 | |||
| 138 | __[[#!/usr/bin/env luajit | ||
| 139 | print("G'day " .. "world " .. [=[from]=] .. ' Lua.') | ||
| 140 | ]]:log():show():Do() | ||
| 141 | print('') | ||
| 142 | |||
| 143 | __[[#!/usr/bin/perl | ||
| 144 | print "G'day world from perl.\n"; | ||
| 145 | ]]:log():show():Do() | ||
| 146 | print('') | ||
| 147 | |||
| 148 | __[[#!/usr/bin/env php | ||
| 149 | <?php | ||
| 150 | print("G'day world from php.\n"); | ||
| 151 | ]]:log():show():Do() | ||
| 152 | print('') | ||
| 153 | |||
| 154 | -- Note no indent for Python, coz whitespace is significant. | ||
| 155 | __[[#!/usr/bin/env python3 | ||
| 156 | print("G'day world from python.") | ||
| 157 | ]]:log():show():Do() | ||
| 158 | print('') | ||
| 159 | |||
| 160 | __[[#!/usr/bin/ruby | ||
| 161 | puts "G'day world from ruby." | ||
| 162 | ]]:log():show():Do() | ||
| 163 | print('') | ||
| 164 | |||
| 165 | |||
| 166 | print(__'true':log():show():Do().status) | ||
| 167 | print(__'false':log():show():Do().status) | ||
| 168 | print(__'exit 42':log():show():Do().status) | ||
| 169 | print(__'return 42':log():show():Do().status) | ||
| 170 | print(__'command NoSuchCommand':log():show():Do().status) | ||
| 171 | |||
| 172 | |||
| 173 | --__'qpdfview':forkOnce() | ||
| 174 | --__'qpdfview':forkOnce() | ||
| 175 | |||
| 176 | print('') | ||
| 177 | |||
| 178 | for i,a in ipairs(arg) do print('arg[' .. i .. '] = ' .. a) end | ||
| 179 | print('') | ||
| 180 | for k,a in pairs(arg) do print('arg[' .. k .. '] = ' .. a) end | ||
| 181 | |||
| 182 | __'date':log():show():Do() | ||
| 183 | -- Should get that "later" thing printed while the sleep is happening. | ||
| 184 | __'date; sleep 5; date':log():show():Do() | ||
| 185 | |||
| 186 | |||
