Subversion Repositories Kolibri OS

Compare Revisions

No changes between revisions

Regard whitespace Rev 1664 → Rev 1665

/programs/system/shell/bin/.shell
0,0 → 1,5
#SHS
 
about
echo Type 'help' for help
echo
/programs/system/shell/bin/shell.kex
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property
/programs/system/shell/bin
Property changes:
Added: tsvn:logminsize
+5
\ No newline at end of property
/programs/system/shell/clean.bat
0,0 → 1,2
del shell.kex
del *.o
/programs/system/shell/cmd/cmd_about.c
0,0 → 1,17
 
int cmd_about(char param[])
{
 
char message[] = {
"\
\n\r\
Shell for KolibriOS\n\r\
version %s\n\r\n\r\
author: Oleksandr Bogomaz aka Albom\n\r\
e-mail: albom85@yandex.ru\n\r\
site: http://albom85.narod.ru/\n\r\n\r\
"};
 
printf(message, SHELL_VERSION);
return TRUE;
}
/programs/system/shell/cmd/cmd_alias.c
0,0 → 1,19
 
int cmd_alias(char arg[])
{
 
int result;
 
if (NULL == arg)
{
alias_list();
return TRUE;
}
 
result = alias_check(arg);
 
if ( ( 0 != result ) && ( -1 != result ) )
alias_add(arg);
 
return TRUE;
}
/programs/system/shell/cmd/cmd_ccpuid.c
0,0 → 1,33
 
int cmd_ccpuid(char param[])
{
unsigned a, b, c, d;
char str[13];
 
str[12] = '\0';
 
asm ("cpuid" :
"=a" (a),
"=b" (b),
"=c" (c),
"=d" (d):
"a"(0));
 
str[0] = (b&0x000000ff) >> 0;
str[1] = (b&0x0000ff00) >> 8;
str[2] = (b&0x00ff0000) >> 16;
str[3] = (b&0xff000000) >> 24;
 
str[4] = (d&0x000000ff) >> 0;
str[5] = (d&0x0000ff00) >> 8;
str[6] = (d&0x00ff0000) >> 16;
str[7] = (d&0xff000000) >> 24;
 
str[8] = (c&0x000000ff) >> 0;
str[9] = (c&0x0000ff00) >> 8;
str[10] = (c&0x00ff0000) >> 16;
str[11] = (c&0xff000000) >> 24;
 
printf("%s\n\r", str);
return TRUE;
}
/programs/system/shell/cmd/cmd_cd.c
0,0 → 1,47
 
int cmd_cd(char dir[])
{
 
char temp[256];
unsigned result;
 
if (NULL == dir)
{
printf(" cd directory\n\r");
return FALSE;
}
 
if ( 0 == strcmp(dir, ".") )
return FALSE;
 
if ( ( 0 == strcmp(dir, "..") ) && ( 0 != strcmp(cur_dir, "/")) )
{
cur_dir[strlen(cur_dir)-1]='\0';
dir_truncate(cur_dir);
return FALSE;
}
 
if ( '/' == dir[0])
{
if ( dir_check(dir) )
{
strcpy(cur_dir, dir);
return TRUE;
}
return FALSE;
}
else
{
strcpy(temp, cur_dir);
strcat(temp, dir);
 
if ( dir_check(temp) )
{
strcpy(cur_dir, temp);
return TRUE;
}
 
return FALSE;
}
 
}
/programs/system/shell/cmd/cmd_clear.c
0,0 → 1,6
 
int cmd_clear(char param[])
{
con_cls();
return TRUE;
}
/programs/system/shell/cmd/cmd_date.c
0,0 → 1,23
 
 
int cmd_date(char param[])
{
unsigned date;
unsigned time;
 
date = kol_system_date_get();
printf(" date [dd.mm.yy]: %x%x.%x%x.%x%x",
(date&0xf00000)>>20, (date&0xf0000)>>16, // day
(date&0xf000)>>12, (date&0xf00)>>8, //month
(date&0xf0)>>4, (date&0xf) ); // year
 
 
time = kol_system_time_get();
 
printf("\n\r time [hh:mm:ss]: %x%x:%x%x:%x%x\n\r",
(time&0xf0)>>4, (time&0xf), // hours
(time&0xf000)>>12, (time&0xf00)>>8, // minutes
(time&0xf00000)>>20, (time&0xf0000)>>16 ); // seconds
 
return TRUE;
}
/programs/system/shell/cmd/cmd_echo.c
0,0 → 1,6
 
int cmd_echo(char text[])
{
printf("%s\n\r", text);
return TRUE;
}
/programs/system/shell/cmd/cmd_exit.c
0,0 → 1,8
 
int cmd_exit(char param[])
{
free(ALIASES);
_exit(1);
kol_exit();
return TRUE;
}
/programs/system/shell/cmd/cmd_free.c
0,0 → 1,14
 
int cmd_free(char param[])
{
unsigned total, free, used;
 
total = kol_system_mem();
free = kol_system_memfree();
used = total - free;
 
printf (" total [kB / MB / %%]: %-7d / %-5d / 100\n\r free [kB / MB / %%]: %-7d / %-5d / %d\n\r used [kB / MB / %%]: %-7d / %-5d / %d\n\r",
total, total/1024, free, free/1024, (free*100)/total, used, total/1024-free/1024, 100-(free*100)/total );
return TRUE;
}
/programs/system/shell/cmd/cmd_help.c
0,0 → 1,32
 
int cmd_help(char cmd[])
{
 
int i;
 
char available[]={" %d commands available:\n\r"};
 
if ( !strlen(cmd) )
{
printf (available, NUM_OF_CMD);
for (i = 0; i < NUM_OF_CMD; i++)
printf(" %s\n\r", COMMANDS[i].name);
return TRUE;
}
else
{
for (i=0; i<NUM_OF_CMD; i++)
if ( !strcmp(cmd, COMMANDS[i].name) )
{
printf(COMMANDS[i].help);
return TRUE;
}
 
printf (" Command \'%s\' not found.\n\r", cmd);
printf (available, NUM_OF_CMD);
for (i = 0; i < NUM_OF_CMD; i++)
printf(" %s\n\r", COMMANDS[i].name);
}
 
return FALSE;
}
/programs/system/shell/cmd/cmd_kill.c
0,0 → 1,43
 
 
int _atoi ( char *s )
{
int i, n;
n = 0;
for ( i = 0; s[i]!= '\0'; ++i)
if ((s[i]<'0') || (s[i]>'9'))
return 0;
else
n = 10 * n + s[i] - '0';
 
return n;
}
 
 
 
int cmd_kill(char process[])
{
 
unsigned proc;
int result;
 
if (NULL == process)
{
printf(" kill PID\n\r");
return FALSE;
}
else
{
proc = _atoi(process);
if ( 0 != proc )
{
result = kol_process_kill_pid(proc);
if (result < 0)
return FALSE;
else
return TRUE;
}
}
 
}
/programs/system/shell/cmd/cmd_ls.c
0,0 → 1,47
 
int cmd_ls(char dir[])
{
 
kol_struct70 k70;
unsigned *n;
unsigned num_of_file;
unsigned *t;
unsigned type_of_file;
int i;
 
k70.p00 = 1;
k70.p04 = 0;
k70.p08 = 0;
k70.p12 = 2*1024*1024; // 2 MB
k70.p16 = malloc(2*1024*1024);
k70.p20 = 0;
 
/// !!!
// Åñëè ls çàïóñêàåòñÿ áåç ïàðàìåòðîâ, ïðîñìàòðèâàåì òåêóùèé êàòàëîã
if ( !strlen(dir) )
k70.p21 = cur_dir;
else
k70.p21 = dir;
if ( !kol_file_70(&k70) ) // ïðîâåðÿåì ñóùåñòâîâàíèå êàòàëîãà
{
free(k70.p16);
return FALSE;
}
 
n = k70.p16+8;
num_of_file = *n; // ÷èñëî ôàéëîâ â êàòàëîãå
 
for (i = 0; i < num_of_file; i++)
{
printf (" %s", k70.p16+32+40+(264+40)*i);
t = k70.p16+32+(264+40)*i;
type_of_file = *t;
if ( (0x10 == (type_of_file&0x10)) || (8 == (type_of_file&8)) )
printf ("/");
printf ("\n\r");
}
 
free(k70.p16);
return TRUE;
}
/programs/system/shell/cmd/cmd_mkdir.c
0,0 → 1,44
 
int cmd_mkdir(char dir[])
{
 
char temp[256];
kol_struct70 k70;
unsigned result;
 
if (NULL == dir)
{
printf(" mkdir directory\n\r");
return FALSE;
}
 
 
if ( 0 == strcmp(dir, ".") || ( 0 == strcmp(dir, "..") ) || ( 0 == strcmp(cur_dir, "/")) )
{
return FALSE;
}
 
k70.p00 = 9;
k70.p04 = 0;
k70.p08 = 0;
k70.p12 = 0;
k70.p16 = 0;
k70.p20 = 0;
 
if ( '/' == dir[0])
k70.p21 = dir;
else
{
strcpy(temp, cur_dir);
strcat(temp, dir);
k70.p21 = temp;
}
 
result = kol_file_70(&k70);
 
if (0 == result)
return TRUE;
else
return FALSE;
 
}
/programs/system/shell/cmd/cmd_more.c
0,0 → 1,87
 
int cmd_more(char file[])
{
 
kol_struct70 k70;
kol_struct_BDVK bdvk;
unsigned result, filesize, pos, i;
char buf[81]; //áóôåð
char temp[256];
unsigned flags;
 
if (NULL == file)
{
printf (" less filename\n\r");
return FALSE;
}
 
if ( '/' == file[0])
{
strcpy(temp, file);
 
if ( !file_check(temp) )
{
return FALSE;
}
}
else
{
strcpy(temp, cur_dir);
strcat(temp, file);
if ( !file_check(temp) )
{
return FALSE;
}
}
 
k70.p00 = 5;
k70.p04 = k70.p08 = k70.p12 = 0;
k70.p16 = &bdvk;
k70.p20 = 0;
k70.p21 = temp;
 
result = kol_file_70(&k70); // ïîëó÷àåì èíôîðìàöèþ î ôàéëå
if ( 0 != result )
return FALSE;
 
filesize = bdvk.p32[0]; // ïîëó÷àåì ðàçìåð ôàéëà
 
buf[80]=0;
flags = con_get_flags();
 
for (pos=0;pos<filesize;pos+=80)
{
 
memset(buf, 0, 80);
 
k70.p00 = 0;
k70.p04 = pos;
k70.p08 = 0;
k70.p12 = 80;
k70.p16 = buf;
k70.p20 = 0;
k70.p21 = temp;
 
result = kol_file_70(&k70); // ÷òåíèå 80 ñèìâîëîâ
for (i=0; i<80; i++)
{
 
if (27 == buf[i])
con_set_flags(flags|0x100);
else con_set_flags(flags);
 
printf ("%c", buf[i]);
}
if ( 0 != result )
{
con_set_flags(flags);
printf ("\n\r");
return TRUE;
}
 
}
con_set_flags(flags);
printf ("\n\r");
return TRUE;
}
/programs/system/shell/cmd/cmd_ps.c
0,0 → 1,32
 
int cmd_ps(char param[])
{
 
int i, n;
char *buf1k;
unsigned PID;
unsigned *p;
short *s;
short STATE;
 
buf1k = malloc(1024);
if (NULL == buf1k)
return FALSE;
 
for (i = 1;;i++)
{
n = kol_process_info(i, buf1k);
p = buf1k+30;
PID = *p;
s = buf1k+50;
STATE = *s;
if ( 9 != STATE)
printf (" %7d %s\n\r", PID, buf1k+10);
if (i == n)
break;
}
 
free(buf1k);
return TRUE;
 
}
/programs/system/shell/cmd/cmd_pwd.c
0,0 → 1,6
 
int cmd_pwd(char param[])
{
printf (" %s\n\r", cur_dir);
return TRUE;
}
/programs/system/shell/cmd/cmd_reboot.c
0,0 → 1,6
 
int cmd_reboot(char param[])
{
kol_system_end(3);
return TRUE;
}
/programs/system/shell/cmd/cmd_rm.c
0,0 → 1,50
 
int cmd_rm(char file[])
{
 
kol_struct70 k70;
char temp[256];
unsigned result;
 
if (NULL == file)
{
printf (" rm filename\n\r");
return FALSE;
}
 
if ( '/' == file[0])
{
strcpy(temp, file);
 
if ( !file_check(temp) )
{
return FALSE;
}
}
else
{
strcpy(temp, cur_dir);
strcat(temp, file);
if ( !file_check(temp) )
{
return FALSE;
}
}
 
k70.p00 = 8;
k70.p04 = 0;
k70.p08 = 0;
k70.p12 = 0;
k70.p16 = 0;
k70.p20 = 0;
k70.p21 = temp;
 
result = kol_file_70(&k70);
 
if (0 == result)
return TRUE;
else
return FALSE;
 
}
/programs/system/shell/cmd/cmd_rmdir.c
0,0 → 1,46
 
int cmd_rmdir(char dir[])
{
 
char temp[256];
kol_struct70 k70;
unsigned result;
 
if (NULL == dir)
{
printf(" rmdir directory\n\r");
return FALSE;
}
 
if ( ( 0 == strcmp(dir, ".") ) || ( 0 == strcmp(dir, "..") ) || ( 0 == strcmp(cur_dir, "/")) )
{
return FALSE;
}
 
k70.p00 = 8;
k70.p04 = 0;
k70.p08 = 0;
k70.p12 = 0;
k70.p16 = 0;
k70.p20 = 0;
 
if ( '/' == dir[0])
k70.p21 = dir;
else
{
strcpy(temp, cur_dir);
strcat(temp, dir);
k70.p21 = temp;
}
 
if ( !dir_check(temp) )
return FALSE;
 
result = kol_file_70(&k70);
 
if (0 == result)
return TRUE;
else
return FALSE;
 
}
/programs/system/shell/cmd/cmd_sleep.c
0,0 → 1,12
 
int cmd_sleep(char param[])
{
int delay;
 
if (!strlen(param))
return FALSE;
 
delay = _atoi(param);
kol_sleep((unsigned)delay);
return TRUE;
}
/programs/system/shell/cmd/cmd_touch.c
0,0 → 1,54
 
int cmd_touch(char file[])
{
 
kol_struct70 k70;
char temp[256];
unsigned result;
 
if (NULL == file)
{
printf(" touch filename\n\r");
return FALSE;
}
 
if ( ( 0 == strcmp(file, ".") ) || ( 0 == strcmp(file, "..") ) || ( 0 == strcmp(cur_dir, "/")) )
{
return FALSE;
}
 
if ( '/' == file[0])
{
strcpy(temp, file);
 
if ( !file_check(temp) )
k70.p00 = 2;
else
k70.p00 = 3;
}
else
{
strcpy(temp, cur_dir);
strcat(temp, file);
if ( !file_check(temp) )
k70.p00 = 2;
else
k70.p00 = 3;
}
 
k70.p04 = 0;
k70.p08 = 0;
k70.p12 = 0;
k70.p16 = 0;
k70.p20 = 0;
k70.p21 = temp;
 
result = kol_file_70(&k70);
 
if (0 == result)
return TRUE;
else
return FALSE;
 
}
/programs/system/shell/cmd/cmd_ver.c
0,0 → 1,6
 
int cmd_ver(char param[])
{
printf (" %s\n\r", SHELL_VERSION);
return TRUE;
}
/programs/system/shell/cmd
Property changes:
Added: tsvn:logminsize
+5
\ No newline at end of property
/programs/system/shell/modules/module_alias.c
0,0 → 1,126
 
/// ===========================================================
 
int alias_check(char alias[])
{
 
unsigned i;
char buf1[256];
char buf2[256];
 
if ( !alias_split (alias, buf1, buf2))
return FALSE;
 
 
for (i = 0; i < NUM_OF_CMD; i++)
if ( !strcmp(COMMANDS[i].name, buf1) )
return -1;
 
if (NULL == ALIASES)
return FALSE;
 
for (i = 0; i < ALIAS_NUM; i++)
{
if ( !strcmp(ALIASES+256*i, buf1) )
return FALSE;
}
 
return TRUE;
}
 
/// ===========================================================
 
int alias_search(char alias[])
{
 
unsigned i;
 
for (i = 0; i < ALIAS_NUM; i++)
{
if ( !strcmp(ALIASES+256*i, alias) )
return i;
}
 
return -1;
}
 
/// ===========================================================
 
int alias_add(char alias[])
{
 
char buf1[256];
char buf2[256];
 
if ( ALIAS_NUM > 255)
return FALSE;
 
if ( !alias_split (alias, buf1, buf2))
return FALSE;
 
strcpy (ALIASES+256*ALIAS_NUM, buf1);
strcpy (ALIASES+256*ALIAS_NUM+64*1024, buf2);
ALIAS_NUM++;
 
return TRUE;
}
 
/// ===========================================================
 
void alias_list()
{
 
unsigned i;
 
if ( 0 == ALIAS_NUM)
return;
 
for (i = 0; i < ALIAS_NUM; i++)
printf (" %s=%s\n\r",ALIASES+256*i, ALIASES+256*i+64*1024);
}
 
/// ===========================================================
 
int alias_split (char alias[], char s1[], char s2[])
{
 
unsigned i, j;
 
if (NULL == strchr(alias, '='))
return FALSE;
 
for (i=0, j = 0;; i++)
{
if ('=' == alias[i])
{
s1[i]='\0';
break;
}
s1[i]=alias[i];
}
 
j = 0;
 
for (;; i++, j++)
{
s2[j]=alias[i];
if ('\0' == alias[i])
break;
}
 
trim(s1);
 
for (i=0;;i++)
{
s2[i] = s2[i+1];
if ('\0' == s2[i] )
break;
}
 
trim(s2);
 
return TRUE;
 
}
 
/// ===========================================================
/programs/system/shell/modules/module_command.c
0,0 → 1,203
 
/// ===========================================================
 
void command_clear()
{
for (;CMD_POS;CMD_POS--)
printf("%c %c", 8, 8);
CMD[0]='\0';
}
 
/// ===========================================================
 
void command_history_add(char command[])
{
 
if ( (0 != strcmp( CMD_HISTORY[0], CMD)) &&
(0 != strcmp( CMD_HISTORY[1], CMD)) &&
(0 != strcmp( CMD_HISTORY[2], CMD)) &&
(0 != strcmp( CMD_HISTORY[3], CMD)) &&
(0 != strcmp( CMD_HISTORY[4], CMD)) )
 
{
strcpy(CMD_HISTORY[4], CMD_HISTORY[3]);
strcpy(CMD_HISTORY[3], CMD_HISTORY[2]);
strcpy(CMD_HISTORY[2], CMD_HISTORY[1]);
strcpy(CMD_HISTORY[1], CMD_HISTORY[0]);
 
strcpy(CMD_HISTORY[0], CMD);
}
 
}
 
/// ===========================================================
 
void command_get()
{
unsigned key;
//unsigned pos = 0;
int hist;
 
CMD_POS = 0;
CMD_NUM = 0;
 
for (;;)
{
key = getch();
if ( 0 != (key & 0xff) )
{
key &= 0xff;
switch (key)
{
case 27: // ESC
command_clear();
break;
 
case 13: // ENTER
CMD[CMD_POS] = '\0';
printf("\n\r");
 
command_history_add(CMD);
return;
 
case 8: // BACKSPACE
if (CMD_POS > 0)
{
printf ("%c %c", 8, 8);
CMD_POS--;
}
break;
 
case 9: // TAB
break;
 
default:
if (CMD_POS < 255)
{
CMD[CMD_POS] = key;
CMD_POS++;
printf("%c", key);
}
break;
};
}
else // îáðàáîòêà ðàñøèðåííûõ êëàâèø
{
key = (key>>8)&0xff;
// printf ("%d\n\r", key);
 
switch (key)
{
 
case 72: // UP
for (hist = 0; hist < CMD_HISTORY_NUM; hist++)
{
command_clear();
 
if (CMD_NUM < CMD_HISTORY_NUM-1)
CMD_NUM++;
else
CMD_NUM = 0;
printf( CMD_HISTORY[CMD_NUM] );
strcpy(CMD, CMD_HISTORY[CMD_NUM]);
if ((CMD_POS = strlen(CMD)) != 0)
break;
}
 
break;
 
case 80: // DOWN
for (hist = 0; hist < CMD_HISTORY_NUM; hist++)
{
command_clear();
 
if (CMD_NUM > 0)
CMD_NUM--;
else
CMD_NUM = CMD_HISTORY_NUM-1;
 
printf( CMD_HISTORY[CMD_NUM] );
strcpy(CMD, CMD_HISTORY[CMD_NUM]);
if ((CMD_POS = strlen(CMD)) != 0)
break;
}
break;
 
case 0: // console window closed
cmd_exit(NULL);
 
};
}
}
}
 
 
 
/// ===========================================================
 
int command_get_cmd(char cmd[])
{
unsigned i;
for (i=0;;i++)
{
cmd[i] = CMD[i];
if (0 == cmd[i])
{
i = -2;
break;
}
if ( iswhite(cmd[i]) )
{
cmd[i] = '\0';
break;
}
}
return i+1;
}
 
/// ===========================================================
 
typedef void (*handler1_t)(char* arg);
 
/// ===========================================================
 
void command_execute()
{
char cmd[256];
char args[256];
unsigned arg;
int i;
 
trim(CMD);
arg = command_get_cmd(cmd);
 
if ( !strlen(cmd) )
return;
 
strcpy(args, CMD+arg);
trim(args);
 
for (i = 0; i < NUM_OF_CMD; i++)
{
if (!strcmp(cmd, COMMANDS[i].name))
{
((handler1_t)COMMANDS[i].handler)(args);
return;
}
}
 
 
if ( -1 != alias_search(CMD) )
{
strcpy(CMD, ALIASES+64*1024+256*alias_search(CMD));
command_execute();
return;
}
 
executable_run(cmd, args);
 
}
 
/// ===========================================================
/programs/system/shell/modules/module_executable.c
0,0 → 1,60
 
/// ===========================================================
 
int executable_run(char cmd[], char args[])
{
 
char exec[256];
char error_starting[]={" No such command '%s'.\n\r"};
int result;
 
if ( '/' == cmd[0]) // åñëè ïóòü àáñîëáòíûé
{
strcpy(exec, cmd);
 
if ( !file_check(exec) ) // ïðîâåðÿåì ñóùåñòâîâàíèå ôàéëà
{
printf(error_starting, cmd);
return FALSE;
}
}
 
else
{
strcpy(exec, cur_dir); // ïðîâåðÿåì ôàéë â òåêóùåì êàòàëîãå
strcat(exec, cmd);
if ( !file_check(exec) ) // ïðîâåðÿåì ñóùåñòâîâàíèå ôàéëà
{
strcpy(exec, "/rd/1/"); // ïðîâåðÿåì ôàéë íà âèðòóàëüíîì äèñêå
strcat(exec, cmd);
if ( !file_check(exec) ) // ïðîâåðÿåì ñóùåñòâîâàíèå ôàéëà
{
printf(error_starting, cmd);
return FALSE;
}
}
}
 
 
if ( script_check(exec) )
{
return script_run(exec, args);
}
 
/* çàïóñê ïðîãðàììû */
result = program_run(exec, args);
if (result > 0)
{
printf (" '%s' started. PID = %d\n\r", cmd, result);
return TRUE;
}
else
{
printf(error_starting, cmd);
return FALSE;
}
 
}
 
/// ===========================================================
/programs/system/shell/modules/module_program.c
0,0 → 1,16
 
int program_run(char cmd[], char param[])
{
 
kol_struct70 k70;
 
k70.p00 = 7;
k70.p04 = 0;
k70.p08 = param;
k70.p12 = 0;
k70.p16 = 0;
k70.p20 = 0;
k70.p21 = cmd;
 
return kol_file_70(&k70);
}
/programs/system/shell/modules/module_script.c
0,0 → 1,102
 
/// ===========================================================
 
int script_check(char file[])
{
 
kol_struct70 k70;
char buf[4];
 
k70.p00 = 0;
k70.p04 = 0;
k70.p08 = 0;
k70.p12 = 4; // ÷èòàòü 4 áàéòà
k70.p16 = buf;
k70.p20 = 0;
k70.p21 = file;
 
kol_file_70(&k70);
 
if ( !strcmp(buf, script_sign) )
return TRUE;
else
return FALSE;
}
 
/// ===========================================================
 
int script_run(char exec[], char args[])
{
 
kol_struct70 k70;
kol_struct_BDVK bdvk;
unsigned result, filesize, pos, i;
char *buf; //áóôåð, êóäà êîïèðóåòñÿ ñêðèïò
 
k70.p00 = 5;
k70.p04 = k70.p08 = k70.p12 = 0;
k70.p16 = &bdvk;
k70.p20 = 0;
k70.p21 = exec;
 
result = kol_file_70(&k70); // ïîëó÷àåì èíôîðìàöèþ î ôàéëå
if ( 0 != result )
return FALSE;
 
filesize = bdvk.p32[0]; // ïîëó÷àåì ðàçìåð ôàéëà
 
buf = malloc(filesize+256);
if (NULL == buf)
return FALSE;
 
buf[filesize]=0;
 
k70.p00 = 0;
k70.p04 = k70.p08 = 0;
k70.p12 = filesize;
k70.p16 = buf;
k70.p20 = 0;
k70.p21 = exec;
 
result = kol_file_70(&k70); // ñ÷èòûâàåì ôàéë â áóôåð
if ( 0 != result )
{
free(buf);
return FALSE;
}
 
pos = 0;
 
for (;;) // îáðàáîòêà ñêðèïòà
{
 
if (pos > filesize)
break;
 
for (i=0;;i++) // ñ÷èòûâàíèå ñòðîêè
{
if ((0x0A == buf[pos])||(0x0D == buf[pos])||(0 == buf[pos]))
{
pos++;
CMD[i] = '\0';
break;
}
CMD[i] = buf[pos];
pos++;
}
 
if ( 0 == strlen(CMD) ) // ïóñòàÿ ñòðîêà
continue;
 
if ('#' == CMD[0]) // êîììåíòàðèé
continue;
 
command_execute();
 
}
 
free(buf);
return TRUE;
}
 
/// ===========================================================
/programs/system/shell/modules
Property changes:
Added: tsvn:logminsize
+5
\ No newline at end of property
/programs/system/shell/start.asm
0,0 → 1,41
 
format MS COFF
 
public Start
public _PATH
public _PARAM
 
extrn Memory
extrn hEnd
 
extrn _kol_main
 
section ".text" code
db "MENUET01"
dd 1, Start, hEnd, Memory, hStack, _PARAM, _PATH
 
Start:
 
; èíèöèàëèçàöèÿ êó÷è
mov eax, 68
mov ebx, 11
int 0x40
 
; âûçîâ ãëàâíîé ïðîöåäóðû
mov eax, _kol_main
call eax
 
; çàâåðøåíèå ðàáîòû ïðîãðàììû
mov eax, -1
int 0x40
 
section ".bss"
 
_PARAM:
rb 256
 
_PATH:
rb 256
 
rb 8*1024
hStack:
/programs/system/shell/system/boolean.h
0,0 → 1,3
 
#define FALSE 0
#define TRUE 1
/programs/system/shell/system/console.c
0,0 → 1,88
 
///===========================
 
#define CON_COLOR_BLUE 1
#define CON_COLOR_GREEN 2
#define CON_COLOR_RED 4
#define CON_COLOR_BRIGHT 8
/* öâåò ôîíà */
#define CON_BGR_BLUE 0x10
#define CON_BGR_GREEN 0x20
#define CON_BGR_RED 0x40
#define CON_BGR_BRIGHT 0x80
 
///===========================
 
void (* _stdcall con_init)(unsigned w_w, unsigned w_h, unsigned s_w, unsigned s_h, const char* t);
void (* _cdecl printf)(const char* format,...);
void (* _stdcall _exit)(char bCloseWindow);
void (* __stdcall gets)(char* str, int n);
int (* __stdcall getch)(void);
int (* __stdcall con_get_font_height)(void);
int (* __stdcall con_set_cursor_height)(int new_height);
unsigned (*__stdcall con_get_flags)(void);
unsigned (*__stdcall con_set_flags)(unsigned new_flags);
void (*__stdcall con_cls)(void);
 
///===========================
 
void CONSOLE_INIT(char title[])
{
kol_struct_import *imp;
 
imp = kol_cofflib_load("/sys/lib/console.obj");
if (imp == NULL)
kol_exit();
 
con_init = ( _stdcall void (*)(unsigned, unsigned, unsigned, unsigned, const char*))
kol_cofflib_procload (imp, "con_init");
if (con_init == NULL)
kol_exit();
 
printf = ( _cdecl void (*)(const char*,...))
kol_cofflib_procload (imp, "con_printf");
if (printf == NULL)
kol_exit();
 
_exit = ( _stdcall void (*)(char))
kol_cofflib_procload (imp, "con_exit");
if (_exit == NULL)
kol_exit();
 
gets = ( _stdcall void (*)(char*, int))
kol_cofflib_procload (imp, "con_gets");
if (gets == NULL)
kol_exit();
 
getch = ( _stdcall int (*)(void))
kol_cofflib_procload (imp, "con_getch2");
if (getch == NULL)
kol_exit();
 
con_get_font_height = ( _stdcall int (*)(void))
kol_cofflib_procload (imp, "con_get_font_height");
if (con_get_font_height == NULL)
kol_exit();
 
con_set_cursor_height = ( _stdcall int (*)(int))
kol_cofflib_procload (imp, "con_set_cursor_height");
if (con_set_cursor_height == NULL)
kol_exit();
 
con_get_flags = ( _stdcall unsigned (*)(void))
kol_cofflib_procload (imp, "con_get_flags");
if (con_get_flags == NULL)
kol_exit();
 
con_set_flags = ( _stdcall unsigned (*)(unsigned))
kol_cofflib_procload (imp, "con_set_flags");
if (con_set_flags == NULL)
kol_exit();
 
con_cls = ( _stdcall void (*)(void))
kol_cofflib_procload (imp, "con_cls");
if (con_cls == NULL)
kol_exit();
 
con_init(-1, -1, -1, -1, title);
}
/programs/system/shell/system/kolibri.c
0,0 → 1,412
 
#include "kolibri.h"
#include "string.h"
 
 
extern char KOL_PATH[256];
extern char KOL_PARAM[256];
extern char KOL_DIR[256];
 
 
void kol_exit()
{
asm ("int $0x40"::"a"(-1));
}
 
 
void kol_sleep(unsigned d)
{
asm ("int $0x40"::"a"(5), "b"(d));
}
 
 
void kol_wnd_define(unsigned x, unsigned y, unsigned w, unsigned h, unsigned c)
{
asm ("nop"::"a"(0), "b"(x*65536+w), "c"(y*65536+h), "d"(c));
asm ("movl $0xffffff, %esi \n int $0x40");
}
 
 
void kol_wnd_move(unsigned x, unsigned y)
{
asm ("nop"::"a"(67), "b"(x), "c"(y));
asm ("movl $-1, %edx \n movl $-1, %esi \n int $0x40");
}
 
 
void kol_event_mask(unsigned e)
{
asm ("int $0x40"::"a"(40), "b"(e));
}
 
 
unsigned kol_event_wait()
{
asm ("int $0x40"::"a"(10));
}
 
 
unsigned kol_event_wait_time(unsigned time)
{
asm ("int $0x40"::"a"(23), "b"(time));
}
 
 
unsigned kol_event_check()
{
asm ("int $0x40"::"a"(11));
}
 
 
void kol_paint_start()
{
asm ("int $0x40"::"a"(12), "b"(1));
}
 
 
void kol_paint_end()
{
asm ("int $0x40"::"a"(12), "b"(2));
}
 
 
void kol_paint_pixel(unsigned x, unsigned y, unsigned c)
{
asm ("int $0x40"::"a"(1), "b"(x), "c"(y), "d"(c));
}
 
 
void kol_paint_bar(unsigned x, unsigned y, unsigned w, unsigned h, unsigned c)
{
asm ("int $0x40"::"a"(13), "b"(x*65536+w), "c"(y*65536+h), "d"(c));
}
 
 
void kol_paint_line(unsigned x1, unsigned y1, unsigned x2, unsigned y2, unsigned c)
{
asm ("int $0x40"::"a"(38), "b"(x1*65536+x2), "c"(y1*65536+y2), "d"(c));
}
 
 
void kol_paint_string(unsigned x, unsigned y, char *s, unsigned c)
{
asm ("int $0x40"::"a"(4), "b"(x*65536+y), "c"(c), "d"(s));
}
 
 
void kol_paint_image(unsigned x, unsigned y, unsigned w, unsigned h, char *d)
{
asm ("int $0x40"::"a"(7), "c"(w*65536+h), "d"(x*65536+y), "b"(d));
}
 
 
void kol_paint_image_pal(unsigned x, unsigned y, unsigned w, unsigned h, char *d, unsigned *palette)
{
asm ("nop"::"c"(w*65536+h), "d"(x*65536+y), "b"(d));
asm ("nop"::"a"(palette));
asm ("movl %eax, %edi");
asm ("xor %eax, %eax");
asm ("movl %eax, %ebp");
asm ("pushl $8");
asm ("popl %esi");
asm ("int $0x40"::"a"(65));
}
 
 
unsigned kol_key_get()
{
asm ("int $0x40"::"a"(2));
}
 
 
unsigned kol_key_control()
{
asm ("int $0x40"::"a"(66), "b"(3));
}
 
 
void kol_key_lang_set(unsigned lang)
{
asm ("int $0x40"::"a"(21), "b"(2), "c"(9), "d"(lang));
}
 
 
unsigned kol_key_lang_get()
{
asm ("int $0x40"::"a"(26), "b"(2), "c"(9));
}
 
 
void kol_key_mode_set(unsigned mode)
{
asm ("int $0x40"::"a"(66), "b"(1), "c"(mode));
}
 
 
unsigned kol_key_mode_get()
{
asm ("int $0x40"::"a"(66), "b"(2));
}
 
 
unsigned kol_btn_get()
{
asm ("int $0x40"::"a"(17));
}
 
 
void kol_btn_define(unsigned x, unsigned y, unsigned w, unsigned h, unsigned d, unsigned c)
{
asm ("nop"::"b"(x*65536+w), "c"(y*65536+h), "d"(d));
asm ("nop"::"a"(c));
asm ("movl %eax, %esi");
asm ("int $0x40"::"a"(8));
}
 
 
void kol_btn_type(unsigned t)
{
asm ("int $0x40"::"a"(48), "b"(1), "c"(t));
}
 
 
void kol_wnd_caption(char *s)
{
asm ("int $0x40"::"a"(71), "b"(1), "c"(s));
}
 
 
unsigned kol_mouse_pos()
{
asm ("int $0x40"::"a"(37), "b"(0));
}
 
 
unsigned kol_mouse_posw()
{
asm ("int $0x40"::"a"(37), "b"(1));
}
 
 
unsigned kol_mouse_btn()
{
asm ("int $0x40"::"a"(37), "b"(2));
}
 
 
void kol_board_putc(char c)
{
asm ("int $0x40"::"a"(63), "b"(1), "c"(c));
}
 
 
void kol_board_puts(char *s)
{
unsigned i;
i = 0;
while (*(s+i))
{
asm ("int $0x40"::"a"(63), "b"(1), "c"(*(s+i)));
i++;
}
}
 
 
void kol_board_puti(int n)
{
char c;
int i = 0;
do
{
c = n % 10 + '0';
asm ("int $0x40"::"a"(63), "b"(1), "c"(c));
i++;
}
while ((n /= 10) > 0);
}
 
 
int kol_file_70(kol_struct70 *k)
{
asm ("int $0x40"::"a"(70), "b"(k));
}
 
 
kol_struct_import* kol_cofflib_load(char *name)
{
asm ("int $0x40"::"a"(68), "b"(19), "c"(name));
}
 
 
void* kol_cofflib_procload (kol_struct_import *imp, char *name)
{
int i;
for (i=0;;i++)
if ( NULL == ((imp+i) -> name))
break;
else
if ( 0 == strcmp(name, (imp+i)->name) )
return (imp+i)->data;
return NULL;
}
 
 
unsigned kol_cofflib_procnum (kol_struct_import *imp)
{
unsigned i, n;
 
for (i=n=0;;i++)
if ( NULL == ((imp+i) -> name))
break;
else
n++;
 
return n;
}
 
 
void kol_cofflib_procname (kol_struct_import *imp, char *name, unsigned n)
{
unsigned i;
*name = 0;
 
for (i=0;;i++)
if ( NULL == ((imp+i) -> name))
break;
else
if ( i == n )
{
strcpy(name, ((imp+i)->name));
break;
}
 
}
 
 
unsigned kol_system_cpufreq()
{
asm ("int $0x40"::"a"(18), "b"(5));
}
 
 
unsigned kol_system_mem()
{
asm ("int $0x40"::"a"(18), "b"(17));
}
 
 
unsigned kol_system_memfree()
{
asm ("int $0x40"::"a"(18), "b"(16));
}
 
 
unsigned kol_system_time_get()
{
asm ("int $0x40"::"a"(3));
}
 
 
unsigned kol_system_date_get()
{
asm ("int $0x40"::"a"(29));
}
 
 
unsigned kol_system_end(unsigned param)
{
asm ("int $0x40"::"a"(18), "b"(9), "c"(param));
}
 
 
void kol_path_file2dir(char *dir, char *fname)
{
unsigned i;
strcpy (dir, fname);
for ( i = strlen(dir);; --i)
if ( '/' == dir[i])
{
dir[i] = '\0';
return;
}
}
 
 
void kol_path_full(char *full, char *fname)
{
char temp[256];
 
switch (*fname)
{
 
case '/':
strncpy(temp, fname+1, 2);
temp[2]=0;
if ( (!strcmp("rd", temp)) || (!strcmp("hd", temp)) || (!strcmp("cd", temp)) )
strcpy (full, fname);
break;
 
case '.':
break;
 
default:
break;
 
};
 
}
 
 
 
void kol_screen_wait_rr()
{
asm ("int $0x40"::"a"(18), "b"(14));
}
 
 
 
void kol_screen_get_size(unsigned *w, unsigned *h)
{
unsigned size;
asm ("int $0x40":"=a"(size):"a"(14));
*w = size / 65536;
*h = size % 65536;
}
 
 
 
unsigned kol_skin_height()
{
asm ("int $0x40"::"a"(48), "b"(4));
}
 
 
unsigned kol_thread_start(unsigned start, unsigned stack)
{
asm ("int $0x40"::"a"(51), "b"(1), "c"(start), "d"(stack));
}
 
 
unsigned kol_time_tick()
{
asm ("int $0x40"::"a"(26), "b"(9));
}
 
 
unsigned kol_sound_speaker(char data[])
{
asm ("movl %0, %%esi"::"a"(data));
asm ("int $0x40"::"a"(55), "b"(55));
}
 
 
unsigned kol_process_info(unsigned slot, char buf1k[])
{
asm ("int $0x40"::"a"(9), "b"(buf1k), "c"(slot));
}
 
 
int kol_process_kill_pid(unsigned process)
{
asm ("int $0x40"::"a"(18), "b"(18), "c"(process));
}
/programs/system/shell/system/kolibri.h
0,0 → 1,90
 
#define NULL ((void*)0)
 
typedef struct
{
unsigned p00 __attribute__((packed));
unsigned p04 __attribute__((packed));
unsigned p08 __attribute__((packed));
unsigned p12 __attribute__((packed));
unsigned p16 __attribute__((packed));
char p20 __attribute__((packed));
char *p21 __attribute__((packed));
} kol_struct70 __attribute__((packed));
 
 
typedef struct
{
unsigned p00 __attribute__((packed));
char p04 __attribute__((packed));
char p05[3] __attribute__((packed));
unsigned p08 __attribute__((packed));
unsigned p12 __attribute__((packed));
unsigned p16 __attribute__((packed));
unsigned p20 __attribute__((packed));
unsigned p24 __attribute__((packed));
unsigned p28 __attribute__((packed));
unsigned p32[2] __attribute__((packed));
unsigned p40 __attribute__((packed));
} kol_struct_BDVK __attribute__((packed));
 
typedef struct
{
char *name __attribute__((packed));
void *data __attribute__((packed));
} kol_struct_import __attribute__((packed));
 
 
void kol_exit();
void kol_sleep(unsigned d);
void kol_wnd_define(unsigned x, unsigned y, unsigned w, unsigned h, unsigned c);
void kol_wnd_move(unsigned x, unsigned y);
void kol_wnd_caption(char *s);
void kol_event_mask(unsigned e);
unsigned kol_event_wait();
unsigned kol_event_wait_time(unsigned time);
unsigned kol_event_check();
void kol_paint_start();
void kol_paint_end();
void kol_paint_pixel(unsigned x, unsigned y, unsigned c);
void kol_paint_bar(unsigned x, unsigned y, unsigned w, unsigned h, unsigned c);
void kol_paint_line(unsigned x1, unsigned y1, unsigned x2, unsigned y2, unsigned c);
void kol_paint_string(unsigned x, unsigned y, char *s, unsigned c);
void kol_paint_image(unsigned x, unsigned y, unsigned w, unsigned h, char *d);
void kol_paint_image_pal(unsigned x, unsigned y, unsigned w, unsigned h, char *d, unsigned *palette);
unsigned kol_key_get();
unsigned kol_key_control();
void kol_key_lang_set(unsigned lang);
unsigned kol_key_lang_get();
void kol_key_mode_set(unsigned mode);
unsigned kol_key_mode_get();
void kol_btn_define(unsigned x, unsigned y, unsigned w, unsigned h, unsigned d, unsigned c);
unsigned kol_btn_get();
void kol_btn_type(unsigned t);
unsigned kol_mouse_pos();
unsigned kol_mouse_posw();
unsigned kol_mouse_btn();
void kol_board_putc(char c);
void kol_board_puts(char *s);
void kol_board_puti(int n);
int kol_file_70(kol_struct70 *k);
kol_struct_import* kol_cofflib_load(char *name);
void* kol_cofflib_procload (kol_struct_import *imp, char *name);
unsigned kol_cofflib_procnum (kol_struct_import *imp);
void kol_cofflib_procname (kol_struct_import *imp, char *name, unsigned n);
unsigned kol_system_end(unsigned param);
unsigned kol_system_cpufreq();
unsigned kol_system_mem();
unsigned kol_system_memfree();
unsigned kol_system_time_get();
unsigned kol_system_date_get();
void kol_path_file2dir(char *dir, char *fname);
void kol_path_full(char *full, char *fname);
void kol_screen_wait_rr();
void kol_screen_get_size(unsigned *w, unsigned *h);
unsigned kol_skin_height();
unsigned kol_thread_start(unsigned start, unsigned stack);
unsigned kol_time_tick();
unsigned kol_sound_speaker(char data[]);
unsigned kol_process_info(unsigned slot, char buf1k[]);
int kol_process_kill_pid(unsigned process);
/programs/system/shell/system/stdlib.c
0,0 → 1,33
 
unsigned int seed_o = 0x45168297;
 
 
void srand (unsigned seed)
{
seed_o = seed;
}
 
 
int rand (void)
{
seed_o = seed_o * 0x15a4e35 + 1;
return(seed_o >> 16);
}
 
 
void* malloc(unsigned s)
{
asm ("int $0x40"::"a"(68), "b"(12), "c"(s) );
}
 
 
void free(void *p)
{
asm ("int $0x40"::"a"(68), "b"(13), "c"(p) );
}
 
 
void* realloc(void *p, unsigned s)
{
asm ("int $0x40"::"a"(68), "b"(12), "c"(p), "d"(s) );
}
/programs/system/shell/system/stdlib.h
0,0 → 1,14
 
#define RAND_MAX 0x7FFFU
 
#define isspace(c) ((c)==' ')
#define abs(i) (((i)<0)?(-(i)):(i))
 
#define random(num) ((rand()*(num))/((RAND_MAX+1)))
 
void* malloc(unsigned size);
void free(void *pointer);
void* realloc(void* pointer, unsigned size);
 
void srand (unsigned seed);
int rand (void);
/programs/system/shell/system/string.c
0,0 → 1,124
 
#include "string.h"
 
void* memset(void *mem, int c, unsigned size)
{
unsigned i;
 
for ( i = 0; i < size; i++ )
*((char *)mem+i) = (char) c;
 
return NULL;
}
 
 
void* memcpy(void *dst, const void *src, unsigned size)
{
 
unsigned i;
 
for ( i = 0; i < size; i++)
*(char *)(dst+i) = *(char *)(src+i);
 
return NULL;
}
 
 
int memcmp(const void* buf1, const void* buf2, int count)
{
int i;
for (i=0;i<count;i++)
{
if (*(unsigned char*)buf1<*(unsigned char*)buf2)
return -1;
if (*(unsigned char*)buf1>*(unsigned char*)buf2)
return 1;
}
return 0;
}
 
void strcat(char strDest[], char strSource[])
{
 
int i, j;
i = j = 0;
while (strDest[i] != '\0')
i++;
 
while ((strDest[i++] = strSource[j++]) != '\0')
;
}
 
 
int strcmp(const char* string1, const char* string2)
{
 
while (1)
{
if (*string1<*string2)
return -1;
if (*string1>*string2)
return 1;
 
if (*string1=='\0')
return 0;
 
string1++;
string2++;
}
 
}
 
 
void strcpy(char strDest[], const char strSource[])
{
unsigned i;
 
i = 0;
while ((strDest[i] = strSource[i]) != '\0')
i++;
 
}
 
 
char* strncpy(char *strDest, const char *strSource, unsigned n)
{
unsigned i;
 
if (! n )
return strDest;
 
i = 0;
while ((strDest[i] = strSource[i]) != '\0')
if ( (n-1) == i )
break;
else
i++;
 
return strDest;
}
 
 
int strlen(const char* string)
{
int i;
 
i=0;
while (*string++) i++;
return i;
}
 
 
 
char* strchr(const char* string, int c)
{
while (*string)
{
if (*string==c)
return (char*)string;
string++;
}
return (char*)0;
}
 
/programs/system/shell/system/string.h
0,0 → 1,15
 
#ifndef NULL
#define NULL ((void*)0)
#endif
 
void* memset(void *mem, int c, unsigned size);
void* memcpy(void *dst, const void *src, unsigned size);
int memcmp(const void* buf1, const void* buf2, int count);
 
void strcat(char strDest[], char strSource[]);
int strcmp(const char* string1, const char* string2);
void strcpy(char strDest[], const char strSource[]);
char* strncpy(char *strDest, const char *strSource, unsigned n);
int strlen(const char* string);
char *strchr(const char* string, int c);
/programs/system/shell/system
Property changes:
Added: tsvn:logminsize
+5
\ No newline at end of property