aabc2/KOS_qrcodes
1
0
Fork 0
forked from KolibriOS/kolibrios
Code Pull Requests Activity

- Module files are removed from the source folder.

Browse Source 
- Removed fasm debug module. 
- Added debug function to "kolibri" module.

git-svn-id: svn://kolibrios.org@8475 a494cfbc-eb01-0410-851d-a64ba20cac60
This commit is contained in:
superturbocat2001
2020-12-25 23:07:44 +00:00
parent 4930c1d7a2
commit 6db1f4dd5a
11 changed files with 35 additions and 351 deletions
Download Patch File Download Diff File Expand all files Collapse all files

19
programs/develop/tinypy/tinypy/Makefile
View File

@@ -13,21 +13,24 @@ CFLAGS = -U_Win32 -U_WIN32 -U__MINGW32__ -mpreferred-stack-boundary=2 \
INCLUDES= -I. -I$(SDK_DIR)/sources/newlib/libc/include
LIBPATH:= -L $(SDK_DIR)/lib -L /home/autobuild/tools/win32/mingw32/lib
OBJECTS = tpmain.o kolibri_init.o kolibri_fs.o kolibri_gui.o kolibri_net.o kolibri_dbg.obj
KOLIBRI_M_OBJ= ../modules/kolibri/init.o \
../modules/kolibri/fs.o \
../modules/kolibri/net.o \
../modules/kolibri/gui.o \
../modules/kolibri/debug.o \
OBJECTS = tpmain.o $(KOLIBRI_M_OBJ)
all:$(NAME)
$(NAME): $(OBJECTS) Makefile
$(NAME): $(OBJECTS)
$(LD) $(LIBPATH) --subsystem native -o $@ $(OBJECTS) $(LDFLAGS) -n -Map $(NAME).map
kos32-objcopy $@ -O binary
kpack $@
%.o : %.c Makefile
$(CC) -c $(INCLUDES) $(CFLAGS) -o $@ $<
kolibri_dbg.obj: fasm_modules/kolibri_dbg.s
fasm fasm_modules/kolibri_dbg.s
cp fasm_modules/kolibri_dbg.obj .
clean:
-rm -f *.o $(NAME).map fasm_modules/kolibri_dbg.obj kolibri_dbg.obj
rm -f *.o $(NAME).map $(KOLIBRI_M_OBJ)

155
programs/develop/tinypy/tinypy/fasm_modules/kolibri_dbg.s
View File

@@ -1,155 +0,0 @@
; TinyPy module
; Name: kolibri_dbg
;
; Exports:
; debug_print(msg) - prints a message to debug board.
format coff
use32 ; Tell compiler to use 32 bit instructions
section '.init' code ; Keep this line before includes or GCC messes up call addresses
include '../../../proc32.inc'
include '../../../struct.inc'
purge section,mov,add,sub
include 'tinypy.inc'
include '../../../../programs/dll.inc'
extrn '_tp_dict' as tp_dict
extrn '_tp_set' as tp_set
extrn '_tp_get' as tp_get
extrn '_tp_None' as tp_None
extrn '_tp_fnc' as tp_fnc
public kolibri_dbg_init as '_kolibri_dbg_init'
; Module name
modname db "kolibri_dbg"
modnamelen = $-modname
; Exported function name
debug_print_name db "debug_print"
debug_print_namelen = $-debug_print_name
; Export dictionary for module
kolibri_dbg_dict rb sizeof.tp_obj
; tp_obj of exported function
debug_print_obj rb sizeof.tp_obj
; Function debug_print(tp_vm *tp)
; return nothing
debug_print:
push ebp
mov ebp, esp
; Store registers
push eax
push ebx
push ecx
push edx
sub esp, sizeof.tp_obj; Reserve tp_obj tmp
mov edx, esp
push edx ;Store &tmp
; Obtain tp_string parameter
; tp_get(&tmp, tp, *(tp_obj *)(tp_vm->params), tp_None)
push_tp_none
mov eax, dword[ebp+12] ;4 for return address, 4 for result pointer; 4 for tp_vm
add eax, tp_vm.params
push_tp_obj_at_reg eax
push dword[ebp+12]
push edx ;ebx contains address of reserved tp_obj variable
call tp_get
;Restore stack
add esp, sizeof.tp_obj*2+4;2 tp_obj's and 2 pointers in parameters minus 1 pointer to result (cleared inside tp_get)
;Leave if parameter is not a string. tp_raise() should be called here.
pop edx; edx = &tmp
cmp dword[edx], TP_STRING ; Check that function returned a TP_STRING
jne .exit
mov ecx, dword[edx+tp_string_.len] ; String length
mov edx, dword[edx+tp_string_.val] ;
mov eax, 63
mov ebx, 1
.cont:
; Print message.
push ecx ; Store ecx to use it in inner loop
mov cl, byte[edx]
inc edx
int 40h
pop ecx ; Get ecx back
loop .cont
.exit:
add esp, sizeof.tp_obj ; Release tp_obj reserved in stack.
; Returning tp_None
mov eax, dword[ebp+8]
mov dword[eax], 0
; Restore registers
pop edx
pop ecx
pop ebx
pop eax
mov esp, ebp
pop ebp
ret
;void kolibri_dbg_init(tp_vm *tp);
kolibri_dbg_init:
push ebp
mov ebp, esp
;Save registers
push eax
push ebx
push ecx
; Create module dictionary and store its address in kolibri_dbg_str
mov eax, dword [ebp + 8]
push eax
push kolibri_dbg_dict
call tp_dict
add esp, 4 ;Clear stack
; Push tp_obj structure pointed by kolibri_dbg_dict
push_tp_obj kolibri_dbg_dict
; Push modname as a tp_obj object
push modnamelen; len
push modname ; val
push 0 ;_tp_string info
push TP_STRING ; type
; Push tp_obj structure pointed by tp->modules
mov eax, dword [ebp + 8]
add eax, tp_vm.modules + 16
mov ecx, 4
.push_tpobj1:
sub eax, 4
push dword[eax]
loop .push_tpobj1
push eax
call tp_set
add esp, sizeof.tp_obj*3+4
; Register "debug_print" function
;Reserve memory for function tp_obj object
sub esp, sizeof.tp_obj
mov eax, esp
push debug_print
push dword[ebp+8]
push eax
call tp_fnc
add esp, 8; tp_obj is already in stack, adding other arguments
;Pushing function name tp_obj
;mov eax, esp
;push_tp_obj_at_reg eax
push debug_print_namelen
push debug_print_name
push 0
push TP_STRING
;Pushing module dictionary tp_obj
push_tp_obj kolibri_dbg_dict
;Pushing tp_vm
push dword[ebp+8]
call tp_set
add esp, sizeof.tp_obj*3+4
; Leaving function
pop ecx
pop ebx
pop eax
mov esp, ebp
pop ebp
ret

184
programs/develop/tinypy/tinypy/fasm_modules/tinypy.inc
View File

@@ -1,184 +0,0 @@
; Python object types
TP_NONE equ 0
TP_NUMBER equ 1
TP_STRING equ 2
TP_DICT equ 3
TP_LIST equ 4
TP_FNC equ 5
TP_DATA equ 6
; Python "number" object. Can be treated as integer or float.
struct tp_number_
type rd 1
val rd 1
ends
; GC information for "string" object
struct _tp_string
gci rd 1
s rb 1
ends
; Python "string" object
struct tp_string_
type rd 1
info rd 1 ;pointer to _tp_string
val rd 1
len rd 1
ends
; GC information for "list" object
struct _tp_list
gci rd 1
items rd 1
len rd 1
alloc rd 1
ends
; Python "list" object
struct tp_list_
type rd 1
val rd 1 ;pointer to _tp_list
ends
; GC information for "dict" object
struct _tp_dict
gci rd 1
items rd 1
len rd 1
alloc rd 1
cur rd 1
mask rd 1
used rd 1
ends
; Python "dict" object
struct tp_dict_
type rd 1
val rd 1 ;pointer to _tp_dict
ends
; GC information for "function" object
; todo
; Python "function" object
struct tp_fnc_
type rd 1
info rd 1
ftype rd 1
val rd 1
ends
; Python "data" object
struct tp_data_
type rd 1
info rd 1
val rd 1
magic rd 1
ends
struct tp_gc_info
type rd 1
data rd 1
ends
; Generic Python object
struct tp_obj
union
type rd 1
string tp_string_
number tp_number_
gc_info tp_gc_info
dict tp_dict_
list tp_list_
fnc tp_fnc_
dat tp_data_
ends
ends
; Bytecode element
struct sregs
.i rb 1
.a rb 1
.b rb 1
.c rb 1
ends
struct tp_code
union
i rb 1
regs sregs
string rb 4
number rp 1
ends
ends
; TinyPy VM frame
struct tp_frame_
.codes rd 1
.cur rd 1
.jump rd 1
.regs rd 1
.ret_dest rd 1
.fname rb sizeof.tp_obj
.name rb sizeof.tp_obj
.line rb sizeof.tp_obj
.globals rb sizeof.tp_obj
.lineno rd 1
.cregs rd 1
ends
; TinyPy VM
TP_FRAMES equ 256
struct tp_vm
builtins rb sizeof.tp_obj
modules rb sizeof.tp_obj
frames rb TP_FRAMES*sizeof.tp_frame_
_params rb sizeof.tp_obj
params rb sizeof.tp_obj
_regs rb sizeof.tp_obj
regs rq 1
root rb sizeof.tp_obj
jmp_buf rd 1
jump rd 1
ex rb sizeof.tp_obj
chars rb 512
cur rd 1
white rb sizeof._tp_list
grey rb sizeof._tp_list
black rb sizeof._tp_list
strings rb sizeof._tp_dict
steps rd 1
ends
macro push_tp_none
{
local .push_more
mov ecx, 4
.push_more:
push 0
loop .push_more
}
macro push_tp_obj obj
{
local .push_more
mov ebx, obj + 12
mov ecx, 4
.push_more:
push dword[ebx]
sub ebx, 4
loop .push_more
}
macro push_tp_obj_at_reg reg
{
local .push_more
add reg, 12
mov ecx, 4
.push_more:
push dword[reg]
sub reg, 4
loop .push_more
}

1
programs/develop/tinypy/tinypy/kolibri_fs.c
View File

@@ -1 +0,0 @@
#include "../modules/kolibri/fs.c"

163
programs/develop/tinypy/tinypy/kolibri_gui.c
View File

@@ -1,163 +0,0 @@
#include "tp.h"
#include <kos32sys.h>
typedef unsigned short int uint16_t;
typedef unsigned int uint32_t;
extern void _tp_raise(TP,tp_obj);
extern tp_obj tp_dict(TP);
extern tp_obj tp_method(TP,tp_obj self,tp_obj v(TP));
extern tp_obj tp_number(tp_num v);
extern tp_obj tp_list(TP);
extern void _tp_list_append(TP,_tp_list *self, tp_obj v);
extern tp_obj tp_call(TP, const char *mod, const char *fnc, tp_obj params);
extern void _tp_call(TP,tp_obj *dest, tp_obj fnc, tp_obj params);
extern int tp_bool(TP,tp_obj v);
extern tp_obj tp_has(TP,tp_obj self, tp_obj k);
// #define _cdecl __attribute__((cdecl))
extern int (* _cdecl con_printf)(const char* format,...);
static tp_obj kolibri_show(TP)
{
tp_obj self = TP_TYPE(TP_DICT);
uint16_t xpos = (uint16_t)(tp_get(tp, self, tp_string("x")).number.val);
uint16_t ypos = (uint16_t)tp_get(tp, self, tp_string("y")).number.val;
uint16_t height = (uint16_t)tp_get(tp, self, tp_string("height")).number.val;
uint16_t width = (uint16_t)tp_get(tp, self, tp_string("width")).number.val;
uint16_t fixedsize = (uint16_t)tp_get(tp, self, tp_string("fixedsize")).number.val;
uint32_t bgcolor = (uint32_t)tp_get(tp, self, tp_string("bgcolor")).number.val;
uint32_t status;
uint32_t style;
uint32_t x = xpos * 0x10000 + width;
uint32_t y = ypos * 0x10000 + height;
if (fixedsize)
style = 0;
else
style = 0x33000000 + (bgcolor & 0xFFFFFF);
asm volatile ("int $0x40"::"a"(12), "b"(1));
asm volatile ("int $0x40"::
"a"(0), "b"(x), "c"(y), "d"(style),
"S"(0), "D"(0));
asm volatile ("int $0x40"::"a"(12), "b"(2));
/* If window has additional handler, run it. */
if (tp_bool(tp, tp_has(tp, self, tp_string("on_show"))))
{
tp_obj result;
tp_obj fnc = tp_get(tp, self, tp_string("on_show"));
tp_obj param_list = tp_list(tp); /* Prepare parameters. */
_tp_list_append(tp, param_list.list.val, self);
_tp_call(tp, &result, fnc, param_list);
}
return tp_None;
}
static void window_function(void)
{
uint32_t ev;
/* Wait for event. */
do {
asm volatile("int $0x40":"=a"(ev):"a"(10));
} while(ev != 3);
asm volatile("int $040"::"a"(-1));
}
static tp_obj kolibri_default_handler(TP)
{
return tp_None;
}
/* Run window_function() in separated thread. */
static tp_obj kolibri_run(TP)
{
tp_obj self = TP_TYPE(TP_DICT);
tp_obj redraw = tp_get(tp, self, tp_string("show"));
tp_obj result;
tp_obj key_handler = tp_None;
tp_obj button_handler = tp_None;
int button_id;
uint32_t ev;
int leave=0;
tp_obj param_list;
/* Obtain handlers. */
if (tp_bool(tp, tp_has(tp, self, tp_string("on_key"))))
key_handler = tp_get(tp, self, tp_string("on_key"));
if (tp_bool(tp, tp_has(tp, self, tp_string("on_button"))))
button_handler = tp_get(tp, self, tp_string("on_button"));
while(!leave){
asm volatile("int $0x40":"=a"(ev):"a"(10));
switch (ev)
{
case 1:
_tp_call(tp, &result, redraw, tp_None);
break;
case 2:
if (key_handler.type == TP_FNC)
{
param_list = tp_list(tp); /* Prepare parameters. */
_tp_list_append(tp, param_list.list.val, self);
oskey_t key;
key = get_key();
_tp_list_append(tp, param_list.list.val, tp_number(key.code));
_tp_call(tp, &result, key_handler, param_list);
}
break;
case 3:
button_id = get_os_button();
if (button_id == 1)
leave = 1;
else if (button_handler.type == TP_FNC)
{
param_list = tp_list(tp); /* Prepare parameters. */
_tp_list_append(tp, param_list.list.val, self);
_tp_list_append(tp, param_list.list.val, tp_number(button_id));
_tp_call(tp, &result, button_handler, param_list);
}
break;
default:
con_printf("Got unknown event %d\n", ev);
break;
}
};
return tp_None;
}
static tp_obj kolibri_print_text(TP)
{
tp_obj self = TP_TYPE(TP_DICT);
uint32_t textcolor = (uint32_t)tp_get(tp, self, tp_string("textcolor")).number.val;
uint16_t x = (uint16_t)tp_get(tp, self, tp_string("curx")).number.val;
uint16_t y = (uint16_t)tp_get(tp, self, tp_string("cury")).number.val;
uint32_t ofs;
uint32_t width = (uint32_t)tp_get(tp, self, tp_string("width")).number.val;
tp_obj text = TP_TYPE(TP_STRING);
draw_text_sys((char *)text.string.val, x, y, text.string.len, textcolor);
/* Update cursor position. */
ofs = 6 * text.string.len;
tp_set(tp, self, tp_string("cury"), tp_number(y + 9 * ((x + ofs) / width)));
tp_set(tp, self, tp_string("curx"), tp_number((x + ofs)%width));
return tp_None;
}
tp_obj kolibri_mainwindow(TP)
{
tp_obj obj = tp_dict(tp);
obj = tp_dict(tp);
tp_set(tp, obj, tp_string("x"), TP_TYPE(TP_NUMBER));
tp_set(tp, obj, tp_string("y"), TP_TYPE(TP_NUMBER));
tp_set(tp, obj, tp_string("height"), TP_TYPE(TP_NUMBER));
tp_set(tp, obj, tp_string("width"), TP_TYPE(TP_NUMBER));
tp_set(tp, obj, tp_string("curx"), tp_number(0));
tp_set(tp, obj, tp_string("cury"), tp_number(0));
tp_set(tp, obj, tp_string("fixedsize"), TP_TYPE(TP_NUMBER));
tp_set(tp, obj, tp_string("textcolor"), tp_number(0x202020));
tp_set(tp, obj, tp_string("bgcolor"), tp_number(0xFFFFFF));
tp_set(tp, obj, tp_string("show"), tp_method(tp, obj, kolibri_show));
tp_set(tp, obj, tp_string("run"), tp_method(tp, obj, kolibri_run));
/*tp_set(tp, obj, tp_string("keyhandler"), tp_method(tp, obj, kolibri_default_handler));
tp_set(tp, obj, tp_string("buttonhandler"), tp_method(tp, obj, kolibri_default_handler));*/
tp_set(tp, obj, tp_string("print_text"), tp_method(tp, obj, kolibri_print_text));
return obj;
}

1
programs/develop/tinypy/tinypy/kolibri_init.c
View File

@@ -1 +0,0 @@
#include "../modules/kolibri/init.c"

296
programs/develop/tinypy/tinypy/kolibri_net.c
View File

@@ -1,296 +0,0 @@
#include <sys/socket.h>
// #include <menuet/net.h>
#include "tp.h"
extern tp_obj tp_dict(TP);
extern tp_obj tp_method(TP,tp_obj self,tp_obj v(TP));
extern tp_obj tp_fnc(TP,tp_obj v(TP));
extern tp_obj tp_get(TP,tp_obj self, tp_obj k);
tp_obj tp_has(TP,tp_obj self, tp_obj k);
// #define _cdecl __attribute__((cdecl))
extern int (* _cdecl con_printf)(const char* format,...);
#define PRECISION 0.000001
#define GET_SOCKET_DESCRIPTOR(_obj, _sock) do{ \
if (fabs(tp_has(tp, _obj, tp_string("socket")).number.val) < PRECISION)\
tp_raise(tp_None, "Socket not open", tp_None); \
_sock = (__u32)(tp_get(tp, _obj, tp_string("socket")).number.val + PRECISION);\
} while(0)
/* Socket close method.
*
* Example:
* s.close() # s must be a socket object created by socket.
*
* Raises exception if socket was not opened. Otherwise returns True.
*/
static tp_obj kolibri_close_socket(TP)
{
// tp_obj self = TP_TYPE(TP_DICT);
// __u32 socktype;
// __u32 s;
// GET_SOCKET_DESCRIPTOR(self, s);
// socktype = (__u32)tp_get(tp, self, tp_string("type")).number.val;
// GET_SOCKET_DESCRIPTOR(self, s);
// if (socktype == SOCK_STREAM)
// __menuet__close_TCP_socket(s);
// else if (socktype == SOCK_DGRAM)
// __menuet__close_UDP_socket(s);
return tp_True;
}
/* Socket send method.
*
* Example:
* data="<html><head><title>Preved!!!</title></head><body>Example.</body></html>"
* s.send(data)
* or:
* s.send(data, 20) # Send just 20 bytes
*/
static tp_obj kolibri_send(TP)
{
// tp_obj self = TP_TYPE(TP_DICT);
// tp_obj data_obj = TP_TYPE(TP_STRING);
// __u32 datalen = TP_DEFAULT(tp_False).number.val;
// __u32 socktype = (__u32)tp_get(tp, self, tp_string("type")).number.val;
// __u32 s;
// int result;
// GET_SOCKET_DESCRIPTOR(self, s);
// if (datalen < 0 || datalen > data_obj.string.len)
// datalen = data_obj.string.len;
// if (socktype == SOCK_STREAM)
// result = __menuet__write_TCP_socket(s, datalen, (void *)data_obj.string.val);
// else if (socktype == SOCK_DGRAM)
// result = __menuet__write_UDP_socket(s, datalen, (void *)data_obj.string.val);
// return tp_number(!(result != 0));
return tp_number(0);
}
#define __u32 unsigned int
#define __u8 unsigned char
/* Socket recv method.
*
* data="<html><head><title>Preved!!!</title></head><body>Example.</body></html>"
* s.recv(data)
* or:
* s.recv(data, 20) # Send just 20 bytes
*/
static tp_obj kolibri_recv(TP)
{
tp_obj self = TP_TYPE(TP_DICT);
__u32 datalen = TP_DEFAULT(tp_False).number.val;
__u32 s;
__u8 c;
__u8 *buf, *p;
__u32 buf_size;
__u32 bytes_read = 0;
int i;
// GET_SOCKET_DESCRIPTOR(self, s);
// if (datalen)
// buf_size = datalen;
// else
// buf_size = 2048;
// if (!(buf = malloc(datalen)))
// tp_raise(tp_None, "Cannot allocate buffer for received data", tp_None);
// p = buf;
// while (__menuet__read_socket(s, &c) && bytes_read < buf_size)
// {
// *p++ = c;
// bytes_read++;
// if (bytes_read >= buf_size && !datalen)
// {
// buf_size += 1024;
// buf = realloc(buf, buf_size);
// }
// }
return tp_string_n(buf, bytes_read);
}
static void inet_pton(TP, const char *buf, int len, __u32 *addr)
{
char *p = (char *)buf;
int i = 0;
__u32 val = 0;
*addr = 0;
while (*p && p < buf + len && i < 4)
{
if (*p == '.' || !*p)
{
if (val > 255)
tp_raise(tp_None, "ValueError: number > 255 in IP address", tp_None);
*addr += (val << ((i++) << 3));
val = 0;
}
else
{
if (*p < '0' || *p > '9')
tp_raise(tp_None, "ValueError: bad char in IP address, digit expected", tp_None);
val = val * 10 + *p - '0';
}
p++;
}
if (!*p)
{
if (i == 3)
*addr += (val << ((i++) << 3));
else
tp_raise(tp_None, "ValueError: bad IP address", tp_None);
}
}
/* Converter from string presentation to binary address. */
static tp_obj kolibri_inet_pton(TP)
{
tp_obj obj;
__u32 addr;
obj = TP_TYPE(TP_STRING);
// inet_pton(tp, (char *)obj.string.val, (int)obj.string.len, &addr);
return tp_number(addr);
}
/* Socket bind method.
*
* In KolibriOS it just sets local address and port.
*
* Example:
* s.bind('10.10.1.2', 6000) #Connects to 10.10.1.2:6000
*/
tp_obj kolibri_bind(TP)
{
// tp_obj self = TP_TYPE(TP_DICT);
// tp_obj local_addr_obj = TP_OBJ();
// __u32 local_port = (__u32)TP_TYPE(TP_NUMBER).number.val;
// __u32 local_addr;
// if (local_addr_obj.type == TP_NUMBER)
// local_addr = local_addr_obj.number.val;
// else if (local_addr_obj.type == TP_STRING)
// inet_pton(tp, (const char *)local_addr_obj.string.val, local_addr_obj.string.len, &local_addr);
// tp_set(tp, self, tp_string("local_addr"), tp_number(local_addr));
// tp_set(tp, self, tp_string("local_port"), tp_number(local_port));
return tp_None;
}
/* Socket connect method.
*
* Example:
* s.connect('10.10.1.1', 7000) #Connects to 10.10.1.1:7000
*/
tp_obj kolibri_connect(TP)
{
// tp_obj self = TP_TYPE(TP_DICT);
// tp_obj remote_addr_obj = TP_OBJ();
// __u32 remote_addr;
// __u32 remote_port = (__u32)TP_TYPE(TP_NUMBER).number.val;
// __u32 local_port = tp_get(tp, self, tp_string("local_port")).number.val;
// __u32 socktype = (__u32)tp_get(tp, self, tp_string("type")).number.val;
// int s = -1; /* Socket descriptor */
// if (remote_addr_obj.type == TP_NUMBER)
// remote_addr = remote_addr_obj.number.val;
// else if (remote_addr_obj.type == TP_STRING)
// inet_pton(tp, (const char *)remote_addr_obj.string.val, remote_addr_obj.string.len, &remote_addr);
// if (socktype == SOCK_STREAM)
// s = __menuet__open_TCP_socket(local_port, remote_port, remote_addr, 1);
// else if (socktype == SOCK_DGRAM)
// s = __menuet__open_UDP_socket(local_port, remote_port, remote_addr);
// if (s >= 0)
// {
// tp_set(tp, self, tp_string("socket"), tp_number(s));
// return tp_True;
// }
// else
return tp_False;
}
/* Socket listen method.
*
* Example:
* s.listen('10.10.1.1', 5000)
*/
tp_obj kolibri_listen(TP)
{
// tp_obj self = TP_TYPE(TP_DICT);
// tp_obj remote_addr_obj = TP_OBJ();
// __u32 remote_addr;
// __u32 remote_port = (__u32)TP_TYPE(TP_NUMBER).number.val;
// __u32 local_port = tp_get(tp, self, tp_string("local_port")).number.val;
// __u32 socktype = (__u32)tp_get(tp, self, tp_string("type")).number.val;
// int s = -1; /* Socket descriptor */
// if (socktype != SOCK_STREAM)
// tp_raise(tp_None, "IOError: attempt to listen on non-TCP socket", tp_None);
// if (remote_addr_obj.type == TP_NUMBER)
// remote_addr = remote_addr_obj.number.val;
// else if (remote_addr_obj.type == TP_STRING)
// inet_pton(tp, (const char *)remote_addr_obj.string.val, remote_addr_obj.string.len, &remote_addr);
// if ((s = __menuet__open_TCP_socket(local_port, remote_port, remote_addr, 0)) >= 0)
// {
// tp_set(tp, self, tp_string("socket"), tp_number(s));
// return tp_True;
// }
// else
return tp_False;
}
/* Exported function.
*
* Example:
*
* s = socket(socket.AF_INET, socket.SOCK_DGRAM)
*
* Returns socket object.
*/
tp_obj kolibri_socket(TP)
{
tp_obj s;
tp_obj sockfamily = TP_TYPE(TP_NUMBER);
tp_obj socktype = TP_TYPE(TP_NUMBER);
// if (fabs(sockfamily.number.val - AF_INET) > PRECISION ||
// (fabs(socktype.number.val - SOCK_STREAM) > PRECISION &&
// fabs(socktype.number.val - SOCK_DGRAM) > PRECISION))
// return tp_None;
s = tp_dict(tp);
// tp_set(tp, s, tp_string("family"), sockfamily);
// tp_set(tp, s, tp_string("type"), socktype);
// tp_set(tp, s, tp_string("bind"), tp_method(tp, s, kolibri_bind));
// tp_set(tp, s, tp_string("connect"), tp_method(tp, s, kolibri_connect));
// tp_set(tp, s, tp_string("send"), tp_method(tp, s, kolibri_send));
// tp_set(tp, s, tp_string("recv"), tp_method(tp, s, kolibri_recv));
// tp_set(tp, s, tp_string("close"), tp_method(tp, s, kolibri_close_socket));
// if (fabs(socktype.number.val - SOCK_STREAM) < PRECISION)
// tp_set(tp, s, tp_string("listen"), tp_method(tp, s, kolibri_listen));
return s;
}
tp_obj kolibri_socket_module(TP)
{
tp_obj socket_mod = tp_dict(tp);
// tp_set(tp, socket_mod, tp_string("AF_INET"), tp_number(AF_INET));
// tp_set(tp, socket_mod, tp_string("SOCK_STREAM"), tp_number(SOCK_STREAM));
// tp_set(tp, socket_mod, tp_string("SOCK_DGRAM"), tp_number(SOCK_DGRAM));
tp_set(tp, socket_mod, tp_string("AF_INET"), tp_number(0));
tp_set(tp, socket_mod, tp_string("SOCK_STREAM"), tp_number(0));
tp_set(tp, socket_mod, tp_string("SOCK_DGRAM"), tp_number(0));
tp_set(tp, socket_mod, tp_string("inet_pton"), tp_fnc(tp, kolibri_inet_pton));
tp_set(tp, socket_mod, tp_string("socket"), tp_fnc(tp, kolibri_socket));
return socket_mod;
}

1
programs/develop/tinypy/tinypy/test.py
View File

@@ -10,6 +10,7 @@ def onbtn():
print("Button pressed")
if __name__=="__main__":
kolibri.debug_print("Debug test line\n")
w = kolibri.window(10,10,400, 400, False)
w.on_show = onshow
w.on_key = onkey

3
programs/develop/tinypy/tinypy/tpmain.c
View File

@@ -2,11 +2,10 @@
/* INCLUDE */
const char header[]="TinyPy for kolibriOS";
extern void (*kolibri_dbg_init)(tp_vm *tp) __attribute__((__stdcall__));
//extern void kolibri_dbg_init(tp_vm *tp); //__attribute__((__stdcall__));
void main(int argc, const char *argv[]) {
tp_vm *tp = tp_init(argc, argv);
// kolibri_dbg_init(tp);
kolibri_init(tp);
CONSOLE_INIT(header);
/* INIT */