Possible: Yes, but probably not for me. Maybe someone who is better at reverse engineering could do it
I'll make a GUI where it will be possible to remove packages.

On TI-Nspire CX CAS, somewhere between 0x102167A8 and 0x102167F8 you have in [R4] (char **) a pointer to the char sequence containing the name of the currently confirmed deleted file.

But as said, before, whatever the type, lua, basic, or ndless, it should not have to matter to the program (both computer and calc side)

As said by other people earlier, there is no interest in making pacspire support Lua nor Basic program, since they are only one-file-made.

Should I add my 2 cents ?

Only from what I can see in the topic (i.e. I never tested anything), something that bother me is the number of files/folders created.
Remember how slow the TI-Nspire is on generating the MyDocument view, and here with only one project it creates dozens of files.

Maybe pacspire should hide those files and offers a way to unhide them, such as Hide Manager (by renaming the files/folders such that they do not appear in the MyDocument view).

On the other hand, as for the user-friendly part, as hoffa said, remember its only a calculator, and imagine yourself explain to this type of guy (no offense here) how to use pacspire : I doubt it would be easy, but who knows if pacspire comes included with Ndless package ?

Also, I know nFrame is not yet ready, but would it help for the userfriendly part ?

Anyway, as for the others, I really like this project and would like to push it beyong its limits !

I really don't understand why you're struggling with scoped-variables-overriding.

What I mean :
local foo = 42
{ -- new scope, it can a function, for, while, etc ..
    local foo = 69
    print(foo) -- prints 69
}
print(foo) -- prints 42
Is that a new concept for you ?

Because here, "self" is the object itself, it won't colide with current scope variables.

Thus, this is valid :
Foo = class()
function Foo:init(x, y, z)
  self.x = x
  self.y = y
  self.z = z
end

And this is invalid :
Foo = class()
function Foo:init(xx, yy, zz)
  x = xx
  y = yy
  z = zz
end


But obviously, this is also valid :
Foo = class()
function Foo:init(xx, yy, zz)
  self.x = xx
  self.y = yy
  self.z = zz
end


thank you... Is the call and the structure in LUA for NSpire the same?

Yes, the same. TI did not reinvented the Lua, they only turned it event-based and added their API.

Do you have a short example?

The example given in the second link will work
local status, err = pcall(function () a = 'a'+1 end)
print(err)     --> stdin:1: attempt to perform arithmetic on a string value

local status, err = pcall(function () error("my error") end)
print(err)     --> stdin:1: my error


Hi,

Why would you use xpcall instead of pcall since on TI-Nspire the "debug" package is not available ?
Anyway, just google-it
http://www.fxcodebase.com/documents/IndicoreSDK/lua/pdf-xpcall.html
http://www.lua.org/pil/8.5.html

Can i use any function which i have created with the program editor?

I don't understand your question (maybe because its answer is obvious) I'm just looking forward finding a deeper problem : do you have any source code ?

Ah, I'm making stupid mistakes again, I go back and look at it again and see that that line is within the function BallClass:init(x, y, radius)

Oh of course, I get what ipairs is now. Takes all the indices in numbered order (ones that can be ordered anyway), and has the indicies and keys from the table in pairs. Ok.

Oh wow I didn't know that _ could be used as a variable. Kinda like a wild card. Is it?

Spoiler For This question isn't so important, the more pressing stuff is below:

so can _ be used mixed like how you would search using * in other languages
Eg: you have variables bark, bork, berk
can you look for b_rk somehow?

No, "_" is just a valid char as a variable name such as _a, _foo, ________bar, foo_bar or even _ or _____, etc ...
Futhermore, "_" is in the Lua's culture (same in OCaml for example) a junk variable. It is then used when you know you don't want to use it.
But this doesn't mean it has a special meaning for the Lua's interpretor, for example this works :
local _o = 42
for _=1, _o do
 print(_, _+1, _o/_)
end


Quote

":" is just a shortcut for a.b(self)

So PointClass:init(x, y) is a shortcut for PointClass.init(PointClass, x, y)

I'm trying to work through in my mind the connections between all this stuff, and I still don't quite get it. I even drew a diagram, draft version, probably some mistake in there .
To describe what i'm not getting, it's the syntax that's getting me. I'm having trouble understanding the meaning of certain parts of the syntax lua classes use.

Yes ":" is a shortcut to "." + self, you understood that well.
Where you're going "too far" in the understanding is that you substitude "self" as the ClassName which is not always the case.
"self" is a dynamic variable, its meaning is determined at running time. Just remind that "self" refers to the first argument when using the ":" notation.
For example, these 3 calls are differents :
Toto = class()
function Toto:init()
  print(self)
end

Toto:init()     -- equivalent to Toto.init(Toto)
lol = Toto()   -- equivalent to Toto.init(temp) where "temp" will be stored in "lol"
lal = lol.init({}) -- here we force "self" to be "{}", an empty table


How does that translate to something in a table?

This is an intersting deep question. Jim will maybe better explain than me, but I'll try something :
In Lua, table have a "prototype" table that describe their content and how to access an element. This inner table is called "metatable".
You can get/set the metatables using getmetatable(tbl) or setmetatable(tbl, meta).
There are special elements of the metatable that changes the meaning of tbl[a] for example, or t1 + t2. It's like operator overloading.

Metatables in classes are used to transfert all the links to the functions from the "template" (the class) to the "instance" (the object) without copying them.
This means that when you're doing foo = Foo(), you end up with a new table (foo) that has the metatable of Foo (the class) that refers to every single function you defined in Foo (Foo.bar() for example).
Using the same principle, when doing Bar = class(Foo), you end up with a new table (Bar) that has the metatable of Foo (the parent class) that refers to every single function you defined in Foo. What's the difference then ? Foo() will also call Foo:init() after the copy (the constructor).

Quote from: Legimet on July 28, 2013, 09:42:08 am

Hmm, I looked in the nspire_emu source code and it has a bool value break_on_warn, which is set to true if you have a /W. But break_on_warn is not set to false in the first place! So I guess it could have true or false, randomly.

Global variables should default to 0 (false in this case).

It totally depends on the compiler. For example, clang++ does initialize global variables whereas g++ does not : Already had this behavior on a project where it worked using clang++ but not with g++. Initializing this var to something solved the problem.