07:52 <Regenaxer> Fixed the wiki article about namespaces

08:17 <tankf33der> next task

08:17 <tankf33der> http://adventofcode.com/2016/day/10

08:26 <yunfan> Regenaxer: the ref should be fix too

08:26 <yunfan> i found my latest pil hasnt support `pil -vi`

08:26 <Regenaxer> Hi tankf33der, yunfan

08:26 <Regenaxer> Which ref do you mean?

08:26 <yunfan> hold on

08:28 <yunfan> https://software-lab.de/doc/ref.html#intro

08:28 <yunfan> check the chapter `Invocation`

08:29 <Regenaxer> yes?

08:29 <Regenaxer> What should `pil -vi` do? Invoke 'vi' without args?

08:30 <Regenaxer> You need at least '+' to get debug mode

08:30 <Regenaxer> Without it vi is not defined

08:30 <Regenaxer> pil -vi +

08:30 <Regenaxer> but (vi) without args does nothing

08:31 <yunfan> aha

08:31 <yunfan> got it

08:31 <yunfan> sorry for my mistake

08:31 <Regenaxer> np

08:39 <Regenaxer> Ah, (vi) *does* something: "without arguments permanently switches the REPL line editor"

08:40 <Regenaxer> So it creates a file .pil/editor

08:40 <Regenaxer> I did not notice because I switched the editor to vip

08:42 <Regenaxer> i.e. I have lib/vip.l on the command line in my startup scripts

11:24 <aw-> hi all

11:24 <Regenaxer> Hi aw-!

11:33 <aw-> Regenaxer: if I use (call 'script.sh) <-- calling a bash script, if I type in the screen, nothing appears

11:33 <aw-> it's probably something minor

11:34 <Regenaxer> What should appear?

11:35 <aw-> text?

11:36 <aw-> the bash script is doing something like: read

11:36 <aw-> to read input

11:36 <Regenaxer> Then you need a pipe

11:36 <Regenaxer> (out '(script) (prinl "...

11:37 <aw-> (prinl what?

11:37 <aw-> what do i prinl ?

11:37 <Regenaxer> 'call' has stdio to the terminal

11:37 <Regenaxer> How should I know what input your script needs?

11:38 <aw-> i don't think I understand..

11:38 <Regenaxer> hmm

11:39 <Regenaxer> It depends whether pil is in raw mode

11:39 <aw-> if I do (call) from a pil script, i can't interact with the program being called?

11:39 <Regenaxer> eg 'vi' calls Vim in default mode

11:39 <Regenaxer> you can, but it may depend on the terminal settings

11:39 <aw-> err sorry.. i **can** interact with it, it's just that whatever i type doesn't appear on screen

11:40 <Regenaxer> Try (call "vim" "a") in both 'pil' and 'pil +'

11:40 <Regenaxer> So you are in raw mode

11:41 <aw-> yes i'm in raw mode, i just checked with (raw)

11:41 <aw-> in my program

11:41 <Regenaxer> ok

11:41 <Regenaxer> then do (raw NIL) before the call

11:41 <Regenaxer> and perhaps (raw T) after

11:41 <aw-> i tried that, script goes crazy

11:42 <Regenaxer> yeah, this is a nasty issue

11:43 <Regenaxer> What script is that?

11:43 <Regenaxer> Does it itself set terminal parameters like Vim?

11:43 <Regenaxer> or does it just read standard input as it is?

11:44 <Regenaxer> Does it use readline? If so it also modifies stty

11:45 <Regenaxer> I think you are fine if you start pil without debug mode

11:45 <Regenaxer> Then it does not modify the tty

11:45 <aw-> yes it's not running under debug

11:45 <aw-> it's just a 1 line bash script

11:45 <aw-> using 'read' builtin

11:46 <Regenaxer> No, I'm wrong

11:46 <Regenaxer> vim does work only in debug mode

11:46 <Regenaxer> which is fine in this case ;)

11:47 <Regenaxer> Ah, we were talking about the REPL here

11:47 <Regenaxer> if it is a script, you need (in NIL (call ...

11:48 <Regenaxer> hmm, no, sorry

11:49 <Regenaxer> But vim is special anyway, as it uses curses

11:49 <Regenaxer> I think if your script does not change the tty, it would work

11:49 <Regenaxer> Try a simple 'cat'

11:50 <Regenaxer> Bash uses readline and thus modifies tty too

11:52 <aw-> wait let me give you an example

11:53 <aw-> script.sh contents

11:53 <aw-> #!/bin/bash

11:53 <aw-> read -t 30 -r -e check_str

11:53 <aw-> echo "GOT: $check_str"

11:54 <aw-> call that script.sh from pil, and it doesn't echo output when typing

11:54 <Regenaxer> Bash uses readline and thus modifies tty too

11:54 <aw-> ohhh wait

11:54 <aw-> -r is raw disable

11:55 <Regenaxer> Not sure what this implies ...

11:55 <aw-> ah same thing

11:55 <aw-> http://wiki.bash-hackers.org/commands/builtin/read

11:56 <Regenaxer> I would not rely on 'call' I/O settings here

11:56 <Regenaxer> (out '(script) (while (line) (prinl @]

11:56 <aw-> why not?

11:57 <Regenaxer> We had lots of discussions

11:57 <Regenaxer> about the right tcsetpgrp() calls

11:57 <Regenaxer> setpgid()

11:58 <Regenaxer> Terminal settings are a mess in Unix

11:58 <aw-> i recall discussing this issue with you.. or something similar

11:58 <Regenaxer> I don't know the right way

11:58 <Regenaxer> yeah, I asked several people

11:58 <Regenaxer> Vim or Vip work fine however

11:59 <Regenaxer> when pil is in raw mode

12:00 <aw-> 'passwd works as well

12:00 <Regenaxer> hmm

12:00 <aw-> well... passwd doesn't echo the pass anyways haha

12:00 <Regenaxer> what about 'cat' in the script?

12:00 <aw-> cat works

12:00 <Regenaxer> stdin -> stoout

12:00 <aw-> i've used that in the past

12:00 <Regenaxer> mom, tel

12:27 <aw-> ok this is a waste of time, it will be faster for me to just re-write the bash script in picolisp

12:40 <Regenaxer> Sorry, yeah, I'm still on the phone

14:30 <reed> Hi all, I'm reading the documentation on the C foreign function interface, trying to write some wrapper functions for api in "linux/joystick.h". The joystick event wraps a few varieties of integers. Would a type declaration in an FFI call need to be different for a struct containing a signed 32 bit integer, compared to an unsigned 16 bit integer?

14:33 <tankf33der> reed: start with something simpler

14:34 <reed> tankf33der: Good advice. But even with a toy example, just a function that randomly returns an unsigned 32 bit integer and a different function that randomly returns a signed 16 bit integer, would the interface be different?

14:35 <tankf33der> show function prototype from h file

14:37 <tankf33der> i'm still feel timidly with (native) function

14:39 <reed> for intstance "usigned long f1();" vs "signed int f2();"

14:41 <tankf33der> it will be (native "joy.so" "f1" 'N ...)

14:41 <tankf33der> interface will be different for every function because you need native for "f1" and "f2"

14:41 <reed> So the 'N because its a "long"? and (native "joy.so" "f2" 'I) because it's an int?

14:42 <tankf33der> lets say yes.

14:42 <tankf33der> http://rosettacode.org/wiki/MD5#PicoLisp

14:42 <reed> Thanks. I'll give it a shot

14:42 <tankf33der> clone my repo and find all strings with native

14:43 <tankf33der> as start point

14:45 <tankf33der> next

14:46 <tankf33der> take this md5 example and convert to sha256 and sha512 and check with python or something else.

14:46 <tankf33der> good homework.

14:50 <Regenaxer> reed, just to be sure, you use pil64? To be able to use 'native'

14:51 <reed> Regenaxer: Yes, I'm using pil64

14:51 <reed> I'm just trying to figure out how the 'I 'B 'S, in the FFI etc map to the C types. Particularly when there's unsigned and signed stuff happening

14:53 <Regenaxer> I is a signed 32 bit int

14:53 <Regenaxer> N is a 64bit or pointer

14:54 <Regenaxer> If the C function returns only a 32 bit value, negative results need to be converted

14:54 <Regenaxer> Can you show a prototype of the C function here?

14:55 <tankf33der> reed> for intstance "usigned long f1();" vs "signed int f2();"

14:55 <reed> So the same would apply to short ints? I would need to convert them to an int or a long first?

14:56 <Regenaxer> yes, so (native "lib.so" "f1" 'N)

14:56 <Regenaxer> vs (native "lib.so" "f1" 'I)

14:56 <tankf33der> vs (native "lib.so" "f2" 'I)

14:56 <Regenaxer> I signed int is just 'I'

14:57 <Regenaxer> 'N' is also signed

14:57 <Regenaxer> Have you tried it?

14:57 <Regenaxer> Just experiment on the REPL

14:57 <reed> I'm in the process. Thank you!

14:58 <Regenaxer> :)

15:08 <beneroth> hi all

15:10 <Regenaxer> Hi beneroth

15:40 <beneroth> brb