Converting MINI-BASIC in MASM over to C++?

This is a discussion on Converting MINI-BASIC in MASM over to C++? within the Projects and Job Recruitment forums, part of the Community Boards category; >> ...but I think porting it to C/C++ would benefit the C/C++ community. How exactly does a C/C++ programmer benefit? ...

  1. #46
    Guest Sebastiani's Avatar
    Join Date
    Aug 2001
    Location
    Waterloo, Texas
    Posts
    5,708
    >> ...but I think porting it to C/C++ would benefit the C/C++ community.

    How exactly does a C/C++ programmer benefit?

    >> It is a useful language modeled after Palo Alto Tiny BASIC from 1976.

    Debatable. I once had the task of translating a legacy program written in BASIC to C. The problem was that over the years, with each modification, the program had developed more and more bugs, and ran ever slower. The program consisted of at least 10,000 - 15,000 lines of code, and the maintainers openly admitted that they had problems understanding the code themselves (which they had written!), and were not at all sure what was causing all of the errors. After reading the code for a few hours it became clear to me that a complete rewrite would be necessary. Tracing the flow of the code was nearly impossible, and global variables were strewn all over the place. A real mess. Incidentally, the C version took only a few days to complete, was orders of magnitude smaller, and ran much faster. The bottom line is that BASIC just isn't very scaleable. It may be 'useful' for certain toy projects, but falls way short of being a 'real' programming language.
    Code:
    #include <cmath>
    #include <complex>
    bool euler_flip(bool value)
    {
        return std::pow
        (
            std::complex<float>(std::exp(1.0)), 
            std::complex<float>(0, 1) 
            * std::complex<float>(std::atan(1.0)
            *(1 << (value + 2)))
        ).real() < 0;
    }

  2. #47
    Registered User
    Join Date
    Jun 2004
    Posts
    76
    Tiny BASIC is a minibasic compared to normal, classic interpreted BASIC. It supports a minimal amount of commands and structures...26 scalar variables and 1 array (denoted by @(I)).

    Paul

  3. #48
    The larch
    Join Date
    May 2006
    Posts
    3,573
    That would indicate that it is useless for almost any practical purpose. On the other hand it might be a good exercise in implementing a programming language.
    I might be wrong.

    Thank you, anon. You sure know how to recognize different types of trees from quite a long way away.
    Quoted more than 1000 times (I hope).

  4. #49
    Registered User
    Join Date
    Jun 2004
    Posts
    76
    It is a good exercise in implementing a programming language. It has only the barest of commands...from the MiniBas.txt document:

    "In MINI-BASIC, all number are 32 bits signed integers and must be within the range of -2 147 483 647 .. 2 147 483 647.

    Variables

    There are 26 scalar variables donoted by the letters A through Z. The one array variable is denoted by '@(I)'. Its dimension is originally limited to 2000 cells in source code, but it can be extended to hundreds thousands of cells if you really need it.


    Functions

    There are four functions in MINI-BASIC.

    ABS(X) - Returns the absolute vaulue of the variable X.

    PEEK(X)- Returns the contents of 8 bits memory location X in Basic text area.

    RND(X) - Returns a random number between 1 and X (inclusive).

    SIZE - Returns the number of bytes left unused by the program



    Arithmetic and Comparison Operators

    The following operators are supported:

    / - integer divide (fractional results not returned)

    * - integer multiply

    - - subtract

    + - add

    > - compare if greater than

    < - compare if less than

    = - compare if equal to
    NOTE: multiple assignment statements are not supported, i.e., "A=B=O" is interpreted by MINI-BASIC as meaning "set A to the result of comparing B with 0

    <> - compare if not equal to

    >= - compare if greater than or equal to

    <= - compare if less than or equal to


    The +,-,*, and / operations return a value within the range -2 147 483 647.. 2 147 483 647.

    All compare operations result in a 1 if the comparison is true and a 0 if it is false.


    Expressions

    Expressions are formed with numbers, variables, and functions with arithmetic and compare operators between them. + and - signs can also be used at the beginning of an expression. The value of an expression is evaluated from left to right, except that the * and / operators are always given precedence, with + and -, and then the compare operators following, in that order.
    Parentheses can be used to alter the order of evaluation in the standard algebraic sense.


    Statements

    A MINI-BASIC statement consists of a statement number between 1 and 99999 followed by one or more commands (see Commands below).Commands in the same statement are seperated by a colon ":".If the "GOTO", "STOP", and "RETURN" commands are used then they must be the last command in that statement.


    Program

    A MINI-BASIC program consists of one or more statements. When the direct command (see Direct Commands below) "RUN" is issued, the statement with the lowest statement number is executed first, then the one with the next lowest statement number, etc. The "GOTO", "GOSUB", "STOP", and "RETURN" commands can alter this normal sequence. Within any statement the execution takes place
    from left to right. The "IF" command can cause remaining commands within the same statement to be skipped.


    Blanks

    MINI-BASIC statements and commands may use blanks freely, except that numbers, command key words, and function names may not have embedded blanks.

    Editor

    MINI-BASIC contains a useful line editor for entering and correcting MINI-BASIC programs. Maximum line length allowed is 255 char. All of the line editing features of a standard editor are used :
    - Right and left arrows to go right and left in the edited line
    - Home and End keys move cursor to top or end of line
    - Del and BackSpace keys to cancel a char. preceding or following cursor position
    - Insert to switch between normal and insert mode. Insert is the mode by default, and cursor appearence is modified, depending of the mode used.
    - Alt+num. sequence to enter an ASCII code character
    The EDIT nn command allows to correct an existing MINI-BASIC statement. Statements may be deleted by simply typing their statement number, followed by a CR. Corrections may be verified by typing LIST nn and striking the Escape to terminate the LIST process.


    ERROR MESSAGES

    There are 23 error messages in MINI-BASIC. When an error is encountered the error message itself is printed, followed by the statement causing the program error. Control is then passed to the MINI-BASIC editor.

    STATEMENT COMMANDS


    MINI-BASIC statement commands are listed below with examples.
    Remember that commands can be concatenated with semi-colons. In order
    to store any given statement, you must precede that statement with a
    statement number between 1 and 32767. Statement numbers are NOT shown
    in the examples.


    LET command

    LET A=234-5*6;A=A/2;X=A-100;@(X+9)=A-1

    The LET command assigns the value of an expression to the
    specified variable. In the example above, the variable "A" assumes
    the value of the expression "234-5*6", or "204". Then the variable "A"
    assumes the value "102". Next, the variable "X" is set to the value of
    the expression "A-100", or "2". The last command assigns the value
    "101" to the array variable "@(11)". The "LET" portion of the LET
    command is optional, i.e., the following examples are true:

    A=10
    C=5*3/5;C=C*5


    REM Command

    REM ANYTHING CAN BE WRITTEN AFTER "REM"

    The REM command is ignored by TINY BASIC. It is used by
    experienced programmers to comment BASIC programs. A program comment
    is used by programmers to remind themselves of the logic of a program
    section. All good programs are invariably commented.


    PRINT Command

    PRINT

    PRINT will cause a carriage-return (CR) and a line-feed (LF) on
    the output device.

    PRINT A*3+1,"ABC"

    This form of the PRINT command will print the value of the
    expression A*3+1 on the output device, followed by the string ABC on
    the same line. Note that single (') or double quotes (") may be used
    to denote character strings, but that pairs must be mached.

    PRINT A*3+1,"ABC",

    This form of the PRINT command will produce the same results as
    the previous example except that the normal CR-LF is inhibited by the
    trailing comma at the end of the statement. This allows other PRINT
    commands to print on the same line.

    PRINT A,B,#3,C,D,E,#10,F,G

    This form of the PRINT command demonstrates format control. The
    format character # is used to indicate the number of leading spaces to
    be printed before a number. The default number is 6. Once the # format
    is invoked it is active for the remainder of the statement unless
    overridden by a subsequent format specifier, as in the example.

    PRINT 'ABC',\,'XXX'

    The back-slash (\) character is used to cause a CR without a LF.
    In this example, the string ABC is printed followed by the string XXX
    on top of the original ABC.


    INPUT Command


    INPUT A,B

    The INPUT statement is used to acquire input data during program
    execution. In the example above, MINI-BASIC will print A: and wait
    for a number to be typed at the console terminal. Next, MINI-BASIC
    will print B: and wait for another number to be typed at the console
    terminal. In this example the variables A and B will assume the values
    of the appropiate input values. The INPUT statement will accept
    expressions as well as numbers as input.

    INPUT 'WHAT IS THE WEIGHT'A,"AND SIZE"B

    In this example MINI-BASIC will print the string WHAT IS THE
    WEIGHT: and wait for operator input. Next, the string AND SIZE: will
    be printed, on the same line, and MINI-BASIC will wait for operator
    input.

    INPUT A,'STRING',\,"ANOTHER STRING",B

    MINI-BASIC will react to the back-slash character (\) in this
    example in the same fashion as in the PRINT command. The second string
    will overwrite the first string STRING.


    IF Command

    IF A<B LET X=3;PRINT 'THIS STRING'

    The IF command works with the comparison operators (enumerated
    above) to check the validity of the specified comparison condition. In
    this example, if the comparison A<B is true, then the balance of the
    commands in the statement are executed. However, if the comparison
    tests false, then the balance of the commands in the statement are NOT
    executed and control passes to the statement with the next highest
    statement number.


    IF A<B GOTO 100

    This example illustrates a common use of the IF command and the
    GOTO (see below) command. If the comparison tests true control is
    passed to statement number 100, otherwise execution passes to the
    statement with the next highest statement number.


    GOTO Command

    GOTO 120

    This statement is used to modify the normal sequence of
    execution of MINI-BASIC statements. In this example, control is passed
    unconditionally to statement number 120. The GOTO command cannot be
    followed by a semi-colon and other commands within the same statement.
    It must appear as the last command in any given statement.

    GOTO A*10+B

    This form of the GOTO is called a "computed GOTO". In this case,
    control is passed to the statement number represented by the
    expression that follows "GOTO".


    GOSUB Command

    GOSUB 120

    The GOSUB command is used to invoke a subroutine at the
    specified statement number (120 in the example). Control is passed to
    statement number 120 and execution continues. A RETURN command (see
    below) is used, within the subroutine, to cause MINI-BASIC to pass
    control to the statement that immediatly follows the GOSUB command
    that caused the subroutine to execute. The GOSUB command cannot be
    followed by any other commands within the same statement and it must
    be the last command within any given statement. GOSUB commands can be
    nested, limited by the size of the stack space (see below).

    GOSUB A*10+B

    In this example, the subroutine at the statement number equal to
    the value of the expression is executed. This form of the statement
    will cause a different subroutine to be executed depending upon the
    value of the expression that follows "GOSUB".


    RETURN Command

    RETURN

    The RETURN command causes execution to resume at the statement
    that follows the GOSUB that caused the current subroutine to be
    executed. It must be the last command of any given statement.


    FOR Command

    FOR X=1 TO 10
    PRINT 'HELLO'
    NEXT X

    The FOR command is used to set up execution loops. In the TINY
    BASIC program segment above the statement PRINT 'HELLO' is executed 10
    times since it is placed between the FOR statement and the NEXT
    statement. The NEXT X statement (see below) has the effect of
    incrementing X by one and passing control to the FOR statement. If the
    new value of X is still less than or equal to 10, the MINI-BASIC
    statements between FOR and NEXT are executed again. This process
    repeats until X is incremented past the loop termination value (10 in
    the example above).

    FOR X=1 TO 10 STEP 2
    PRINT 'HELLO'
    NEXT X

    In the above variant of the FOR command the loop increment has
    been changed from 1 (the default) to 2 by means of the STEP clause. In
    this case, the program fragment would only print HELLO five times if
    executed.

    FOR commands can be nested, that is, one FOR loop can contain
    other FOR loops provided that the loop variables (the variable X in
    the examples) are diferent,. If a new FOR command with the same loop
    variable as that of an old FOR command is encountered, the old FOR
    will be terminated.


    NEXT Command

    NEXT X

    The NEXT command is part of the FOR command and is used to cause
    loop variables to be incremented by the increment specified by the
    STEP clause (default is 1) and to pass control to the appropiate TINY
    BASIC FOR loop. The variable specified by the NEXT command (X in the
    example) is used to specify the correct FOR loop.


    POKE Command

    POKE A,B

    The POKE command is used to place data B into memory address A.
    This command may be repeated as follows:

    POKE A,B,C,D

    In the above example, data B is placed in memory location A, then data
    D is placed in memory location C. All variables may be expressions. Be
    careful not to POKE MINI-BASIC itself!


    USR Command

    USR(I,J)

    The USR Command is actually a built-in TINY BASIC subroutine
    call that permits linkage to machine language subroutines. All 8086
    registers are available for use by the machine language subroutine. It
    is the responsibility of the machine language routine to execute a RET
    instruction. In the example above, a machine language routine at
    address I is called. J is an optional parameter that, if present, will
    be passed in register BX to the subroutine.


    WAIT Command

    WAIT I,J,K

    The WAIT command is used to cause MINI-BASIC execution to pause
    and wait for a specified value at an 8086 input port. In the example
    above, the value at input port I is read, exclusive OR'd with the
    value of the expression J, and the result is then AND'd with the value
    of expression K. WAIT will return only if the final result is
    non-zero. WAIT provides an easy-to-use mechanism to cause TINY BASIC
    to pause its execution and wait for a specified external event. J is
    assumed to be 0 if not specified.


    STOP Command

    STOP

    This command stops the execution of a TINY BASIC program and
    passes control to the MINI-BASIC monitor. It can appear many times in
    a program but it must be the last command in any given statement.




    DIRECT COMMANDS


    Direct commands are those commands that can be invoked only by
    the operator when MINI-BASIC is in command mode (i.e. in response to
    the '>' prompt). All statement commands (those listed above) can be
    invoked while in command mode. Typing a control-C while in command or
    monitor mode will cause TINY BASIC to terminate. Control is then
    passed to the host operating system monitor.

    Recall that a statment consists of a statement number followed
    by one or more commands. If the statement number is missing, or if it
    is 0, the command will be executed immediatly after typing the
    terminating CR. The following commands can be used as direct commands;
    they CANNOT be used as part of a MINI-BASIC statement.


    RUN Command

    RUN

    The RUN command causes execution of the stored TINY BASIC
    program. Execution will commence at the lowest numbered statement and
    continue until there are either no more statements to execute or a
    STOP command is found. A long MINI-BASIC program may be terminated by
    typing control-X at the console. This passes control the the TINY
    BASIC monitor. A control-C may be typed at any time also, then TINY
    BASIC is terminated and control is passed to the host operating
    system.


    LIST Command

    LIST

    The LIST command is used to display the current TINY BASIC
    program on the operator's console. The statements will be listed in
    numerical order. If LIST is followed by an expression (e.g. LIST 200)
    the listing will commence with statements following the specified
    statement, inclusive.


    NEW Command

    NEW

    The NEW command deletes the current program from TINY BASIC's
    memory.


    SAVE Command

    SAVE FILENAME

    The SAVE command saves the current TINY BASIC program on the
    logged in disk with the specified filename FILENAME. The default
    filetype is ".TBI". If there is insufficient room on the disk, the
    SAVE command responds with "HOW?".


    LOAD Command

    LOAD FILENAME

    The LOAD command loads the specified MINI-BASIC program from the
    logged in disk into the program area. Any program residing within TINY
    BASIC prior to the LOAD operation is lost. If the specified program is
    not found on the disk, or if there is insufficient room for the
    program, LOAD responds with "HOW?". The filetype is assumed to be
    ".TBI".


    BYE Command

    BYE

    The BYE command terminates MINI-BASIC. Control is passed back to
    the host operating system.




    MINI-BASIC OPERATION


    MINI-BASIC is initiated from the host operating system's command
    mode like any other transient command. TINY BASIC will sign-on,
    announce 'OK', and then prompt '>' awaiting operator interaction. An
    example follows:

    A:TBASIC

    8086 MINI-BASIC V1.0

    OK
    >

    In the example above the program 'TBASIC.COM' was found on the
    logged-in disk ('A' in the example). TINY BASIC then commenced
    execution by first announcing itself and then prompting '>' for
    operator input.

    MINI-BASIC utilizes all of the host operating system's line
    editing facilities. For example, if an operator wished to cancel a
    line typed to MINI-BASIC, he need only type a control-X, etc. If hard
    copy of a MINI-BASIC session is desired, control-P and control-N will
    toggle the printer, if it exists.

    At present, saved MINI-BASIC programs can be edited only with
    the internal TINY BASIC editor. Programs prepared by an external
    editor can not be read by MINI-BASIC."




    Paul

  5. #50
    Kernel hacker
    Join Date
    Jul 2007
    Location
    Farncombe, Surrey, England
    Posts
    15,677
    Quote Originally Posted by Paul Panks View Post
    Does the list function list the whole program?

    Paul
    Yes, it does - the snapshot is in the middle of the listing, but as far as I can tell, it lists the whole program.

    --
    Mats
    Compilers can produce warnings - make the compiler programmers happy: Use them!
    Please don't PM me for help - and no, I don't do help over instant messengers.

  6. #51
    Registered User
    Join Date
    Jun 2004
    Posts
    76
    Ok, thanks.

    Paul

  7. #52
    Kernel hacker
    Join Date
    Jul 2007
    Location
    Farncombe, Surrey, England
    Posts
    15,677
    At present, saved MINI-BASIC programs can be edited only with
    the internal TINY BASIC editor. Programs prepared by an external
    editor can not be read by MINI-BASIC.
    I have vague plans to allow loading of basic source-code that is plain text - there is no reason why this CAN'T be supported. This will also support editing using an external editor.

    --
    Mats
    Compilers can produce warnings - make the compiler programmers happy: Use them!
    Please don't PM me for help - and no, I don't do help over instant messengers.

  8. #53
    Kernel hacker
    Join Date
    Jul 2007
    Location
    Farncombe, Surrey, England
    Posts
    15,677
    Source code.

    Please bear in mind that this is work in progress, and a lot of it follows the original minibasic source code, where a better solution could be made in C or C++.

    The file is minibasic.cpp, but it's actually more C than C++.

    --
    Mats

    Edit: Added attachment - it is really a .zip file, not a text file.
    Attached Files Attached Files
    Last edited by matsp; 03-18-2009 at 07:18 PM.
    Compilers can produce warnings - make the compiler programmers happy: Use them!
    Please don't PM me for help - and no, I don't do help over instant messengers.

  9. #54
    Guest Sebastiani's Avatar
    Join Date
    Aug 2001
    Location
    Waterloo, Texas
    Posts
    5,708
    Hmm, I don't see the attached file, matsp...
    Code:
    #include <cmath>
    #include <complex>
    bool euler_flip(bool value)
    {
        return std::pow
        (
            std::complex<float>(std::exp(1.0)), 
            std::complex<float>(0, 1) 
            * std::complex<float>(std::atan(1.0)
            *(1 << (value + 2)))
        ).real() < 0;
    }

  10. #55
    Kernel hacker
    Join Date
    Jul 2007
    Location
    Farncombe, Surrey, England
    Posts
    15,677
    Edited.

    --
    Mats
    Compilers can produce warnings - make the compiler programmers happy: Use them!
    Please don't PM me for help - and no, I don't do help over instant messengers.

  11. #56
    Guest Sebastiani's Avatar
    Join Date
    Aug 2001
    Location
    Waterloo, Texas
    Posts
    5,708
    For some reason, ScrollConsoleScreenBuffer returns an error on my system. I'll post an update as soon as I find out why...
    Code:
    #include <cmath>
    #include <complex>
    bool euler_flip(bool value)
    {
        return std::pow
        (
            std::complex<float>(std::exp(1.0)), 
            std::complex<float>(0, 1) 
            * std::complex<float>(std::atan(1.0)
            *(1 << (value + 2)))
        ).real() < 0;
    }

  12. #57
    Guest Sebastiani's Avatar
    Join Date
    Aug 2001
    Location
    Waterloo, Texas
    Posts
    5,708
    The problem is that 'EditSize' isn't always compatible with the user's virtual console metrics. This workaround seemed to fix it:

    Code:
    void RealRedimWindow(COORD *size)
    {
        COORD maxSize;
        int newSize, oldSize;
        TestApiError(GetConsoleScreenBufferInfo(hStdOut, &csbi));
        maxSize = csbi.dwMaximumWindowSize;//GetLargestConsoleWindowSize(hStdOut);
        *size = maxSize;
        if (size->X > maxSize.X || size->Y > maxSize.Y)
        {
            BadParameter();
            return;
        }
    
        oldSize = csbi.dwSize.X * csbi.dwSize.Y;
        newSize = size->X * size->Y;
        csbi.dwSize = *size;
        if (newSize == oldSize)
        {
            return;
        }
        // Current buffer is higher, redim window first, then buffer
        if (newSize < oldSize)
        {
            TestApiError(SetConsoleWindowInfo(hStdOut, 1, &csbi.srWindow));
            TestApiError(SetConsoleScreenBufferSize(hStdOut, csbi.dwSize));
        }
        else
        {
            TestApiError(SetConsoleScreenBufferSize(hStdOut, csbi.dwSize));
            TestApiError(SetConsoleWindowInfo(hStdOut, 1, &csbi.srWindow));
        }
        ConsoleCharNbr = newSize;
        TestApiError(GetConsoleScreenBufferInfo(hStdOut, &csbi));
        TestApiError(SetConsoleMode(hStdOut, 0));
        TestApiError(SetConsoleMode(hStdIn, ENABLE_PROCESSED_INPUT));
    
        ClrScr();
    }
    Code:
    #include <cmath>
    #include <complex>
    bool euler_flip(bool value)
    {
        return std::pow
        (
            std::complex<float>(std::exp(1.0)), 
            std::complex<float>(0, 1) 
            * std::complex<float>(std::atan(1.0)
            *(1 << (value + 2)))
        ).real() < 0;
    }

  13. #58
    Registered User
    Join Date
    Jun 2004
    Posts
    76
    So how's it coming along?

    Paul

  14. #59
    Kernel hacker
    Join Date
    Jul 2007
    Location
    Farncombe, Surrey, England
    Posts
    15,677
    Quote Originally Posted by Sebastiani View Post
    The problem is that 'EditSize' isn't always compatible with the user's virtual console metrics. This workaround seemed to fix it:

    Code:
    void RealRedimWindow(COORD *size)
    {
        COORD maxSize;
        int newSize, oldSize;
        TestApiError(GetConsoleScreenBufferInfo(hStdOut, &csbi));
        maxSize = csbi.dwMaximumWindowSize;//GetLargestConsoleWindowSize(hStdOut);
        *size = maxSize;
        if (size->X > maxSize.X || size->Y > maxSize.Y)
        {
            BadParameter();
            return;
        }
    
        oldSize = csbi.dwSize.X * csbi.dwSize.Y;
        newSize = size->X * size->Y;
        csbi.dwSize = *size;
        if (newSize == oldSize)
        {
            return;
        }
        // Current buffer is higher, redim window first, then buffer
        if (newSize < oldSize)
        {
            TestApiError(SetConsoleWindowInfo(hStdOut, 1, &csbi.srWindow));
            TestApiError(SetConsoleScreenBufferSize(hStdOut, csbi.dwSize));
        }
        else
        {
            TestApiError(SetConsoleScreenBufferSize(hStdOut, csbi.dwSize));
            TestApiError(SetConsoleWindowInfo(hStdOut, 1, &csbi.srWindow));
        }
        ConsoleCharNbr = newSize;
        TestApiError(GetConsoleScreenBufferInfo(hStdOut, &csbi));
        TestApiError(SetConsoleMode(hStdOut, 0));
        TestApiError(SetConsoleMode(hStdIn, ENABLE_PROCESSED_INPUT));
    
        ClrScr();
    }
    That sets the size to always be maxSize. I don't think that's right.

    --
    Mats
    Compilers can produce warnings - make the compiler programmers happy: Use them!
    Please don't PM me for help - and no, I don't do help over instant messengers.

  15. #60
    Guest Sebastiani's Avatar
    Join Date
    Aug 2001
    Location
    Waterloo, Texas
    Posts
    5,708
    Well, the original problem I was having was that my console apparently doesn't support a size of 100 * 25, but the code wasn't detecting that. Reading the documentation for 'GetLargestConsoleWindowSize', I found this:

    The function does not take into consideration the size of the screen buffer, which means that the window size returned may be larger than the size of the screen buffer. The GetConsoleScreenBufferInfo function can be used to determine the maximum size of the console window, given the current screen buffer size, the current font, and the display size.
    So then I changed the line to:

    Code:
    maxSize = csbi.dwMaximumWindowSize;//GetLargestConsoleWindowSize(hStdOut);
    That seemed to work, since now I was getting a 'BadParameter' error. So I set 'size' to 'maxSize', and the program ran without errors.

    But now that I think of it - why resize the window at all? This seems to work fine:

    Code:
    void RedimWindow(const COORD *)
    {
        TestApiError(GetConsoleScreenBufferInfo(hStdOut, &csbi));
        ConsoleCharNbr = csbi.dwSize.X * csbi.dwSize.Y;
        TestApiError(SetConsoleMode(hStdOut, 0));
        TestApiError(SetConsoleMode(hStdIn, ENABLE_PROCESSED_INPUT));
        ClrScr();
    }
    Code:
    #include <cmath>
    #include <complex>
    bool euler_flip(bool value)
    {
        return std::pow
        (
            std::complex<float>(std::exp(1.0)), 
            std::complex<float>(0, 1) 
            * std::complex<float>(std::atan(1.0)
            *(1 << (value + 2)))
        ).real() < 0;
    }

Popular pages Recent additions subscribe to a feed

Similar Threads

  1. Converting textBox1->Text into a basic string.
    By azjherben in forum C++ Programming
    Replies: 5
    Last Post: 06-07-2009, 09:27 PM
  2. [ANN] New script engine (Basic sintax)
    By MKTMK in forum C++ Programming
    Replies: 1
    Last Post: 11-01-2005, 10:28 AM
  3. what are your thoughts on visual basic?
    By orion- in forum A Brief History of Cprogramming.com
    Replies: 16
    Last Post: 09-22-2005, 05:28 AM
  4. VC++ 6 & MASM (eek)
    By cboard_member in forum C++ Programming
    Replies: 2
    Last Post: 07-16-2005, 11:00 AM

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21