Chastity White Rose

Blog

  • chastack prototype

    I have created a small prototype of a calculator in the C programming language. It is a stack based calculator similar to the forth programming language. It is written in C as a testing ground but uses methods designed to be translatable to Assembly language. It will be a featured program in chapter ten of my Linux Assembly book.

    main.c

    #include <stdio.h>
#include <string.h>
#include "chastelib.h"

#define stack_length 0x10
int stack[stack_length]; /*stack array of size stack_length*/

/*
variables named after registers

esp is declared as a pointer because its only purpose in Assembly is managing the stack
ebp is declared as a pointer to keep track of the original stack pointer address

all other registers are used as normal integers
*/
int eax,ebx,ecx,edx,esi,edi,*ebp,*esp;

void push(i)
{
 esp--;
 *esp=i;
}

int pop()
{
 int i=*esp;
 *esp=0; /*set the value at [esp] to 0 to delete it*/
 esp++;
 return i;
}


int main(int argc, char **argv)
{
 int x=1;

 /*set the radix used for integer display*/
 radix=10;
 int_width=1;

 /*set the stack pointer to where it should start*/
  esp=stack+stack_length;
  ebp=esp; /*backup address of esp to ebp*/

 /*
 Now the fun begins. Each argument is processed as a number or command
 */

 while(x!=argc)
 {
  /*
  putstr(argv[x]);
  putstr("\n");
  */
  
  /*first, we check for commands before we check for integers*/
  
  if(!strcmp(argv[x],"add"))
  {
   /*putstr("The add command adds using the top two numbers on the stack.\n");*/
   ebx=pop();
   eax=pop();
   eax+=ebx;
   push(eax);
  }
  
  else if(!strcmp(argv[x],"mul"))
  {
   /*putstr("The mul command multiplies using the top two numbers on the stack.\n");*/
   ebx=pop();
   eax=pop();
   eax*=ebx;
   push(eax);
  }

  else if(!strcmp(argv[x],"sub"))
  {
   /*putstr("The sub command subtracts using the top two numbers on the stack.\n");*/
   ebx=pop();
   eax=pop();
   eax-=ebx;
   push(eax);
  }

  else if(!strcmp(argv[x],"div"))
  {
   /*putstr("The div command divides using the top two numbers on the stack.\n");*/
   ebx=pop();
   eax=pop();
   eax/=ebx;
   push(eax);
  }

  else /*try to get a number and push it to the stack*/
  {
   
  eax=strint(argv[x]); /*get a number from the string*/
  if(strint_errors)
  {
   putstr("Last argument was not a number, but it could be a command!\n");
  }
  else
  {
   /*
   putstr("number returned by strint(argv[x]) is: ");
   putint(eax);
   putstr("\n");
   putstr("It will be pushed to the stack.");
   */
   push(eax);
  }
  
  }
  
  x++;
 }
 
 while(esp<ebp)
 {
  putint(*esp);
  putstr("\n");
  esp++;
 }
 
 return 0;
}

  • SALUTE THE RAINBOW FLAG

    The most potent weapon against the lesbian and gay community has been the stereotypes that we have ourselves aided in creating. Our parades are videotaped, but only our campiest brethren are not edited out; our statements are recorded, but only the most extreme are heard; our disagreements are noted, but only the most politically correct are not filtered out. We find ourselves portrayed as an army of leather and feather clad politically correct hot-heads marching in lockstep (in heels??) to the beat of the same drummer.

    And yet, when any group raises its head, not to denounce our more eccentrically coffered siblings, but to disagree with the community’s self appointed coat-and-tie leadership, we are ostracized.

    It is not too much to say that there is a concerted effort within the gay and lesbian community to suppress the pro-life message. If you come forth as a pro-life gay man or lesbian, you are likely to be accused of sedition. To speak in defense of the unborn is to violate the last taboo of the gay community. The argument that sexual privacy rights necessarily are dependent on abortion rights is specious. In the 1973 the Supreme Court ruled that abortion was a constitutionally protected privacy right: In 1986 the Supreme Court ruled that consensual homosexual relations were not. Therefore, for lesbians and gays this specific constitutional theory of privacy rights is irrelevant.

    When was the last time that the Human Rights Campaign Fund or any local gay political action committees endorsed a pro-life candidate for office – even if that candidate was also pro gay? And what about a the routine diversion of funds raised by AIDS walks to abortion providers – and this in the name of compassion for people with with AIDS? Pro-life gays and to lesbians – even those who have lost loved ones AIDS – have actually found themselves excluded from AIDS walks because they objected to this practice. When any march or rally is proposed to seek redress of a grievance of the lesbian and gay community – anti-gay violence, for example – it must be joined in equal measure with a demand for reproductive freedom and abortion on demand. We are exhorted in our publications and e-mail to resist any restriction on abortion as if it intended to replace the daily execution of 4400 of the unborn with 4400 of our own.

    Of all Americans, those of us in the sexual minority community have the most reason to be concerned about protecting human life. After all, we know what it is to have our lives and rights trampled on, especially the basic human right just to keep on living. Homophobia has placed our right to life in danger every day: ask anyone who has been bashed or someone whose insurance will not cover lifesaving medical care. We fight back in every way that we can: we organize, we lobby, we vote. We claim the same basic rights heterosexuals take for granted.

    But lesbian and gay Americans are not the only ones whose rights are jeopardized. Everyday, the ugly face of prejudice shows itself when the rights of others are shortchanged because of gender, race, state of health, ethnicity, religion, politics, etc. The gay community has come to the realization that we cannot work for our own rights alone but must work to achieve basic human rights for all those who suffer discrimination.

    Why? Because our rights and the rights of others are the same human rights. As gay men and lesbian women, we stay that all human life deserves dignity and respect. No human life should be considered expendable and the basic right to live should be guaranteed without threat or harassment. That includes the unborn, a voiceless minority with no defense against the worst of all abuses: death. Some 4400 are wiped out every day. Why must we speak for unborn people? Simply because they are people. To be pro-life and pro-gay is to affirm that human rights are not discretionary.

    America’s abortion policy violates this basic concept of human rights. Just like homophobia, abortion denies people their status as members of human society. Just like homophobia, abortion tries to rid society of real human beings who are considered threatening or undesirable. Just like homophobia, abortion denies one’s place as a member of human society and even one’s right to be alive in it.

    No, not all lesbians and gays are “pro-choice” and it is far past the time when the stereotype imposed on us by some of the “leaders” of our community attempt to force upon us is removed. No survey suggests that members of the sexual minority community are any more pro-choice than the average American. While equal rights have not yet been won, we have grown into a community as diverse as the nation. Closet doors have been abandoned by the thousands. Invisibility and fear are fading into history. Gays and lesbians come from many different backgrounds and hold widely differing belief on many issues. We represent a diversity and pluralism of beliefs at which the rainbow flag only hints. To attempt to enforce a “party line” on all members of our community is to betray the very cause we are fighting for: The right to be different.

    For years, mainstream society has rightly been condemned for not letting lesbians and gays participate fully in the American dream. Now we, in turn, are not permitting our own to be fully active in gay society. We wave rainbow flags and envision multi-colored mosaics but somehow these colors fade away when gay pro-lifers attempt to join the parade. Gays and lesbians who tout ideological diversity prove themselves hypocrites when they ostracize gay pro-lifers.

    If the gay movement is to win the struggle against bigotry and intolerance in mainstream American society, it must first eliminate bigotry and intolerance within it own ranks. We must not do the work of homophobes for them by stereotyping ourselves and enforcing a blanket of political correctness. Even worse, they hinder our entire march of civil rights. When gays and lesbians stereotype themselves with a uniform of political correctness, we make it easy for anti-gay fanatics to smear all of us.

    The existence of the Pro-Life Alliance of Gays and Lesbians (PLAGAL) shreds both the stereotype which the lesbian and gay community has of pro-lifers as well as the stereotype which the straight community has of lesbian and gay Americans. The voices of lesbian and gay pro-lifers are testimony that gays and lesbians are, indeed, everywhere.

    Twenty-five years ago others fought for our rights at Stonewall and we can best honor their memory by defending the rights of others today. Not only the rights of unborn Americans, but also the free speech rights of gay and lesbian Americans. After all, the fight at Stonewall was for our right to be different, not merely to replace the conformity demands of straight society with the conformity demands of certain elements of gay and lesbian society. The freedom of gays and lesbians – not the extermination of the unborn – must be the benchmark for gay liberation.

    Abortion proponents have targeted the LGBТ community with a position paper to the effect that our rights are dependent on the judicially created “right to privacy” which is the foundation upon which Roe v. Wade, and hence abortion, is based. The parallel analysis of changes in abortion rights with changes in gay rights shows how specious this argument is.

    Since the Roe v. Wade decision of 1973, there has been a slow and consistent erosion of abortion-on-demand with the imposition of mandatory counseling, waiting periods, and parental notification. Prohibitions against the expenditure of federal funds as well as state funds have been found constitutional. International family agencies receiving U.S. aid have been prevented from counseling for abortion. Casey v. Planned Parenthood replaced Roe v. Wade as the law of the land on abortion; it replaced the “strict scrutiny” test of state anti-abortion laws with a much weaker “undue burden” test, with four of the nine justices calling for an outright reversal of Roe. Thirty-two states now require parental notification and 18 states require waiting periods and counseling as to risks and fetal development. Both houses of Congress have voted to ban “partial birth” abortions. And the number of abortions has been steadily declining for at least a decade.

    As abortion rights have been undergoing a consistent cutback, there has been a simultaneous expansion of gay rights. In 1961, all states and the District of Columbia had anti-sodomy laws. By the time of the infamous Bowers v Hardwick decision in 1976, fully 50% of the states had already decriminalized sodomy. Bowers held anti-sodomy laws constitutional and stated that the fact that homosexual conduct occurs in the privacy of the home does not affect the result. Bowers was decided fully three years after Roe v. Wade, giving giving lie to the argument that the “right to privacy” had any application to the LGBT community: “Respondent would have us announce …a fundamental right to engage in homosexual sodomy. the This we are quite unwilling to do.” This is the same court, which by a 7 to 2 holding, found a fundamental right in the abortion process.

    When Bowers was specifically overruled by Lawrence v. Texas in 2003, the 25 states that had outlawed sodomy in Bowers had been reduced to only 13, of which only 4 enforced their laws against homosexual conduct. In dissent, Justice Scalia noted that the LGBT community had had considerable success in promoting their agenda to decriminalize sodomy through democratic means. To be sure, there is plenty of language in Lawrence as to “privacy,” but it has little, if any, relevancy to the actual holding based on the due process clause of the 14th Amendment.

    Gay marriage (civil unions, domestic partnerships) is currently a hot public policy issue, but it is the very antithesis of a privacy right because it seeks state action for the approval and sanction of LGBT relationships. Because the marriage contract is a three-party contract (the state is the third party) there can be no meaningful talk of a “right to privacy.” The issue of marital equality is one which has just started, with a few states taking positive steps and The several states taking negative ones. The LGBT community need not fear the competition in the marketplace of ideas.

    Other than gay marriage (which does not concern the right to privacy) and sodomy (which has been won largely by the democratic process and not litigation) the Supreme Court’s only other gay decision, Romer v. Evans, is based on equal protection of the laws and not the right to privacy. Romer disallowed a Colorado constitutional amendment which would have denied gays the protection of anti-discrimination laws. The argument for the right to privacy (“get out of my bedroom") is an appealing one for the LGBT community but it has nothing to do with the advancement of gay rights since the movement began with the Stonewall Riots of 1964. The long fight to decriminalize gay sexual behavior was won state by state through the democratic process. The success was so absolute prior to the Lawrence decision that homosexual sodomy was outlawed in only 4 of the 50 states, and even in those states it was not enforced, leading Justice Thomas to call it an “uncommonly silly” law. The fight for marriage equality is a public policy issue outside any privacy concerns. Any other gay court decision has addressed equal protection of the laws, once again not sounding in any “right to privacy.”

    The position paper put forth by abortion advocates is a thinly veiled attempt to shore up rapidly fading support for abortion-on-demand. Gay Americans, much like their counterparts in straight America, have differing philosophical, religious, moral, ethical, and pragmatic attitudes toward abortion. This appeal to our self-interest will fail as will the attempt to divide and conquer. Abortion advocates have attempted to divide men from women, rich from poor, white from black, religious from secular but it appears all this hard work will come to naught. Abortion rights will fail because, unlike gay rights, they are not the result of a democratic process but rather a brand new “constitutional right” created by a court impatient with democratic change.

    Rainbow Pro-Life Alliance Historical Preservation Project

    Source of this Article: https://mads.si.edu/mads/id/NMAH-AC1146-B041-F025

  • AAA-Linux: Chapter 8: User Input

    This post is a preview of the Linux version of Assembly Arithmetic Algorithms. It is planned to be bigger than the DOS book was and so far I am up to chapter 8 and trying to explain everything I can for Linux users who want to write assembly for modern computers at a speed higher than what was possible using a DOS emulator.

    The first seven chapters have been about teaching the basics of Assembly and getting output of strings and numbers to the screen. All those steps were required for learning Assembly. However, at some point, when you have a program that is meant to do something, you need to have a way for other people, especially those who are not programmers, to be able to give input to direct what the program does.

    There are two main ways of doing this in a console program. The first way is have the program ask for the user to type something from the keyboard and then wait until they write something and press enter. The next program will achieve this. Copy this and try it out and then I will explain after the code how it works.

    FASM Keyboard Input

    format ELF executable

main:

mov dword [radix],10
mov dword [int_width],1

loop_input:

mov eax,string0
call putstring

call getstring

mov esi,eax     ;mov the string address in eax to esi
mov edi,string3 ;mov the "exit" string address to edi
call strcmp     ;call the function to compare the strings and return eax
cmp eax,0       ;if eax is 0, the strings are the same
jz the_end      ;go to the_end if the user typed "exit"

mov eax,string1
call putstring

mov eax,buf
call putstring
call putline

mov eax,string2
call putstring

mov eax,[count]
call putint
call putline

jmp loop_input

the_end:
mov eax,1
mov ebx,0
int 80h

string0 db 'Enter a string from the keyboard: ',0
string1 db 'string: ',0
string2 db 'length: ',0
string3 db 'exit',0

buf db 0x100 dup '?'
count dd 0

getstring:

mov [count],0 ;set count of characters read during this function to zero
mov edx,1     ;number of bytes to read
mov ecx,buf   ;address to store the bytes

getstring_chars:

mov ebx,0     ;read from stdin
mov eax,3     ;invoke SYS_READ (kernel opcode 3)
int 80h       ;call the kernel

cmp eax,1     ;was 1 character read?
jnz getstring_end ; if not, then end this loop

mov al,[ecx]  ;mov last character read into al register

;check if this character is in the proper range to be part of the string

cmp al,0x20      ;compare with 0x20 (space)
jb getstring_end ;jump if below to getstring_end label
cmp al,0x7E      ;compare with 0x7E (tilde)
ja getstring_end ;jump if above to getstring_end label

;if neither jump happened, keep the character and

inc [count]   ;increment how many characters we have read
inc ecx       ;increment address where next byte is read from
jmp getstring_chars ;jump back to start of loop and keep reading

getstring_end:

mov byte[ecx],0 ;terminate this string with a zero

mov eax,buf ;mov the buffer address to eax for returning the string

ret

;strcmp compares the string at esi to the one at edi
;eax returns 0 if the strings are the same and 1 if different
;the algorithm is simple but I will explain it for those who are confused

;eax is initialized to zero
;a byte from each string is loaded into the al and bl registers
;the bytes are compared. if they are different, then we jump to the end
;However, if they are the same, then we check if one of them is zero
;for this purpose it doesn't matter whether we compare al or bl with zero
;because it is known that they are the same if the jnz did not take place
;if it is zero, this also jumps to the end of the function
;If neither jump took place, then we jump to the start of the loop
;but when the function finally ends bl will be subtracted from al
;this ensures that the function returns zero if the final characters are the same

strcmp:

mov eax,0

strcmp_start:

;read a byte from each string
mov al,[edi]
mov bl,[esi]
cmp al,bl
jnz strcmp_end

cmp al,0
jz strcmp_end

inc edi
inc esi

jmp strcmp_start

strcmp_end:
sub al,bl

ret

include 'chastelib32.asm'

    The getstring function uses a read system call to read from file descriptor 0 which represents standard input or the keyboard. It reads one character each time with a loop and starts at an address labeled “buf” which was declared as a global variable of 256 bytes which were initialized with question marks. I also defined a variable named count which was used to automatically count how many bytes were read.

    buf db 0x100 dup '?'
count dd 0

    But I feel that the part of this function that needs the most explaining is this section:

    cmp al,0x20      ;compare with 0x20 (space)
jb getstring_end ;jump if below to getstring_end label
cmp al,0x7E      ;compare with 0x7E (tilde)
ja getstring_end ;jump if above to getstring_end label

    Because this range of characters from space to tilde is what I have identified as the acceptable range of characters. There is no standard way that makes sense for all strings. For example, someone may want to make a getstring function that only accepts capital letters or that only accepts numbers 0 to 9. I can’t say that there is one way that is the best.

    The program listed above will keep running the loop until the user types “exit” as the string. Each time after it gets the string, it compares the what the user entered to the “exit” string. If the strcmp function returns 0, it means the two strings are the same.

    This particular variant of strcmp is based off of the C function of the same name. You may also remember that I wrote a strlen function for the first example in chapter 7 when I had a string that I wanted to write to a new file.

    I believe that using conventional names of C functions is a good idea because C programmers who read my books will already be familiar with that function and what it does in the C programming language.

    In any case, “exit” was the perfect name for a command to “exit” the program. It is also how you log out of a Linux terminal and is the official name for the system call that exits every program in this book!

    Although using the keyboard for input during a running program is a great interactive way of doing things, there is one way that I enjoy even more. The next program is one that I wrote long before I started writing this book and has been referred to as “chastearg” on my blog and the Flat Assembler Forum. It prints the command line arguments when you add them after the name of the program.

    FASM Command Line Arguments

    format ELF executable
entry main

include 'chastelib32.asm'

main:

pop eax              ;pop the number of arguments from the stack
mov [argc],eax       ;save the argument count for later

pop eax              ;pop argument 0 (name of the program)
dec [argc]           ;subtract 1 from argument count

putarg:

cmp [argc],0         ;check for remaining arguments
jz putarg_end        ;if none, end the loop and stop printing
pop eax              ;pop the next argument off the stack
call putstring       ;print the string and a new line
call putline
dec [argc]           ;subtract 1 from argument count
jmp putarg           ;jump to the beginning of the loop

putarg_end:

mov eax, 1           ; invoke SYS_EXIT (kernel opcode 1)
mov ebx, 0           ; return 0 status on exit - 'No Errors'
int 0x80

argc dd 0

    What is a Command Line Argument?

    People who come from a Windows environment may not even know what a command line argument is because they are used to pointing and clicking with a mouse. You can’t enter an argument this way. For clarification on this topic, here is some terminal text to clarify what arguments are.

    fasm main.asm
flat assembler  version 1.73.30  (16384 kilobytes memory)
2 passes, 481 bytes.
chmod +x main
./main this program has command line arguments
this
program
has
command
line
arguments

    When we run fasm and give it the name of the Assembly file we want to assemble, the file is an argument or an option we provide to it. In the above example, main.asm is the file I provide to fasm as an argument.

    After the file is assembled, I run the chmod command with the arguments “+x” and “main” which adds the execution permission to the main executable that was just created.

    Finally, running “./main” followed by more words on the same line causes Linux to interpret them as arguments. They are pushed onto the stack.

    When a program begins on Linux, you can access the number of how many arguments were passed to the program by getting the first number you pop off the stack. In the chastearg program, there is a loop that keeps track of how many arguments are left. While there are some remaining, it keeps popping them into the eax register and calling putstring until there are none left.

    Arguments vs Keyboard Input

    The primary difference between input from the keyboard during a program and passing arguments is that the arguments do not stop the execution of a program and wait for anything. If you have an install script which is meant to compile and install a large program, it is better not to pause it for any reason unless an error happens. Arguments are best in this case so that someone can pass information to it that they want the program to know.

    Keyboard input does have a benefit though. For example, suppose that you ask the user to input a number and then they accidentally input a string that is not recognizable as a number. With keyboard input, you can tell them they made a mistake and ask them to try again. With arguments, you cannot edit them during the program because they are only pushed at the start when the program is run from the terminal.

    Only you can decide which of these methods your program needs, but I hope that my explanation and my strcmp function is helpful for you when you try to write a program that needs input to do different things conditionally.

    Later in this book, I will present a calculator written in Assembly language that builds from this chapter’s keyboard input loop. However, we are not ready for that until I teach you how to separate regular strings from numbers. That will be the subject of the next chapter and I can promise you it is simultaneously the hardest task but also the most useful feature you will need for writing any program that has to read numbers.

  • Abortion prevention: don’t forget about the men

    Consider this situation: A man chooses to have sex with a woman who he knows will go for an abortion if she gets pregnant. She does get pregnant. She goes to an abortionist, who performs the abortion. Which of the three people killed the baby? The father, mother, or abortionist?

    It should be obvious that all three people played a part in the abortion. So no matter what your answer, you are partially correct. The father chose to do the one thing that could result in a pregnancy the mother did not want. The mother chose to abort rather than seeking out alternatives. The abortionist was the final step in causing the death of the baby.

    Keeping all of that in mind, if you could go back and talk to one of the people—the father, mother, or abortionist—and convince them to become pro-life, which one would you choose?

    Again, there’s no one right answer, but I would pick the father. Talking to the abortionist could have a major impact if he’s the only abortionist in town and has no one to replace him, but otherwise, the mother will just go elsewhere for the abortion. Of course talking to the mother is good because if her mind changes, the child will live. But will she have the support of the father? He had expected the mother to have an abortion even before they had sex, which implies that he has no interest in taking care of the child.

    Talking to the father makes sense because he has the power to change his ways and stop creating children who will be killed. He also has the ability to support the mother in taking care of the children he is responsible for, making the mother less likely to want to abort. Many women abort due to fear of being a single mother.

    Outreach to women in crisis pregnancy situations is great, but we need to make sure we’re reaching the men too, rather than placing all of the weight on the women. The idea that men are irrelevant to the abortion debate is incredibly misguided.

    This was a post that I submitted to Kelsey Hazzard at Secular Pro-Life back in 2014. At that time, I was still known as Chandler Klebs. You can still read it where Kelsey posted in on the Secular Pro-Life Blog

    http://blog.secularprolife.org/2014/08/abortion-prevention-dont-forget-about.html

  • update for chastext on DOS

    I used my new getarg function I wrote to improve the DOS version of chastext. Nothing about the behavior of the program has changed but the code is a lot smaller and more readable. This chastext program was the original reason I wrote the chastearg program. I needed to get the command line arguments just write.

    But more importantly, people may not see the value of the chastext program and why it is useful to transform text. For that reason, I took this screenshot of a demo batch file that shows just how much I can modify a text file in stages.

    Besides changing a funny tongue twister about seashells into other things (which made a really great example), I also used the Linux version of chastext to make it possible to assemble my DOS programs with either FASM or NASM. The two assemblers are mostly compatible with each other when doing DOS programming due to the lack of headers in ‘.com’ files. Simply replacing “include” with “%include” is enough to transform my FASM source into NASM source because the % is required for the NASM include directive.

    FASM is my main assembler but making sure it assembles my code in NASM will also make a difference for those following my book, Assembly Arithmetic Algorithms for DOS. The book is complete and available on leanpub but there are possible corrections to the code if necessary.

    And for now, I am also trying to work on the Linux version of the book which will be more work because I have a new angle where I want to compare the Assembly to the C code of the same program. Since Linux developers are more familiar with C, it will help those with C language experience to learn the nature of Assembly language and how it is specifically very useful for Linux systems even more than it is for DOS or Windows.

    Also, the source code of the chastext program is available in its own repository.

    https://github.com/chastitywhiterose/chastext

    C and assembly versions are available which means that it can be either compiled or assembled and run on any operating system that I know about. Almost every platform has a C compiler and my custom assembly programs perform even higher on DOS and Linux than the C version did.

    Between chastehex, chastecmp, and now chastext, I have a small set of development tools that I can use for verifying when my programs are producing the output I want. Each tool was made for a specific need I had in mind.