[TableGen] Format document

[• pcwang-thead]

Summary

Add missing bang operators and reorder them in alphabetical order.

[craig.topper]

LGTM

llvm/docs/TableGen/ProgRef.rst

 
 Bang operators
 --------------
 
 TableGen provides "bang operators" that have a wide variety of uses:
 
 .. productionlist::
    BangOperator: one of
-               : !add        !and         !cast        !con         !dag
-               : !div        !empty       !eq          !filter      !find
-               : !foldl      !foreach     !ge          !getdagop    !gt
-               : !head       !if          !interleave  !isa         !le
-               : !listconcat !listremove  !listsplat   !logtwo      !lt
-               : !mul        !ne          !not         !or          !setdagop
-               : !shl        !size        !sra         !srl         !strconcat
-               : !sub        !subst       !substr      !tail        !xor
+               : !add         !and         !cast        !con         !dag
+               : !div         !empty       !eq          !exists      !filter
+               : !find        !foldl       !foreach     !ge          !getdagop
+               : !gt          !head        !if          !interleave  !isa
+               : !le          !listconcat  !listremove  !listsplat   !logtwo
+               : !lt          !mul         !ne          !not         !or
+               : !setdagop    !shl         !size        !sra         !srl
+               : !strconcat   !sub         !subst       !substr      !tail
+               : !tolower     !toupper     !xor
 
 The ``!cond`` operator has a slightly different
 syntax compared to other bang operators, so it is defined separately:
 
 .. productionlist::
    CondOperator: !cond
 
 See `Appendix A: Bang Operators`_ for a description of each bang operator.

 ``!div(``\ *a*\ ``,`` *b*\ ``)``
     This operator preforms signed division of *a* by *b*, and produces the quotient.
     Division by 0 produces an error. Division of INT64_MIN by -1 produces an error.
 
 ``!empty(``\ *a*\ ``)``
     This operator produces 1 if the string, list, or DAG *a* is empty; 0 otherwise.
     A dag is empty if it has no arguments; the operator does not count.
 
-``!tolower(``\ *a*\ ``)``
-  This operator converts a string input *a* to lower case.
-
-``!toupper(``\ *a*\ ``)``
-  This operator converts a string input *a* to upper case.
-
 ``!eq(`` *a*\ `,` *b*\ ``)``
     This operator produces 1 if *a* is equal to *b*; 0 otherwise.
     The arguments must be ``bit``, ``bits``, ``int``, ``string``, or
     record values. Use ``!cast<string>`` to compare other types of objects.
 
+``!exists<``\ *type*\ ``>(``\ *name*\ ``)``
+    This operator produces 1 if a record of the given *type* whose name is *name*
+    exists; 0 otherwise. *name* should be of type *string*.
+
 ``!filter(``\ *var*\ ``,`` *list*\ ``,`` *predicate*\ ``)``
 
     This operator creates a new ``list`` by filtering the elements in
     *list*. To perform the filtering, TableGen binds the variable *var* to each
     element and then evaluates the *predicate* expression, which presumably
     refers to *var*. The predicate must
     produce a boolean value (``bit``, ``bits``, or ``int``). The value is
     interpreted as with ``!if``:
``!interleave(``\ *list*\ ``,`` *delim*\ ``)``
     *delim* string between each pair, and produces the resulting string.
     The list can be a list of string, int, bits, or bit. An empty list
     results in an empty string. The delimiter can be the empty string.
 
 ``!isa<``\ *type*\ ``>(``\ *a*\ ``)``
     This operator produces 1 if the type of *a* is a subtype of the given *type*; 0
     otherwise.
 
-``!exists<``\ *type*\ ``>(``\ *name*\ ``)``
-    This operator produces 1 if a record of the given *type* whose name is *name*
-    exists; 0 otherwise. *name* should be of type *string*.
-
 ``!le(``\ *a*\ ``,`` *b*\ ``)``
     This operator produces 1 if *a* is less than or equal to *b*; 0 otherwise.
     The arguments must be ``bit``, ``bits``, ``int``, or ``string`` values.
 
 ``!listconcat(``\ *list1*\ ``,`` *list2*\ ``, ...)``
     This operator concatenates the list arguments *list1*, *list2*, etc., and
     produces the resulting list. The lists must have the same element type.
 
``!substr(``\ *string*\ ``,`` *start*\ [``,`` *length*]\ ``)``
     between 0 and the length of the string. The length of the substring
     is specified by *length*; if not specified, the rest of the string is
     extracted. The *start* and *length* arguments must be integers.
 
 ``!tail(``\ *a*\ ``)``
     This operator produces a new list with all the elements
     of the list *a* except for the zeroth one. (See also ``!head``.)
 
+``!tolower(``\ *a*\ ``)``
+  This operator converts a string input *a* to lower case.
+
+``!toupper(``\ *a*\ ``)``
+  This operator converts a string input *a* to upper case.
+
 ``!xor(``\ *a*\ ``,`` *b*\ ``, ...)``
     This operator does a bitwise EXCLUSIVE OR on *a*, *b*, etc., and produces
     the result. A logical XOR can be performed if all the arguments are either
     0 or 1.
 
 Appendix B: Paste Operator Examples
 ===================================