Index: translator/Parser/TypeData.cc
===================================================================
--- translator/Parser/TypeData.cc	(revision 0b8cd7227c65b28513877765de7302e28eefbb6f)
+++ translator/Parser/TypeData.cc	(revision f7f6785834eaf341228a98a2b3786030fe9329ba)
@@ -696,4 +696,10 @@
 	    } else {
 		switch ( ret ) {
+		  case BasicType::LongLongSignedInt:	// PAB
+		    ret = BasicType::LongLongUnsignedInt;
+		    break;
+		  case BasicType::LongSignedInt:
+		    ret = BasicType::LongUnsignedInt;
+		    break;
 		  case BasicType::SignedInt:
 		  case BasicType::ShortSignedInt:
@@ -715,4 +721,7 @@
 	    } else {
 		switch ( ret ) {
+		  case BasicType::LongLongSignedInt:	// PAB
+		    ret = BasicType::LongLongUnsignedInt;
+		    break;
 		  case BasicType::LongSignedInt:
 		    ret = BasicType::LongUnsignedInt;
Index: translator/Parser/cfa.y
===================================================================
--- translator/Parser/cfa.y	(revision 0b8cd7227c65b28513877765de7302e28eefbb6f)
+++ translator/Parser/cfa.y	(revision f7f6785834eaf341228a98a2b3786030fe9329ba)
@@ -10,24 +10,24 @@
  * Created On       : Sat Sep  1 20:22:55 2001
  * Last Modified By : Peter A. Buhr
- * Last Modified On : Wed Jan  7 09:19:57 2015
- * Update Count     : 906
+ * Last Modified On : Sat Jan 17 09:23:45 2015
+ * Update Count     : 908
  */
 
-/* This grammar is based on the ANSI99 C grammar, specifically parts of EXPRESSION and STATEMENTS, and on the
-   C grammar by James A. Roskind, specifically parts of DECLARATIONS and EXTERNAL DEFINITIONS.  While parts
-   have been copied, important changes have been made in all sections; these changes are sufficient to
+/* This grammar is based on the ANSI99/11 C grammar, specifically parts of EXPRESSION and STATEMENTS, and on
+   the C grammar by James A. Roskind, specifically parts of DECLARATIONS and EXTERNAL DEFINITIONS.  While
+   parts have been copied, important changes have been made in all sections; these changes are sufficient to
    constitute a new grammar.  In particular, this grammar attempts to be more syntactically precise, i.e., it
    parses less incorrect language syntax that must be subsequently rejected by semantic checks.  Nevertheless,
-   there are still several semantic checks required and many are noted in the grammar. Finally, the grammar
-   is extended with GCC and CFA language extensions. */
+   there are still several semantic checks required and many are noted in the grammar. Finally, the grammar is
+   extended with GCC and CFA language extensions. */
 
 /* Acknowledgments to Richard Bilson, Glen Ditchfield, and Rodolfo Gabriel Esteves who all helped when I got
    stuck with the grammar. */
 
-/* The root language for this grammar is ANSI99 C. All of ANSI99 is parsed, except for:
+/* The root language for this grammar is ANSI99/11 C. All of ANSI99/11 is parsed, except for:
 
    1. designation with '=' (use ':' instead)
 
-   Most of the syntactic extensions from ANSI90 to ANSI99 C are marked with the comment "ANSI99". This grammar
+   Most of the syntactic extensions from ANSI90 to ANSI11 C are marked with the comment "C99/C11". This grammar
    also has two levels of extensions. The first extensions cover most of the GCC C extensions, except for:
 
@@ -40,5 +40,5 @@
    Cforall (CFA), which fixes several of C's outstanding problems and extends C with many modern language
    concepts. All of the syntactic extensions for CFA C are marked with the comment "CFA". As noted above,
-   there is one unreconcileable parsing problem between ANSI99 and CFA with respect to designators; this is
+   there is one unreconcileable parsing problem between C99 and CFA with respect to designators; this is
    discussed in detail before the "designation" grammar rule. */
 
@@ -67,19 +67,20 @@
 %token TYPEDEF
 %token AUTO EXTERN REGISTER STATIC
-%token INLINE						/* ANSI99 */
-%token FORTRAN						/* ANSI99, extension ISO/IEC 9899:1999 Section J.5.9(1) */
+%token INLINE						/* C99 */
+%token FORTRAN						/* C99, extension ISO/IEC 9899:1999 Section J.5.9(1) */
 %token CONST VOLATILE
-%token RESTRICT						/* ANSI99 */
+%token RESTRICT						/* C99 */
 %token FORALL LVALUE					/* CFA */
 %token VOID CHAR SHORT INT LONG FLOAT DOUBLE SIGNED UNSIGNED
-%token BOOL COMPLEX IMAGINARY				/* ANSI99 */
+%token BOOL COMPLEX IMAGINARY				/* C99 */
 %token TYPEOF LABEL					/* GCC */
 %token ENUM STRUCT UNION
 %token TYPE FTYPE DTYPE CONTEXT				/* CFA */
 %token SIZEOF
-%token ALIGNOF ATTRIBUTE EXTENSION			/* GCC */
+%token ATTRIBUTE EXTENSION				/* GCC */
 %token IF ELSE SWITCH CASE DEFAULT DO WHILE FOR BREAK CONTINUE GOTO RETURN
 %token CHOOSE FALLTHRU TRY CATCH FINALLY THROW		/* CFA */
-%token ASM						/* ANSI99, extension ISO/IEC 9899:1999 Section J.5.10(1) */
+%token ASM						/* C99, extension ISO/IEC 9899:1999 Section J.5.10(1) */
+%token ALIGNAS ALIGNOF ATOMIC GENERIC NORETURN STATICASSERT THREADLOCAL /* C11 */
 
 /* names and constants: lexer differentiates between identifier and typedef names */
@@ -362,5 +363,5 @@
 		{ $$ = new CompositeExprNode(new OperatorNode(OperatorNode::DecrPost), $1); }
 		/* GCC has priority: cast_expression */
-	| '(' type_name_no_function ')' '{' initializer_list comma_opt '}' /* ANSI99 */
+	| '(' type_name_no_function ')' '{' initializer_list comma_opt '}' /* C99 */
 		{ $$ = 0; }
 	;
@@ -642,9 +643,9 @@
 	  push push
 	  label_declaration_opt				/* GCC, local labels */
-	  block_item_list pop '}'			/* ANSI99, intermix declarations and statements */
+	  block_item_list pop '}'			/* C99, intermix declarations and statements */
 		{ $$ = new CompoundStmtNode( $5 ); }
 	;
 
-block_item_list:					/* ANSI99 */
+block_item_list:					/* C99 */
 	block_item
 	| block_item_list push block_item
@@ -773,5 +774,5 @@
 	comma_expression_opt pop ';' comma_expression_opt ';' comma_expression_opt
 						{ $$ = new ForCtlExprNode($1, $4, $6); }
-	| declaration comma_expression_opt ';' comma_expression_opt /* ANSI99 */
+	| declaration comma_expression_opt ';' comma_expression_opt /* C99 */
 		/* Like C++, the loop index can be declared local to the loop. */
 						{ $$ = new ForCtlExprNode($1, $2, $4); }
@@ -1244,8 +1245,8 @@
 	| STATIC
 		{ $$ = DeclarationNode::newStorageClass( DeclarationNode::Static ); }
-	| INLINE					/* ANSI99 */
+	| INLINE					/* C99 */
 		/* INLINE is essentially a storage class specifier for functions, and hence, belongs here. */
 		{ $$ = DeclarationNode::newStorageClass( DeclarationNode::Inline ); }
-	| FORTRAN					/* ANSI99 */
+	| FORTRAN					/* C99 */
 		{ $$ = DeclarationNode::newStorageClass( DeclarationNode::Fortran ); }
 	;
@@ -1270,9 +1271,9 @@
 	| VOID
 		{ $$ = DeclarationNode::newBasicType( DeclarationNode::Void ); }
-	| BOOL						/* ANSI99 */
+	| BOOL						/* C99 */
 		{ $$ = DeclarationNode::newBasicType( DeclarationNode::Bool ); }
-	| COMPLEX					/* ANSI99 */
+	| COMPLEX					/* C99 */
 		{ $$ = DeclarationNode::newBasicType( DeclarationNode::Complex ); }
-	| IMAGINARY					/* ANSI99 */
+	| IMAGINARY					/* C99 */
 		{ $$ = DeclarationNode::newBasicType( DeclarationNode::Imaginary ); }
 	;
@@ -1642,5 +1643,5 @@
 	;
 
-/* There is an unreconcileable parsing problem between ANSI99 and CFA with respect to designators. The problem
+/* There is an unreconcileable parsing problem between C99 and CFA with respect to designators. The problem
    is use of '=' to separator the designator from the initializer value, as in:
 
@@ -1653,10 +1654,10 @@
 
 designation:
-	designator_list ':'				/* ANSI99, CFA uses ":" instead of "=" */
+	designator_list ':'				/* C99, CFA uses ":" instead of "=" */
 	| no_attr_identifier_or_typedef_name ':'	/* GCC, field name */
 							{ $$ = new VarRefNode( $1 ); }
 	;
 
-designator_list:					/* ANSI99 */
+designator_list:					/* C99 */
 	designator
 	| designator_list designator			{ $$ = (ExpressionNode *)($1->set_link( $2 )); }
@@ -1664,7 +1665,7 @@
 
 designator:
-	'.' no_attr_identifier_or_typedef_name		/* ANSI99, field name */
+	'.' no_attr_identifier_or_typedef_name		/* C99, field name */
 							{ $$ = new VarRefNode( $2 ); }
-	| '[' push assignment_expression pop ']'	/* ANSI99, single array element */
+	| '[' push assignment_expression pop ']'	/* C99, single array element */
 		/* assignment_expression used instead of constant_expression because of shift/reduce conflicts
 		   with tuple. */
@@ -2257,5 +2258,5 @@
 
 /* This pattern parses a declaration for a parameter variable or function prototype that is not redefining a
-   typedef name and allows the ANSI99 array options, which can only appear in a parameter list.  The pattern
+   typedef name and allows the C99 array options, which can only appear in a parameter list.  The pattern
    precludes declaring an array of functions versus a pointer to an array of functions, and returning arrays
    and functions versus pointers to arrays and functions. */
@@ -2303,5 +2304,5 @@
 	int f( int foo ); // redefine typedef name in new scope
 
-   and allows the ANSI99 array options, which can only appear in a parameter list.  In addition, the pattern
+   and allows the C99 array options, which can only appear in a parameter list.  In addition, the pattern
    handles the special meaning of parenthesis around a typedef name:
 
@@ -2420,9 +2421,9 @@
 	'[' push assignment_expression pop ']'
 		{ $$ = DeclarationNode::newArray( $3, 0, false ); }
-	| '[' push '*' pop ']'				/* ANSI99 */
+	| '[' push '*' pop ']'				/* C99 */
 		{ $$ = DeclarationNode::newVarArray( 0 ); }
 	| multi_array_dimension '[' push assignment_expression pop ']'
 		{ $$ = $1->addArray( DeclarationNode::newArray( $4, 0, false ) ); }
-	| multi_array_dimension '[' push '*' pop ']'	/* ANSI99 */
+	| multi_array_dimension '[' push '*' pop ']'	/* C99 */
 		{ $$ = $1->addArray( DeclarationNode::newVarArray( 0 ) ); }
 	;
@@ -2493,5 +2494,5 @@
 		{ $$ = DeclarationNode::newArray( 0, 0, false ); }
 	// multi_array_dimension handles the '[' '*' ']' case
-	| '[' push type_qualifier_list '*' pop ']'	/* remaining ANSI99 */
+	| '[' push type_qualifier_list '*' pop ']'	/* remaining C99 */
 		{ $$ = DeclarationNode::newVarArray( $3 ); }
 	| '[' push type_qualifier_list pop ']'
@@ -2551,5 +2552,5 @@
 
 /* This pattern parses a new-style declaration for a parameter variable or function prototype that is either
-   an identifier or typedef name and allows the ANSI99 array options, which can only appear in a parameter
+   an identifier or typedef name and allows the C99 array options, which can only appear in a parameter
    list. */
 
@@ -2607,5 +2608,5 @@
 
 new_array_parameter_1st_dimension:
-	'[' push type_qualifier_list '*' pop ']'	/* remaining ANSI99 */
+	'[' push type_qualifier_list '*' pop ']'	/* remaining C99 */
 		{ $$ = DeclarationNode::newVarArray( $3 ); }
 	| '[' push type_qualifier_list assignment_expression pop ']'
Index: translator/Parser/lex.l
===================================================================
--- translator/Parser/lex.l	(revision 0b8cd7227c65b28513877765de7302e28eefbb6f)
+++ translator/Parser/lex.l	(revision f7f6785834eaf341228a98a2b3786030fe9329ba)
@@ -10,6 +10,6 @@
  * Created On       : Sat Sep 22 08:58:10 2001
  * Last Modified By : Peter A. Buhr
- * Last Modified On : Wed Dec  3 13:37:52 2014
- * Update Count     : 317
+ * Last Modified On : Sat Jan 17 09:15:03 2015
+ * Update Count     : 318
  */
 
@@ -180,4 +180,6 @@
 
 	/* keywords */
+_Alignas		{ KEYWORD_RETURN(ALIGNAS); }	// C11
+_Alignof		{ KEYWORD_RETURN(ALIGNOF); }	// C11
 __alignof		{ KEYWORD_RETURN(ALIGNOF); }	// GCC
 __alignof__		{ KEYWORD_RETURN(ALIGNOF); }	// GCC
@@ -185,4 +187,5 @@
 __asm			{ KEYWORD_RETURN(ASM); }	// GCC
 __asm__			{ KEYWORD_RETURN(ASM); }	// GCC
+_Atomic			{ KEYWORD_RETURN(ATOMIC); }	// C11
 __attribute		{ KEYWORD_RETURN(ATTRIBUTE); }	// GCC
 __attribute__		{ KEYWORD_RETURN(ATTRIBUTE); }	// GCC
@@ -217,4 +220,5 @@
 fortran			{ KEYWORD_RETURN(FORTRAN); }
 ftype			{ KEYWORD_RETURN(FTYPE); }	// CFA
+_Generic		{ KEYWORD_RETURN(GENERIC); }	// C11
 goto			{ KEYWORD_RETURN(GOTO); }
 if			{ KEYWORD_RETURN(IF); }
@@ -229,4 +233,5 @@
 long			{ KEYWORD_RETURN(LONG); }
 lvalue			{ KEYWORD_RETURN(LVALUE); }	// CFA
+_Noreturn		{ KEYWORD_RETURN(NORETURN); }	// C11
 register		{ KEYWORD_RETURN(REGISTER); }
 restrict		{ KEYWORD_RETURN(RESTRICT); }	// C99
@@ -240,6 +245,8 @@
 sizeof			{ KEYWORD_RETURN(SIZEOF); }
 static			{ KEYWORD_RETURN(STATIC); }
+_Static_assert		{ KEYWORD_RETURN(STATICASSERT); } // C11
 struct			{ KEYWORD_RETURN(STRUCT); }
 switch			{ KEYWORD_RETURN(SWITCH); }
+_Thread_local		{ KEYWORD_RETURN(THREADLOCAL); } // C11
 throw			{ KEYWORD_RETURN(THROW); }	// CFA
 try			{ KEYWORD_RETURN(TRY); }	// CFA
