As85 - Revision history

Parasyte: /* Development */ Update source link to git

2012-12-30T05:19:12Z

‎Development: Update source link to git

Parasyte: /* Usage */ Update source link to git

2012-12-30T05:14:59Z

‎Usage: Update source link to git

Parasyte: /* Development */ Update source links

2012-12-30T04:13:23Z

‎Development: Update source links

Parasyte: /* Usage */ Update source link

2012-12-30T04:09:37Z

‎Usage: Update source link

Parasyte: /* Download */ Update source link

2012-12-30T04:08:56Z

‎Download: Update source link

Parasyte: Fix hgkw links

2010-10-21T07:23:51Z

Fix hgkw links

Parasyte: /* Usage */

2010-10-21T07:19:23Z

‎Usage

Parasyte at 07:25, 21 October 2009

2009-10-21T07:25:21Z

Show changes

Gayswee: /* Optimization Concerns */

2009-02-28T01:59:13Z

‎Optimization Concerns

Gayswee: /* Development */

2009-02-28T01:57:36Z

‎Development

@@ Line 316: / Line 316: @@
 As85 is a fairly simple assembler. It doesn't use any sort of 'compiler-compiler' for lexical analysis. In fact, its lexical analysis is very specific to the sm8521 MCU.
-The main loop (assemble() function, defined in [http://git.kodewerx.org/as85/src/a90c47020126a58874638e66c0fbf90fb5ab53c2/src/asm.c?at=default#cl-315 asm.c]) does the input text parsing inline. (This should probably be moved out to a new source file.) After splitting a line into two pieces; op[0] containing the instruction, and op[1] containing its operands; a string comparison against op[0] is done over all supported instructions. If a match is found, the operands string is passed to a dynamically chosen function (from a [http://git.kodewerx.org/as85/src/a90c47020126a58874638e66c0fbf90fb5ab53c2/src/inst.c?at=default#cl-156 function pointer table], indexed by the matched instruction). This function performs the lexical analysis required to decide which instruction we are trying to assemble.
+The main loop (assemble() function, defined in [http://git.kodewerx.org/as85/src/09f8ba9f769d/src/asm.c?at=master#cl-315 asm.c]) does the input text parsing inline. (This should probably be moved out to a new source file.) After splitting a line into two pieces; op[0] containing the instruction, and op[1] containing its operands; a string comparison against op[0] is done over all supported instructions. If a match is found, the operands string is passed to a dynamically chosen function (from a [http://git.kodewerx.org/as85/src/09f8ba9f769d/src/inst.c?at=master#cl-156 function pointer table], indexed by the matched instruction). This function performs the lexical analysis required to decide which instruction we are trying to assemble.
 Since the sm8521 is a CISC machine, its instruction set contains a number of different ways to assemble the same instruction mnemonic. For example, several different addressing modes for the ''mov'' instruction are shown above in the test3.asm output. The lexical analysis is the voodoo which picks the proper addressing mode and byte codes by analyzing the operands.
-The lexical analyzing functions are defined in inst.c (following the function pointer table mentioned previously). The function handling the current instruction will test the operands string against a series of lexical patterns with the [http://git.kodewerx.org/as85/src/a90c47020126a58874638e66c0fbf90fb5ab53c2/src/asm.c?at=default#cl-89 chk_pattern()] function (defined in asm.c, although this should probably be moved).
+The lexical analyzing functions are defined in inst.c (following the function pointer table mentioned previously). The function handling the current instruction will test the operands string against a series of lexical patterns with the [http://git.kodewerx.org/as85/src/09f8ba9f769d/src/asm.c?at=master#cl-89 chk_pattern()] function (defined in asm.c, although this should probably be moved).
-chk_pattern() uses a scanf-like formatting string, rather than a regular expression, which is more common in lexical analysis. Documentation for the formatting string can be found in [http://git.kodewerx.org/as85/src/a90c47020126a58874638e66c0fbf90fb5ab53c2/src/inst.h?at=default#cl-29 inst.h]. With just a few pattern primitives, any of the sm8521's addressing modes can be matched, with the matching primitives output as part of an array. It makes good use of the format scanners defined in [http://git.kodewerx.org/as85/src/a90c47020126a58874638e66c0fbf90fb5ab53c2/src/scan.c?at=default scan.c].
+chk_pattern() uses a scanf-like formatting string, rather than a regular expression, which is more common in lexical analysis. Documentation for the formatting string can be found in [http://git.kodewerx.org/as85/src/09f8ba9f769d/src/inst.h?at=master#cl-29 inst.h]. With just a few pattern primitives, any of the sm8521's addressing modes can be matched, with the matching primitives output as part of an array. It makes good use of the format scanners defined in [http://git.kodewerx.org/as85/src/09f8ba9f769d/src/scan.c?at=master scan.c].
-If chk_pattern() manages to find a match, the matching data may be further checked for validity on a per-context basis. Finally, the full instruction byte codes will be put together and returned to the assemble() loop. This is where the object code would be built. Currently the only thing that happens now is dumping the assembled instruction to stdout, in a debug build. [http://git.kodewerx.org/as85/src/a90c47020126a58874638e66c0fbf90fb5ab53c2/src/asm.c?at=default#cl-464]
+If chk_pattern() manages to find a match, the matching data may be further checked for validity on a per-context basis. Finally, the full instruction byte codes will be put together and returned to the assemble() loop. This is where the object code would be built. Currently the only thing that happens now is dumping the assembled instruction to stdout, in a debug build. [http://git.kodewerx.org/as85/src/09f8ba9f769d/src/asm.c?at=master#cl-464]
 ===Optimization Concerns===

@@ Line 19: / Line 19: @@
 ==Usage==
-The program takes one argument; the file name of an sm8521 assembly file. The files in the [http://git.kodewerx.org/as85/src/a90c47020126a58874638e66c0fbf90fb5ab53c2/examples?at=default /examples] directory are a good place to start.
+The program takes one argument; the file name of an sm8521 assembly file. The files in the [http://git.kodewerx.org/as85/src/09f8ba9f769d47fc2038e81d9cc5866d80f96748/examples?at=master /examples] directory are a good place to start.
 * test.asm is an example of what the beginning of a Game.com program might look like; it contains a header, and some [random] instructions to give you an idea.

@@ Line 316: / Line 316: @@
 As85 is a fairly simple assembler. It doesn't use any sort of 'compiler-compiler' for lexical analysis. In fact, its lexical analysis is very specific to the sm8521 MCU.
-The main loop (assemble() function, defined in [http://hg.kodewerx.org/as85/file/a90c47020126/src/asm.c#l315 asm.c]) does the input text parsing inline. (This should probably be moved out to a new source file.) After splitting a line into two pieces; op[0] containing the instruction, and op[1] containing its operands; a string comparison against op[0] is done over all supported instructions. If a match is found, the operands string is passed to a dynamically chosen function (from a [http://hg.kodewerx.org/as85/file/a90c47020126/src/inst.c#l156 function pointer table], indexed by the matched instruction). This function performs the lexical analysis required to decide which instruction we are trying to assemble.
+The main loop (assemble() function, defined in [http://git.kodewerx.org/as85/src/a90c47020126a58874638e66c0fbf90fb5ab53c2/src/asm.c?at=default#cl-315 asm.c]) does the input text parsing inline. (This should probably be moved out to a new source file.) After splitting a line into two pieces; op[0] containing the instruction, and op[1] containing its operands; a string comparison against op[0] is done over all supported instructions. If a match is found, the operands string is passed to a dynamically chosen function (from a [http://git.kodewerx.org/as85/src/a90c47020126a58874638e66c0fbf90fb5ab53c2/src/inst.c?at=default#cl-156 function pointer table], indexed by the matched instruction). This function performs the lexical analysis required to decide which instruction we are trying to assemble.
 Since the sm8521 is a CISC machine, its instruction set contains a number of different ways to assemble the same instruction mnemonic. For example, several different addressing modes for the ''mov'' instruction are shown above in the test3.asm output. The lexical analysis is the voodoo which picks the proper addressing mode and byte codes by analyzing the operands.
-The lexical analyzing functions are defined in inst.c (following the function pointer table mentioned previously). The function handling the current instruction will test the operands string against a series of lexical patterns with the [http://hg.kodewerx.org/as85/file/a90c47020126/src/asm.c#l89 chk_pattern()] function (defined in asm.c, although this should probably be moved).
+The lexical analyzing functions are defined in inst.c (following the function pointer table mentioned previously). The function handling the current instruction will test the operands string against a series of lexical patterns with the [http://git.kodewerx.org/as85/src/a90c47020126a58874638e66c0fbf90fb5ab53c2/src/asm.c?at=default#cl-89 chk_pattern()] function (defined in asm.c, although this should probably be moved).
-chk_pattern() uses a scanf-like formatting string, rather than a regular expression, which is more common in lexical analysis. Documentation for the formatting string can be found in [http://hg.kodewerx.org/as85/file/a90c47020126/src/inst.h#l29 inst.h]. With just a few pattern primitives, any of the sm8521's addressing modes can be matched, with the matching primitives output as part of an array. It makes good use of the format scanners defined in [http://hg.kodewerx.org/as85/file/a90c47020126/src/scan.c scan.c].
+chk_pattern() uses a scanf-like formatting string, rather than a regular expression, which is more common in lexical analysis. Documentation for the formatting string can be found in [http://git.kodewerx.org/as85/src/a90c47020126a58874638e66c0fbf90fb5ab53c2/src/inst.h?at=default#cl-29 inst.h]. With just a few pattern primitives, any of the sm8521's addressing modes can be matched, with the matching primitives output as part of an array. It makes good use of the format scanners defined in [http://git.kodewerx.org/as85/src/a90c47020126a58874638e66c0fbf90fb5ab53c2/src/scan.c?at=default scan.c].
-If chk_pattern() manages to find a match, the matching data may be further checked for validity on a per-context basis. Finally, the full instruction byte codes will be put together and returned to the assemble() loop. This is where the object code would be built. Currently the only thing that happens now is dumping the assembled instruction to stdout, in a debug build. [http://hg.kodewerx.org/as85/file/a90c47020126/src/asm.c#l464]
+If chk_pattern() manages to find a match, the matching data may be further checked for validity on a per-context basis. Finally, the full instruction byte codes will be put together and returned to the assemble() loop. This is where the object code would be built. Currently the only thing that happens now is dumping the assembled instruction to stdout, in a debug build. [http://git.kodewerx.org/as85/src/a90c47020126a58874638e66c0fbf90fb5ab53c2/src/asm.c?at=default#cl-464]
 ===Optimization Concerns===

@@ Line 19: / Line 19: @@
 ==Usage==
-The program takes one argument; the file name of an sm8521 assembly file. The files in the [http://hg.kodewerx.org/as85/file/tip/examples /examples] directory are a good place to start.
+The program takes one argument; the file name of an sm8521 assembly file. The files in the [http://git.kodewerx.org/as85/src/a90c47020126a58874638e66c0fbf90fb5ab53c2/examples?at=default /examples] directory are a good place to start.
 * test.asm is an example of what the beginning of a Game.com program might look like; it contains a header, and some [random] instructions to give you an idea.

@@ Line 5: / Line 5: @@
 ==Download==
-The source code is available at http://hg.kodewerx.org/as85/
+The source code is available at http://git.kodewerx.org/as85/src/
 ==Current Progress==

@@ Line 21: / Line 21: @@
 The program takes one argument; the file name of an sm8521 assembly file. The files in the [http://hg.kodewerx.org/index.cgi/as85/file/tip/examples /examples] directory are a good place to start.
-* test.asm is an example of what the beginning of what a Game.com program might look like; it contains a header, and some [random] instructions to give you an idea.
+* test.asm is an example of what the beginning of a Game.com program might look like; it contains a header, and some [random] instructions to give you an idea.
 * test2.asm is for testing the integrity of the parser with complex strings.
 * test3.asm lists all possible sm8521 instructions; for verifying the output binary is correct.

@@ Line 326: / Line 326: @@
 ===Optimization Concerns===
-Some optimization could be done within this lexical analysis process. The first improvement would be replacing the linear string comparison with a binary tree. The second thing that would help in this immediate area would be replacing the string comparison itself with a hash comparison. The hash algorithm would have to be suitably small and fast enough to make much of a difference.
+Some optimization could be done within this lexical analysis process. The first improvement would be replacing the linear string comparison with a binary search tree. The second thing that would help in this immediate area would be replacing the string comparison itself with a hash comparison. The hash algorithm would have to be suitably small and fast enough to make much of a difference.
 The next big optimization would be rearranging the chk_pattern() calls within each lexical analyzer to check the most likely patterns first. The best way to choose the best order is static analysis of sm8521 source code, which is obviously in very short supply. Accurate disassemblies of commercial Game.com games would be helpful to this end, however.
 [[Category:Developer_Documentation]]

@@ Line 321: / Line 321: @@
 The lexical analyzing functions are defined in inst.c (following the function pointer table mentioned previously). The function handling the current instruction will test the operands string against a series of lexical patterns with the [http://hg.kodewerx.org/index.cgi/as85/file/a90c47020126/src/asm.c#l89 chk_pattern()] function (defined in asm.c, although this should probably be moved).
-chk_pattern() uses a scanf-like formatting string, rather than a regular expression, which is more common in lexical analysis. Documentation for the formatting string can be found in inst.h. With just a few pattern primitives, any of the sm8521's addressing modes can be matched, with the matching primitives output as part of an array. It makes good use of the format scanners defined in [http://hg.kodewerx.org/index.cgi/as85/file/a90c47020126/src/scan.c scan.c].
+chk_pattern() uses a scanf-like formatting string, rather than a regular expression, which is more common in lexical analysis. Documentation for the formatting string can be found in [http://hg.kodewerx.org/index.cgi/as85/file/a90c47020126/src/inst.h#l29 inst.h]. With just a few pattern primitives, any of the sm8521's addressing modes can be matched, with the matching primitives output as part of an array. It makes good use of the format scanners defined in [http://hg.kodewerx.org/index.cgi/as85/file/a90c47020126/src/scan.c scan.c].
 If chk_pattern() manages to find a match, the matching data may be further checked for validity on a per-context basis. Finally, the full instruction byte codes will be put together and returned to the assemble() loop. This is where the object code would be built. Currently the only thing that happens now is dumping the assembled instruction to stdout, in a debug build. [http://hg.kodewerx.org/index.cgi/as85/file/a90c47020126/src/asm.c#l464]