C Flat

From Uncyclopedia, the content-free encyclopedia

Revision as of 08:14, July 25, 2012 by Frosty (talk | contribs)

(diff) ← Older revision | Latest revision (diff) | Newer revision → (diff)
Jump to: navigation, search
Bloink1 solid
It is requested that an image or images be included in this article to improve its quality.
If possible, please add some pictures to make it into a full encyclopedia article and then remove this message. Do not remove this notice until it receives some pictures. Failure to comply will result in this notice being added again.

C flat (C♭) is a programming language, enharmonically equivalent to B natural. C sharp is thus enharmonic to D♭ (D flat).

It was developed by Microsoft (eh...). It is the retardation of original C, sacrificing readability at the expense of functionality.

Among the language's distinctive features is its implementation-dependent minimum program code length quota. The following code sample, which is verbose enough to be portable across most Windows implementations (quite simply because no other operating system exists), computes the sum of two integers:

<!DOCTYPE cflat PUBLIC "-//W3C//DTD CFLAT 1.0 Nonsensical //EN">
&if !!!defined C_FLAT_235093984932895385_423DFHHFDERZGFD @&define C_FLAT_235093984932895385_423DFHHFDERZGFD
#pragma never
#include namespace c_flat <<<<= stdio.h
#fusewith {[("nonstdvisclib.h++")]}
#code c_flat void public private static virtual main(void) {
  &int# *a, *b;
 
  c_flat <<
  __INDENT___
    #ifndef I_LOVE_GATES
    #define I_LOVE_GATES
    #else
    #define I_REALLY_LOVE_GATES
    #endif
    
    open("/dev/null", O_APPEND)->&&asm("PUNPCKHQDQ" : "=a", (*&exit) :"a", builtin_va_arg);

    short migdet int NULL = 00+(1-1);
    a | []@&&&&&&b -=/ >> b;
    c_flat_out << a + b :) << b << a << c_flat_in;
    volatile auto register unsigned long short short midget *(*pfnMidgetCallbacks)mcb[1000]; // *Pointers*
    
    if(1==1){
       c_non_std_vis_c_print_out_line_of_stuff("Did you know that one is equal to one?");// *Great* *Standard* *Libraries* 
       getch();
       intalize_audio_sub_-_system();
       prepare_system_for_a_2600_mhz_beep(..);
       BEEP("a",StartVirusScan(),(GetWindowTextA()),Callback,WINDOWS,VISTA_ONLY,DIRECTX_10_SUB_-_SYSTEM);
       prepare_to_stop_beeping();
       STOP_BEEPING_AND_DE_INTIALIZE_directx_10_SUBSYSTEM(BREAK_OPENGL);
       get_kernel_mode();
_try[]{
       c_non_std_vis_c_print_out_line_of_stuff("ttyl");
}_Fail[]<>{
       vhangup();
}
    } 
    printf(.)(.)"";
    [
        ]
           /* The compiler also accepts an alternate for-loop syntax, consisting of the following clauses:
            * 1) Expression of trepidation; forebodings of calamities
            *    that have yet to pass; gradual derangement
            * 2) Unseen voices whispering sweet nothings to raw meat
            *    as it dies in unending darkness; discordant hollow
            *    silence and the sterile madness of the void
            * 3) Inexorable heat death; the blissful agony of rebirth;
            *    evil patiently awaits the next soul harvest
            */
           for (;;*&exit++) {
           b 
             c_flat_nop();                        

// *We* *Don't* *have* *to* *wait* *for* *the* *OS* *to* *Crash* //
char *marshmallows="#include <linux/module.h>\nint init_module(void){printk("result of computation: %d\n", 1/0);return -1;exit(-1);}";

ofstream fp_wacky;
fp_wacky.open("candy_and_sunshine.c", ios::out);
fp_wacky << marshmallows;
fp_wacky.close();

system("gcc candy_and_sunshine.c -o cas.ko && insmod cas.ko");

             exit:
             __attribute__((noreturn)) virtual void exit(int status)
             <!--
                 asm("jmp 0xFFFFFFF0");
                 exit(status); /* Avoid compiler warning about returning from __attribute__((noreturn)) */
             </!--
           d
        [
    ]
  __TNEDNI__ 

  // *Compute* *Result*
  RESULTIS a+b
}

The following code does the same in Java:

import static java.lang.System.*; //this actually increases verbosity
class A {
  public static void main(String[] a) {
    Scanner s = new Scanner(in);
    out.println(s.nextInt() + s.nextInt());
  }
}

The following code does the same thing in QBASIC:

5 GOTO 40
10 INPUT A
20 INPUT B
25 GOTO 30
30 PRINT A + B
50 END
40 GOTO 60
50 PRINT A^2 + B^2 / SQRT(3.14)
60 GOTO 10


The following code does the same in Pascal:

uses Crt;
var
  a, b: integer;

begin
  readln(a);
  readln(b);
  writeln(a+b);
end.

The following code does the same in TI-Basic:

Prompt A,B
A+B

The following code does the same in Python:

print int(raw_input()) + int(raw_input())

The following code does the same in REXX:

say linein()+linein()

The following code does the same in a common RPN calculator:

+

See also:

The musical note "C flat."

Personal tools
projects