...Never Say It's Over...

Since not all MCS 213 students can try DEBUG commands because of the technical problems of our computers, search now any Turbo C program with assembly

2008-10-09T19:43:00.000-07:00

#include

unsigned char buffer[3];
FILE *fd;
int handle;
fail(char *);
void pass(char *);
main(int argc,char *argv[])
{
int n;
if(argc!=3)
{
printf("\nFailpass Utility v1.0 Email: chingpongin@yahoo.co.in");
printf("\nEnable/Disable .EXE or .COM execution");
printf("\nsyntex failpass fail ");
printf("\n or");
printf("\n failpass pass ");
exit(2);
}
strupr(argv[1]);
n=strcmp(argv[1],"FAIL");
if(n==0)
{
fail(argv[2]);
exit(2);
}
n=strcmp(argv[1],"PASS");
if(n==0)
{
pass(argv[2]);
exit(2);
}
return 0;
}
fail(char *fname)
{
_chmod(fname,1,FA_ARCH);
fd=fopen(fname,"rb+");
if(fd==NULL)
{
printf("\nCann't open %s\n\n",fname);
exit(2);
}
fseek(fd,0,SEEK_SET);
fread(buffer,2,1,fd);
if(buffer[0]==0xcd)
if(buffer[1]==0x20)
{
fclose(fd);
printf("\n%s already protected...\n\n",fname);
exit(2);
}
fseek(fd,0,SEEK_END);
fwrite(buffer,2,1,fd);
fseek(fd,0,SEEK_SET);
buffer[0]=0xcd; /* don't take any PANGA with this line */
buffer[1]=0x20; /* don't take any PANGA with this line */
fwrite(buffer,2,1,fd);
fclose(fd);
return 0;
}
void pass(char *fname)
{
int xyz;
fd=fopen(fname,"rb+");
if(fd==NULL)
{
fclose(fd);
printf("\nCannot open file %s\n\n",fname);
exit(2);
}
fseek(fd,0,SEEK_SET);
fread(buffer,2,1,fd);
if(buffer[0]!=0xcd)
if(buffer[1]!=0x20)
{
fclose(fd);
printf("\n%s is NOT protected....\n\n",fname);
exit(2);
}
fseek(fd,-2,SEEK_END);
fread(buffer,2,1,fd);
fseek(fd,0,SEEK_SET);
fwrite(buffer,2,1,fd);
fclose(fd);
handle=open(fname,O_RDWR);
chsize(handle,(filelength(handle))-2);
close(handle);
}

Research in the net the most recent assembler. Describe its history, nature and applications. Evaluate this assembler from its predecessor.

2008-10-07T19:54:00.000-07:00

1.) ASM-One = ASM-One was originaly made by Rune-Gram Madsen (better known in the sceneas Promax). He programmed ASM-One in 700 hours during a 4 month period.Before writing ASM-One Rune made some improvements to a resourced versionof Seka. He, however, had much more ideas for improvements than hecould fit into the ugly resourced version of Seka. He therefore startedcoding ASM-One from scratch.Rune made a deal with DMV Verlag (a German company) to sell ASM-One as acommercial program. Unfortunally this didn't turned out the way hehad expected. The guy that signed the contract left the company 2 months laterand Rune had to threaten them with lawers and such to get DMV to dothings they had promised to do (like advertising).All in all, ASM-One sold about 500 copies. Rune bought his first PC forthe money he earned, finished his studies on Computer Science, and startedas a consultant developing software.

2.) VIC-20 = The VIC-20 debuted in June of 1980 at the Computer Electronics Show but its development started almost by accident two years earlier. Commodore engineered and manufactured the "Video Interface Chip 6506" or VIC1 for the video game market which was beginning to collapse. After not being able to sell the chip, Commodore developed the VIC-20 as an inexpensive home computer. Between early 1981, when the VIC actually hit store shelves, and the first few months of 1985, when the last VIC production line was shut down, it had sold more than 2.5 million units. It had an very impressive peak daily production of 9000 units and was the worlds first computer to sell more than 1 million units. There are reports that during its development it was called the MicroPET. and there is a lot of debate over the origins "20" portion of the VIC-20 name. The Commodore Executive responsible for the VIC's development, and the author of The Home Computers Wars, Michael Tomczyk, stated repeatedly that he choose the name simply because he thought it "sounded good". The assembler supported the usual symbolic addressing and the definition of character strings or hex strings. It also allowed address expressions which could be combined with addition, subtraction, multiplication, division, logical AND, logical OR, and exponentiation operators.

REFERENCES:*http://en.wikipedia.org/wiki/Assembly_language#Historical_perspective *http://www.theflamearrows.info/documents/asminfo.html *http://www.commodore.ca/products/vic20/commodore_vic-20.htm

"CrIs LyN"

Justify what situations or applications programmers will rather use Assembly Languages than Higher Level Progamming Languages and vice versa.

2008-10-07T19:37:00.000-07:00

Unlike the other programming languages catalogued here, assembly language is not a single language, but rather a group of languages. Each processor family (and sometimes individual processors within a processor family) has its own assembly language.

In contrast to high level languages, data structures and program structures in assembly language are created by directly implementing them on the underlying hardware. So, instead of catalogueing the data structures and program structures that can be built (in assembly language you can build any structures you so desire, including new structures nobody else has ever created), we will compare and contrast the hardware capabilities of various processor families.

This web page does not attempt to teach how to program in assembly language. Because of the close relationship between assembly languages and the underlying hardware, this web page will discuss hardware implementation as well as software.

If you aren’t fairly familiar with how computers work, you should probably first read basis of computer hardware or this page won’t make any sense at all.

"CrIs LyN"

Best Assembler???

2008-09-16T19:20:00.000-07:00

Technically an assembler is for processing assembly code and a compiler is for processing high(er)-level code(C/C++, Delphi, VB etc.).
But technically it's compiling the source code, and thus it should be a compiler. WTF
An assembler is indeed a primitive compiler, but I believe it`s best to refer to asm compilers as assemblers for better distinction at least.

"CrIs LyN"

ASsEmblY LangUAge AppLicaTion??

2008-09-14T19:42:00.000-07:00

Hard-coded assembly language is typically used in a system's boot ROM(BIOS on IBM-compatible PC systems). This low-level code is used, among other things, to initialize and test the system hardware prior to booting the OS, and is stored in ROM. Once a certain level of hardware initialization has taken place, execution transfers to other code, typically written in higher level languages; but the code running immediately after power is applied is usually written in assembly language. The same is true of most boot loaders.

Many compilers render high-level languages into assembly first before fully compiling, allowing the assembly code to be viewed for debugging and optimization purposes. Relatively low-level languages, such as C, often provide special syntax to embed assembly language directly in the source code. Programs using such facilities, such as the Linux kernel, can then construct abstractions utilizing different assembly language on each hardware platform. The system's portable code can then utilize these processor-specific components through a uniform interface.

Assembly language is also valuable in reverse engineering, since many programs are distributed only in machine code form, and machine code is usually easy to translate into assembly language and carefully examine in this form, but very difficult to translate into a higher-level language. Tools such as the Interactive Disassembler make extensive use of disassembly for such a purpose.

A particular niche that makes use of assembly language is the demoscene. Certain competitions require the contestants to restrict their creations to a very small size (e.g. 256B, 1KB, 4KB or 64 KB), and assembly language is the language of choice to achieve this goal.^[9] When resources, particularly CPU-processing constrained systems, like the Amiga and the Commodore 64, are a concern, assembler coding is a must: optimized assembler code is written "by hand" and instructions are sequenced manually by the in an attempt to minimize the number of CPU cycles used; the CPU constraints are so great that every CPU cycle counts. However, using such techniques has enabled systems like the Commodore 64 to produce real-time 3d Graphics with advanced effects, a feat which would be considered unlikely or even impossible for a system with a 0.99MHz processor.

"cRiS LyN"

what topic/s of MCS213 do you find easy/difficult..Why???

2008-09-14T19:19:00.001-07:00

Topic that is much easier is solving number systems..It is easier for me because I do love solving as well as numbers...While the hardest is programming..Even if I can put the correct syntax sometimes in solving such problem,I can't say that I probably understand it already since it is very complicated,tedious and very mind boggling..

"cris_lyn"