diff --git a/kernel/branches/kolibri-e/help/comm_topics/faq_problems.html b/kernel/branches/kolibri-e/help/comm_topics/faq_problems.html new file mode 100644 index 0000000000..e69de29bb2 diff --git a/kernel/branches/kolibri-e/help/comm_topics/hard_support.html b/kernel/branches/kolibri-e/help/comm_topics/hard_support.html new file mode 100644 index 0000000000..e69de29bb2 diff --git a/kernel/branches/kolibri-e/help/help_main.html b/kernel/branches/kolibri-e/help/help_main.html new file mode 100644 index 0000000000..47a5912616 --- /dev/null +++ b/kernel/branches/kolibri-e/help/help_main.html @@ -0,0 +1,33 @@ + + + Main + KolibriOS Help + + +

Help system for KolibriOS ver. 1.0 (for OS version 0.7.7.0 and newer)

+

Common topics

+ +

Software development

+ +

Using libraries

+ +

Useful links

+ + + \ No newline at end of file diff --git a/kernel/branches/kolibri-e/help/soft_dev/debug.html b/kernel/branches/kolibri-e/help/soft_dev/debug.html new file mode 100644 index 0000000000..7457c5c1c6 --- /dev/null +++ b/kernel/branches/kolibri-e/help/soft_dev/debug.html @@ -0,0 +1,123 @@ + + + Debugging Applications Guide + KolibriOS Help + [To main] + [To the next point] + [To the previous point] + + +

Debugging Applications Guide

+ Introduction

+ +mtdbg is a debugger for the KolibriOS. This documentation describes the capabilities of the debugger and how to work with it. For questions, please visit our forum (board.kolibrios.org).

+ +General description

+ +Mtdbg can only debug one program at a time. Let's call such a program loaded for debugging. If no program is loaded, the vast majority of debugging actions are not available.

+ +mtdbg is controlled by the command line entered from the keyboard. The command line is displayed at the bottom of the debugger window. The standard input keys Backspace, Delete, Home, End, left / right arrows are processed.
+Commands are not case sensitive. An arbitrary non-zero number of spaces is used as a separator.

+ +The debugger can be terminated at any time with the "quit" command (no arguments). However, you can just click on the close button in the upper left corner of the window.

+ +Running the debugger without command line parameters results in no program being loaded. Also, mtdbg can be run with the command line, in this case it will try to load the program with the name specified as the first command line argument and parameters specified as subsequent (if any).

+ +If no program is loaded, you can load the program with the command load <full name of the executable file> [<arguments>].
+For example:
+load / rd / 1 / example
+LOAD / rd / 1 / aclock w200 h200
+LoaD / hd0 / 1 / menuetos / dosbox / dosbox

+ +Everything after the first space after the name of the executable file is literally passed to the program as a command line.
+The load command reports the result in a message window (just above the command line window). If the program was loaded, then this will appear the corresponding message; if not successful, the message will indicate the reason for the error. The most likely one is "file not found" if the filename is incorrect.

+ +The debugger can load files with information about the names in the program (labels, global variables) - text files, each line of which has the form 0x <hex_address_value> <name> (lines that do not have this form are ignored). Such a file can be created manually or generated automatically when compiling the source by fasm.
+Explicit loading is performed with the command load-symbols <full name of the symbol file>.
+In addition, when executing the load command, the debugger checks for the existence of a file with the same name as the loaded binary and the extension .dbg (/rd/1/example.dbg for the first example above), and if there is one, loads it automatically (displaying the message "Symbols loaded" if everything is ok).

+ +It may happen that the downloaded program is packed. The general principle of packaging programs is the following: first, the source file is packed (by some compression algorithm), then a small code is assigned, which receives control when the program starts, unpacks the source code in memory, and then transfers control to it. If the program is packed, then its "real" code is not visible and for debugging you must first go through the unpacker code. mtdbg detects most of the existing packers (mxp, mxp_lzo, mxp_nrv, mtappack) and in this case offers to automatically go to the "real" code. It is recommended to agree (press 'y' or Enter), but you can refuse.
+In case of failure and in the case when the program is packed with something unknown, you can use the "unpack" command (no arguments). Call it only when you are sure that the program is packed and that control has not yet reached the main code! (Starting from Kolibri 0.6.5.0, this entire paragraph is no longer relevant, since applications can be packaged like any binaries with kpack and the unpacker code is in the kernel and unpacking is transparent for debugging.)

+ +The loaded program can be nailed with the "terminate" command (no arguments). The detach command (with no arguments) is detached from the program, after which the program continues to execute normally, as if the debugger was not present. After both of these commands, the program ceases to be debuggable.

+ +You can reload the program for debugging with the "reload" command (no arguments). If there is already a loaded program, then it is nailed and starts (from the very beginning) a new instance (with the same command line), in this case the command is similar to the commands terminate
+load <last program name> <last program arguments>
+Otherwise, the program that was debugged last (in the current session with mtdbg) (with the same command line) is loaded again, i.e. almost the same as load <last program name> <last program arguments>, but the reload command is shorter and more convenient in both cases; moreover, load considers that a new program is loaded, and transfers the data window (see below) to address zero, and reload saves the current address.

+ +The "help" command is always available, which can be abbreviated to "h".
+All teams are divided into groups:
+help with no arguments displays a list of command groups.
+help specifying a group displays a list of commands for that group with short comments.
+help with a command specifies information about the specified command.
+For example:
+help
+help control
+h LoaD

+ +The debugger window consists of the following items, listed from top to bottom:
+- status bar. If there is a loaded program, it shows its name and state ("Running" / "Paused"), if not, it says "No program loaded".
+- register window - shows the values ​​of general-purpose registers, eip register and flags register. The latter is written in two ways: the full hex value and the states of individual flags: CF, PF, AF, ZF, SF, DF, OF. If the flag is cleared, then a small letter is displayed; if set, capitalized.

+ +Registers that have changed since the previous moment are highlighted in green.
+- data window (dump window) - shows the contents of the loaded program memory
+- code window (disassembler window) - shows the program code in the form of disassembled instructions
+- message box
+- command line window

+ +In the dump window, you can view data starting from any address, for this there is the d <expression> command.
+Command d without arguments scrolls down the dump window. The same applies to the code window and the u <expression> command or just u.
+For example:
+d esi - shows the data located at esi (for example, useful before executing the rep movsb instruction)
+d esp - shows the stack
+u eip - disassembles instructions starting with the current one

+ +Expressions in mtdbg can include
+- hexadecimal constants
+- the names of all general purpose registers (8 32-bit, 8 16-bit and 8 8-bit) and eip register; 16- and 8-bit register values ​​are zero-expanded to 32 bits
+- four arithmetic operations +, -, *, / (with standard precedence) and brackets
+- [if there is information about symbols] names loaded from dbg file
+All calculations are done modulo 2 ^ 32.
+Examples of expressions:
+eax
+eip + 2
+ecx-esi-1F
+al + AH * bl
+ax + 2 * bH * (eip + a73)
+3 * esi * di / EAX
+Command ? <expression> evaluates the value of the specified expression.

+ +The values ​​of the registers of the loaded program can be changed with the r command, which has two absolutely equivalent forms:
+r <case> <expression>
+r <case> = <expression>
+(in both cases, you can add spaces to your liking). As a register, you can specify any of the above - 24 general registers and eip.

+ +Let's say the load command has successfully loaded a program for debugging. Immediately after loading, the program is suspended and does not run.
+Pressing Ctrl + F7 (similar to the command line - the "s" command) takes one step in the loaded program, after which control returns to the debugger, which shows the new contents of registers and memory. The int 40h system call (as well as the sysenter and syscall instructions) counts as one step.
+Pressing Ctrl + F8 (similar to the command line - the "p" command) also takes a step in the loaded program, but procedure calls, line operations with the rep / repz / repnz prefix, and loops are performed as one step.
+Stepping instructions are used, as a rule, in separate sections of the program, when it is necessary, for example, to regularly monitor the values ​​of registers and / or some variables in memory.
+The g <expression> command resumes the execution of the program and waits until control reaches eip = the corresponding address, and at this moment suspends the program. The "g" command with no arguments simply resumes program execution.

+ +You can pause the program execution with the "stop" command (without arguments).

+ +Usually it is required for the program to run normally, but when certain conditions are met, the program is suspended and the debugger takes control. The corresponding conditions are called breakpoints, breakpoint (s), in common parlance - breakpoints. The simplest type of breakpoints is to a specific address, i.e. abort execution on eip = <specified value>. These breakpoints are set with the bp <expression> command.

+ +Comment. If there is only one such breakpoint, it is more convenient to use the "g" command with an argument instead.

+ +Another type of breakpoints is by accessing a given area of ​​memory. There can be no more than four such breakpoints (since the hardware capabilities of x86 processors are used, where only 4 such breakpoints are allowed).
+bpm <expression> - bryak to any access to the byte at the specified address
+bpm w <expression> - bryak to write a byte at the specified address
+bpmb, bpmw, bpmd <expression> - bryak to access, respectively, byte, word and doubleword at the specified address. bpm and bpmb are synonyms. When using bpmw, the bpmd address must be word-aligned (i.e. even) or double-word aligned (i.e., divisible by 4), respectively.
+bpmb, bpmw, bpmd w <expression> - similarly for write break.

+ +The list of set breakpoints can be viewed with the "bl" command, information about a specific breakpoint can be obtained with "bl <number>". Unnecessary breakpoints are removed with the "bc <number>" command, temporarily unnecessary ones can be disabled with the "bd <number>" command, when they are needed again, use the "be <number>" command.

+ +Remarks.

+ +When debugging your own programs, you can insert int3 instructions into the code (note that there is no space!). Such an instruction throws an exception on normal startup, which will lead to the termination of the process, but when working under the debugger, the debugger is simply activated (with the message "int3 command at xxx"). This allows you not to think about which addresses to use in the g and / or bp commands. You can also generate a file with information about symbols and load it, then not only there is no need to independently calculate the addresses for "g" and "bp", but also "u", "d", "?" will understand the indication of the label / variable name.
+All output and all input is hexadecimal.
+When the program is running, the register and data windows show information pertaining to the point before the resume; setting of register values ​​in this mode is not possible. However, the "d" command in this mode shows the information that was correct at the time the command was issued.
+Written by diamond. Translated by Alex2003 + + + \ No newline at end of file diff --git a/kernel/branches/kolibri-e/help/soft_dev/fasm_manual.html b/kernel/branches/kolibri-e/help/soft_dev/fasm_manual.html new file mode 100644 index 0000000000..e69de29bb2 diff --git a/kernel/branches/kolibri-e/help/soft_dev/sys_funct_main.html b/kernel/branches/kolibri-e/help/soft_dev/sys_funct_main.html new file mode 100644 index 0000000000..be754b2baf --- /dev/null +++ b/kernel/branches/kolibri-e/help/soft_dev/sys_funct_main.html @@ -0,0 +1,23 @@ + + + List of system functions + KolibriOS Help + [To main] + [To the next point] + [To the previous point] + + +

System Function (for OS version 0.7.7.0 and newer)

+ Number of the function is located in the register eax.
+ The call of the system function is executed by "int 0x40" command.
+ All registers except explicitly declared in the returned value, including eflags, are preserved. + + + \ No newline at end of file diff --git a/kernel/branches/kolibri-e/help/sys_funct/f68_main.html b/kernel/branches/kolibri-e/help/sys_funct/f68_main.html new file mode 100644 index 0000000000..30c787f903 --- /dev/null +++ b/kernel/branches/kolibri-e/help/sys_funct/f68_main.html @@ -0,0 +1,41 @@ + + + +Sys. function 70 +KolibriOS Help +[Back to list system function] + [Previous page] + [Next page] +
+ + + +

System function 68 - debugging.

+A process can load other process as debugged by set of corresponding bit by call to subfunction 7 of function 70.
+A process can have only one debugger; one process can debug some others. The system notifies debugger on events occuring with debugged process.
Messages are written to the buffer defined by subfunction 0.
 +Format of a message:
+ +0: dword: message code;
+ +4: dword: PID of debugged process;
+ +8: there can be additional data depending on message code.

 +Message codes:
+ 1 = exception in addition dword-number of the exception is given process is suspended;
+ 2 = process has terminated comes at any termination: both through the system function -1, and at "murder" by any other process (including debugger itself);
+ 3 = debug exception int 1 = #DB in addition dword-image of the register DR6 is given: bits 0-3: condition of the corresponding breakpoint (set by subfunction 9) is satisfied bit 14: exception has occured because of the trace mode (flag TF is set TF) process is suspended.

 +When debugger terminates, all debugged processes are killed. If debugger does not want this, it must previously detach by +subfunction 3.

 +All subfunctions are applicable only to processes/threads started from the current by function 70 with set debugging flag. Debugging of multithreaded programs is not supported yet.

 +The full list of subfunctions:
+ subfunction 0 - define data area for debug messages
+ subfunction 1 - get contents of registers of debugged thread
+ subfunction 2 - set contents of registers of debugged thread
+ subfunction 3 - detach from debugged process
+ subfunction 4 - suspend debugged thread
+ subfunction 5 - resume debugged thread
+ subfunction 6 - read from the memory of debugged process
+ subfunction 7 - write to the memory of debugged process
+ subfunction 8 - terminate debugged thread
+ subfunction 9 - set/clear hardware breakpoint
 + + + + \ No newline at end of file diff --git a/kernel/branches/kolibri-e/help/sys_funct/f69_main.html b/kernel/branches/kolibri-e/help/sys_funct/f69_main.html new file mode 100644 index 0000000000..d068676a5f --- /dev/null +++ b/kernel/branches/kolibri-e/help/sys_funct/f69_main.html @@ -0,0 +1,56 @@ + + +Sys. function 69 +KolibriOS Help +[Back to list system function] + [Previous page] + [Next page] +
+ + +

System function 69 - debugging.

+A process can load other process as debugged by set of corresponding bit by call to subfunction 7 of function 70.
+A process can have only one debugger; one process can debug some others. The system notifies debugger on events occuring with debugged process.
Messages are written to the buffer defined by subfunction 0.
 +Format of a message:
+ +0: dword: message code;
+ +4: dword: PID of debugged process;
+ +8: there can be additional data depending on message code.

+ +Message codes:
+ 1 = exception in addition dword-number of the exception is given process is suspended;
+ 2 = process has terminated comes at any termination: both through the system function -1, and at "murder" by any other process (including debugger itself);
+ 3 = debug exception int 1 = #DB in addition dword-image of the register DR6 is given: bits 0-3: condition of the corresponding breakpoint (set by subfunction 9) is satisfied bit 14: exception has occured because of the trace mode (flag TF is set TF) process is suspended.

+ +When debugger terminates, all debugged processes are killed. If debugger does not want this, it must previously detach by +subfunction 3.

+ +All subfunctions are applicable only to processes/threads started from the current by function 70 with set debugging flag. Debugging of multithreaded programs is not supported yet.

+ +The full list of subfunctions:
+ subfunction 0 - define data area for debug messages
+ subfunction 1 - get contents of registers of debugged thread
+ subfunction 2 - set contents of registers of debugged thread
+ subfunction 3 - detach from debugged process
+ subfunction 4 - suspend debugged thread
+ subfunction 5 - resume debugged thread
+ subfunction 6 - read from the memory of debugged process
+ subfunction 7 - write to the memory of debugged process
+ subfunction 8 - terminate debugged thread
+ subfunction 9 - set/clear hardware breakpoint

+ +Value for register eax - 69 (SF_DEBUG).
+Values for register ebx:
+0 - SSF_SET_MESSAGE_AREA - subfunction 0 - define data area fror debug messages.
+1 - SSF_GET_REGISTERS - subfunction 1 - Get contents of registers of debugged thread.
+2 - SSF_SET_REGISTERS - subfunction 2 - Set contents of registers of debugged thread.
+3 - SSF_DETACH - subfunction 3 - detach from debugged process.
+4 - SSF_SUSPEND - subfunction 4 - suspend debugged thread.
+5 - SSF_RESUME - subfunction 5 - resume debugged thread.
+6 - SSF_READ_MEMORY - subfunction 6 - read from memory of debugged process.
+7 - SSF_WRITE_MEMORY - subfunction 7 - write to memory of debugged process.
+8 - SSF_TERMINATE - subfunction 8 - terminate debugged thread.
+9 - SSF_DEFINE_BREAKPOINT - subfunction 9 - set/clear hardware breakpoint. + +created 23.08.2020 by Alex2003 + + \ No newline at end of file diff --git a/kernel/branches/kolibri-e/help/sys_funct/f70_main.html b/kernel/branches/kolibri-e/help/sys_funct/f70_main.html new file mode 100644 index 0000000000..b7315ba30f --- /dev/null +++ b/kernel/branches/kolibri-e/help/sys_funct/f70_main.html @@ -0,0 +1,81 @@ + + + +Sys. function 70 +KolibriOS Help +[Back to list system function] + [Previous page] + [Next page] +
+ + + +

System function 70 - Work with file system with long names support

+Parameters:
+ Register eax = 70
+ Register ebx = pointer to the information structure
+Returned value:
+ Register eax = 0 - success; otherwise file system error code some subfunctions return value in other registers too.
+General format of the information structure:
+ +0: dword: subfunction number
+ +4: dword: offset in file or folder
+ +8: dword: higher part of offset or flags
+ +12 = +0xC: dword: size of data
+ +16 = +0x10: dword: pointer to data
+ +20 = +0x14: ?: path - zero terminated string
+ or
+ +20 = +0x14: byte: 0
+ +21 = +0x15: dword: pointer to string
+Case sensitivity depends on filesystem.
+If a path not begins with '/', it is considered a relative.
+To get or set the current folder, use the sysfunction 30.
+'../' in the path means a lift by one folder relatively current folder.
+To set the encoding, put at the start of the string a byte with next values:
+ 1 = cp866
+ 2 = UTF-16LE
+ 3 = UTF-8
+ otherwise will be used cp866. In an absolute path you may put this byte after the '/' or put an additional '/' before it.
+ Also, you may use the sysfunction 80.
+Format of an absolute path: /base/number/dir1/dir2/.../dirn/file, where base/number identifies device, on which file is located:
+ RD/1 = ramdisk
+ FD/1 = first floppy drive, FD/2 = second floppy drive
+ HD0/x, HD1/x, HD2/x, HD3/x = hard drives accordingly on IDE0 (Primary Master), IDE1 (Primary Slave), IDE2 (Secondary Master), IDE3 (Secondary Slave); x - partition number on the selected hard drive, starts from 1
+ CD0/1, CD1/1, CD2/1, CD3/1 = same for cd
+ SYS = system folder (encoding inaffected key), second key may be set by sysfunction 30.3.
+Examples:
+ '/sys/example.asm',0
+ '/rd/1/example.asm',0
+ '/HD0/1/folder/file.txt',0
+ '/hd2/2/pics/tanzania.bmp',0
+ 2,'/',0,'sys','/',0,'F',0,'I',0,'L',0,'E',0,0,0

+ +Available subfunctions:
+ subfunction 0 - read file
+ subfunction 1 - read folder
+ subfunction 2 - create/rewrite file
+ subfunction 3 - write to existing file
+ subfunction 4 - set file size
+ subfunction 5 - get attributes of file/folder
+ subfunction 6 - set attributes of file/folder
+ subfunction 7 - start application
+ subfunction 8 - delete file/folder
+ subfunction 9 - create folder
+For CD-drives due to hardware limitations only subfunctions 0,1,5 and 7 are available, other subfunctions return error with code 2.
+At the first call of subfunctions 0,1,5,7 to ATAPI devices(CD and DVD) the manual control of tray is locked due to caching drive data. Unlocking is made when subfunction 4 of function 24 is called for corresponding device.
+
+ Value for register eax - 70 (SF_FILE).
+ Values for register ebx:
+ 0 - SSF_READ_FILE - subfunction 0 - read file with long names support.
+ 1 - SSF_READ_FOLDER - subfunction 1 - read folder with long names support.
+ 2 - SSF_CREATE_FILE - subfunction 2 - create/rewrite file with long names support.
+ 3 - SSF_WRITE_FILE - subfunction 3 - write to existing file with long names support.
+ 4 - SSF_SET_END - subfunction 4 - set end of file.
+ 5 - SSF_GET_INFO - subfunction 5 - get information on file/folder.
+ 6 - SSF_SET_INFO - subfunction 6 - set attributes of file/folder.
+ 7 - SSF_START_APP - subfunction 7 - start application.
+ 8 - SSF_DELETE - subfunction 8 - delete file/folder.
+ 9 - SSF_CREATE_FOLDER - subfunction 9 - create folder.
+ + + + \ No newline at end of file diff --git a/kernel/branches/kolibri-e/help/us_lib/ini.html b/kernel/branches/kolibri-e/help/us_lib/ini.html new file mode 100644 index 0000000000..030e798df2 --- /dev/null +++ b/kernel/branches/kolibri-e/help/us_lib/ini.html @@ -0,0 +1,39 @@ + + + INI library + KolibriOS Help + [Back to main] + [To the next point] + [To the previous point] +
+ + +

INI library

+ + INI files are text files with the following structure:
+ [name of the first section]
+ Parameter1 = value1
+ Parameter2 = Value2
+ ;comment
+ [name of the second section]
+ Parameter3 = Value3

+ + All lines starting with the character ';' are considered comments and are ignored.

+ + Keyboard shortcut syntax:
+arbitrary number of modifiers Ctrl / Alt / Shift / LCtrl / LAlt / LShift / RCtrl / RAlt / RShift, followed by a latin letter, number or key name.
+Proper names have the following keys:
+F1 - F12
+Home End; PgUp; PgDn; Ins, she is Insert; Del, she is Delete;
+Tab Plus Esc Enter Backspace Space (space);
+Left (left arrow); Right (right arrow); Up (up arrow); Down (down arrow).
+You can write a string with any case of characters. Individual parts are written either together or separated by a plus.
+For example:
+Ctrl + Alt + Backspace
+RCtrl + RShift
+Shiftift
+f10
+Shiftalt5
+ + + \ No newline at end of file diff --git a/kernel/branches/kolibri-e/help/us_lib/open_dialog.html b/kernel/branches/kolibri-e/help/us_lib/open_dialog.html new file mode 100644 index 0000000000..e69de29bb2