first draft

Author: TylerMSFT

docs/c-language/c-primary-expressions.md

@@ -6,20 +6,20 @@ helpviewer_keywords: ["primary expressions"]
 ---
 # C primary expressions
 
-Primary expressions are the building blocks of more complex expressions. They may be constants, identifiers, and in C11, a [Generic selection](generic_selection.md) . An expression in parentheses is also a primary expression.
+Primary expressions are the building blocks of more complex expressions. They may be constants, identifiers, and in C11, a [Generic selection](generic_selection.md). An expression in parentheses is also a primary expression.
 
 ## Syntax
 
-*primary-expression*:\
-    *identifier*\
-    *constant*\
-    *string-literal*\
-    *_Generic(assignment expression, generic-assoc-list)*\
-    **(** *expression* **)**
+*`primary-expression`*:\
+    *`identifier`*\
+    *`constant`*\
+    *`string-literal`*\
+    **(** *`expression`* **)**\
+    *`generic-selection`*
 
 *expression*:\
-    *assignment-expression*\
-    *expression* **,** *assignment-expression*
+    *`assignment-expression`*\
+    *`expression`***,** *`assignment-expression`*
 
 ## See also
 

docs/c-language/generic_selection.md

@@ -7,27 +7,72 @@ helpviewer_keywords: ["_Generic keyword [C]"]
 
 # Generic Selection (C11)
 
-Use the _Generic keyword to select an expression at compile time, based on a type. 
+Use the **`_Generic`** keyword to write code that makes a compile time decision based on the type of the argument.
+
+**`_Generic`** selects an expression based on a type at compile time. It is somewhat similar to overloading in C++ where the type of the argument is used to select which function to call. In this case, the type of the argument selects which expression to evaluate.
+
+For example, the expression `_Generic(42, int:"integer", char:"character", default:"unknown");` evaluates the type of `42` and looks for the matching type, `int` in the list. It will find it and return `"integer"`.
+
+## Syntax
+
+*`generic-selection`*:\
+    **`_Generic`** **(** *`assignment-expression`, `assoc-list`* **)** 
+
+*`assoc-list`*:\
+    *`association`*\
+    *`assoc-list`, `association`*
+
+*`association`*:\
+    *`type-name`* : *`assignment-expression`*\
+    **`default`** : *`assignment-expression`*
+
+The first *`assignment-expression`* is called the controlling expression. The controlling expression is evaluated at compile time and matched against the *`assoc-list`* to find which expression to evaulate and return.
+
+When the controlling expression is evaluated, `const`,  `volatile`, and `restrict` are removed before matching against *`assoc-list`*.
+
+Entries in the `assoc-list` that are not chosen are not evaluated.
+
+## Constraints
+
+- The *`assoc-list`* can't specify the same type more than once.
+- The *`assoc-list`* can't specify types that are compatible with each other, such as an enumeration and the underlying type of that enumeration.
+- If a generic selection doesn't have a default, the controlling expression must have only one compatible type name in the generic association list.
+
+## Example
+
+One way to use **`_Generic`** is in a macro. The <tgmath.h> header file uses **_Generic** to call the right math function depending on the type of argument. For example, the macro for `cos()` maps a call with a float to `cosf()`, whereas a call with a complex double is mapped to `ccos()`.
+
+The following example shows how to write a macro that identifies the type of the argument you pass to it. It produces `"unknown"` if no entry in the *`assoc-list`* matches the controlling expression:
+
+```C
+// Compile with /std:c11
 
-```c
 #include <stdio.h>
-#include <stddef.h>
-#include <stdint.h>
-
-#define typename(x) _Generic((x),        /* Get the name of a type */             \
-                                                                                  \
-        _Bool: "_Bool",                  unsigned char: "unsigned char",          \
-         char: "char",                     signed char: "signed char",            \
-    short int: "short int",         unsigned short int: "unsigned short int",     \
-          int: "int",                     unsigned int: "unsigned int",           \
-     long int: "long int",           unsigned long int: "unsigned long int",      \
-long long int: "long long int", unsigned long long int: "unsigned long long int", \
-        float: "float",                         double: "double",                 \
-  long double: "long double",                   char *: "pointer to char",        \
-       void *: "pointer to void",                int *: "pointer to int",         \
-      default: "other")
+
+/* Get a type name string for the argument x */
+#define TYPE_NAME(X) _Generic((X), \
+           int: "int", \
+         char: "char", \
+      double: "double", \
+      default: "unknown")
+
+int main()
+{
+    printf("Type name: %s\n", TYPE_NAME(42.42));
+
+    // The following results in a compile error because 
+    // 42.4 is a double, doesn't match anything in the list, 
+    // and there is no default.
+    // _Generic(42.4, int:"integer", char : "character"));
+}
+
+/* Output:
+Type name: double
+*/
+
 ```
 
 ## See also
 
-[`/std` (Specify Language Standard Version)](../build/reference/std-specify-language-standard-version.md)\
+[`/std` (Specify Language Standard Version)](../build/reference/std-specify-language-standard-version.md)\
+[Type-generic math](../cpp/c-runtime-library/tgmath.md)