1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308230923102311231223132314231523162317231823192320232123222323232423252326232723282329233023312332233323342335233623372338233923402341234223432344234523462347234823492350235123522353235423552356235723582359236023612362236323642365236623672368236923702371237223732374237523762377237823792380238123822383238423852386238723882389239023912392239323942395239623972398239924002401240224032404240524062407240824092410241124122413241424152416241724182419242024212422242324242425242624272428242924302431243224332434243524362437243824392440244124422443244424452446244724482449245024512452245324542455245624572458245924602461246224632464246524662467246824692470247124722473247424752476247724782479248024812482248324842485248624872488248924902491249224932494249524962497249824992500250125022503250425052506250725082509251025112512251325142515251625172518251925202521252225232524252525262527252825292530253125322533253425352536253725382539254025412542254325442545254625472548254925502551255225532554255525562557255825592560256125622563256425652566256725682569257025712572257325742575257625772578257925802581258225832584258525862587258825892590259125922593259425952596259725982599260026012602260326042605260626072608260926102611261226132614261526162617261826192620262126222623262426252626262726282629263026312632263326342635263626372638263926402641264226432644264526462647264826492650265126522653265426552656265726582659266026612662266326642665266626672668266926702671267226732674267526762677267826792680268126822683268426852686268726882689269026912692269326942695269626972698269927002701270227032704270527062707270827092710271127122713271427152716271727182719272027212722272327242725272627272728272927302731273227332734273527362737273827392740274127422743274427452746274727482749275027512752275327542755275627572758275927602761276227632764276527662767276827692770277127722773277427752776277727782779278027812782278327842785278627872788278927902791279227932794279527962797279827992800280128022803280428052806280728082809281028112812281328142815281628172818281928202821282228232824282528262827282828292830283128322833283428352836283728382839284028412842284328442845284628472848284928502851285228532854285528562857285828592860286128622863286428652866286728682869287028712872287328742875287628772878287928802881288228832884288528862887288828892890289128922893289428952896289728982899290029012902290329042905290629072908290929102911291229132914291529162917291829192920292129222923292429252926292729282929293029312932293329342935293629372938293929402941294229432944294529462947294829492950295129522953295429552956295729582959296029612962296329642965296629672968296929702971297229732974297529762977297829792980298129822983298429852986298729882989299029912992299329942995299629972998299930003001300230033004300530063007300830093010301130123013301430153016301730183019302030213022302330243025302630273028302930303031303230333034303530363037303830393040304130423043304430453046304730483049305030513052305330543055305630573058305930603061306230633064306530663067306830693070307130723073307430753076307730783079308030813082308330843085308630873088308930903091309230933094309530963097309830993100310131023103310431053106310731083109311031113112311331143115311631173118311931203121312231233124312531263127312831293130313131323133313431353136313731383139314031413142314331443145314631473148314931503151315231533154315531563157315831593160316131623163316431653166316731683169317031713172317331743175317631773178317931803181318231833184318531863187318831893190319131923193319431953196319731983199320032013202320332043205320632073208320932103211321232133214321532163217321832193220322132223223322432253226322732283229323032313232323332343235323632373238323932403241324232433244324532463247324832493250325132523253325432553256325732583259326032613262326332643265326632673268326932703271327232733274327532763277327832793280328132823283328432853286328732883289329032913292329332943295329632973298329933003301330233033304330533063307330833093310331133123313331433153316331733183319332033213322332333243325332633273328332933303331333233333334333533363337333833393340334133423343334433453346334733483349335033513352335333543355335633573358335933603361336233633364336533663367336833693370337133723373337433753376337733783379338033813382338333843385338633873388338933903391339233933394339533963397339833993400340134023403340434053406340734083409341034113412341334143415341634173418341934203421342234233424342534263427342834293430343134323433343434353436343734383439344034413442344334443445344634473448344934503451345234533454345534563457345834593460346134623463346434653466346734683469347034713472347334743475347634773478347934803481348234833484348534863487348834893490349134923493349434953496349734983499350035013502350335043505350635073508350935103511351235133514351535163517351835193520352135223523352435253526352735283529353035313532353335343535353635373538353935403541354235433544354535463547354835493550355135523553355435553556355735583559356035613562356335643565356635673568356935703571357235733574357535763577357835793580358135823583358435853586358735883589359035913592359335943595359635973598359936003601360236033604360536063607360836093610361136123613361436153616361736183619362036213622362336243625362636273628362936303631363236333634363536363637363836393640364136423643364436453646364736483649365036513652365336543655365636573658365936603661366236633664366536663667366836693670367136723673367436753676367736783679368036813682368336843685368636873688368936903691369236933694369536963697369836993700370137023703370437053706370737083709371037113712371337143715371637173718371937203721372237233724372537263727372837293730373137323733373437353736373737383739374037413742374337443745374637473748374937503751375237533754375537563757375837593760376137623763376437653766376737683769377037713772377337743775377637773778377937803781378237833784378537863787378837893790379137923793379437953796379737983799380038013802380338043805380638073808380938103811381238133814381538163817381838193820382138223823382438253826382738283829383038313832383338343835383638373838383938403841384238433844384538463847384838493850385138523853385438553856385738583859386038613862386338643865386638673868386938703871387238733874387538763877387838793880388138823883388438853886388738883889389038913892389338943895389638973898389939003901390239033904390539063907390839093910391139123913391439153916391739183919392039213922392339243925392639273928392939303931393239333934393539363937393839393940394139423943394439453946394739483949395039513952395339543955395639573958395939603961396239633964396539663967396839693970397139723973397439753976397739783979398039813982398339843985398639873988398939903991399239933994399539963997399839994000400140024003400440054006400740084009401040114012401340144015401640174018401940204021402240234024402540264027402840294030403140324033403440354036403740384039404040414042404340444045404640474048404940504051405240534054405540564057405840594060406140624063406440654066406740684069407040714072407340744075407640774078407940804081408240834084408540864087408840894090409140924093409440954096409740984099410041014102410341044105410641074108410941104111411241134114411541164117411841194120412141224123412441254126412741284129413041314132413341344135413641374138413941404141414241434144414541464147414841494150415141524153415441554156415741584159416041614162416341644165416641674168416941704171417241734174417541764177417841794180418141824183418441854186418741884189419041914192419341944195419641974198419942004201420242034204420542064207420842094210421142124213421442154216421742184219422042214222422342244225422642274228422942304231423242334234423542364237423842394240424142424243424442454246424742484249425042514252425342544255425642574258425942604261426242634264426542664267426842694270427142724273427442754276427742784279428042814282428342844285428642874288428942904291 |
- #pragma once
- #ifdef __GNUC__
- #pragma GCC diagnostic push
- #pragma GCC diagnostic ignored "-Wunused-parameter"
- #endif
- //===--- Format.h - Format C++ code -----------------------------*- C++ -*-===//
- //
- // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
- // See https://llvm.org/LICENSE.txt for license information.
- // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
- //
- //===----------------------------------------------------------------------===//
- ///
- /// \file
- /// Various functions to configurably format source code.
- ///
- //===----------------------------------------------------------------------===//
- #ifndef LLVM_CLANG_FORMAT_FORMAT_H
- #define LLVM_CLANG_FORMAT_FORMAT_H
- #include "clang/Basic/LangOptions.h"
- #include "clang/Tooling/Core/Replacement.h"
- #include "clang/Tooling/Inclusions/IncludeStyle.h"
- #include "llvm/ADT/ArrayRef.h"
- #include "llvm/Support/Regex.h"
- #include "llvm/Support/SourceMgr.h"
- #include <system_error>
- namespace llvm {
- namespace vfs {
- class FileSystem;
- }
- } // namespace llvm
- namespace clang {
- namespace format {
- enum class ParseError {
- Success = 0,
- Error,
- Unsuitable,
- BinPackTrailingCommaConflict,
- InvalidQualifierSpecified,
- DuplicateQualifierSpecified,
- MissingQualifierType,
- MissingQualifierOrder
- };
- class ParseErrorCategory final : public std::error_category {
- public:
- const char *name() const noexcept override;
- std::string message(int EV) const override;
- };
- const std::error_category &getParseCategory();
- std::error_code make_error_code(ParseError e);
- /// The ``FormatStyle`` is used to configure the formatting to follow
- /// specific guidelines.
- struct FormatStyle {
- // If the BasedOn: was InheritParentConfig and this style needs the file from
- // the parent directories. It is not part of the actual style for formatting.
- // Thus the // instead of ///.
- bool InheritsParentConfig;
- /// The extra indent or outdent of access modifiers, e.g. ``public:``.
- /// \version 3.3
- int AccessModifierOffset;
- /// Different styles for aligning after open brackets.
- enum BracketAlignmentStyle : unsigned char {
- /// Align parameters on the open bracket, e.g.:
- /// \code
- /// someLongFunction(argument1,
- /// argument2);
- /// \endcode
- BAS_Align,
- /// Don't align, instead use ``ContinuationIndentWidth``, e.g.:
- /// \code
- /// someLongFunction(argument1,
- /// argument2);
- /// \endcode
- BAS_DontAlign,
- /// Always break after an open bracket, if the parameters don't fit
- /// on a single line, e.g.:
- /// \code
- /// someLongFunction(
- /// argument1, argument2);
- /// \endcode
- BAS_AlwaysBreak,
- /// Always break after an open bracket, if the parameters don't fit
- /// on a single line. Closing brackets will be placed on a new line.
- /// E.g.:
- /// \code
- /// someLongFunction(
- /// argument1, argument2
- /// )
- /// \endcode
- ///
- /// \warning
- /// Note: This currently only applies to parentheses.
- /// \endwarning
- BAS_BlockIndent,
- };
- /// If ``true``, horizontally aligns arguments after an open bracket.
- ///
- /// This applies to round brackets (parentheses), angle brackets and square
- /// brackets.
- /// \version 3.8
- BracketAlignmentStyle AlignAfterOpenBracket;
- /// Different style for aligning array initializers.
- enum ArrayInitializerAlignmentStyle {
- /// Align array column and left justify the columns e.g.:
- /// \code
- /// struct test demo[] =
- /// {
- /// {56, 23, "hello"},
- /// {-1, 93463, "world"},
- /// {7, 5, "!!" }
- /// };
- /// \endcode
- AIAS_Left,
- /// Align array column and right justify the columns e.g.:
- /// \code
- /// struct test demo[] =
- /// {
- /// {56, 23, "hello"},
- /// {-1, 93463, "world"},
- /// { 7, 5, "!!"}
- /// };
- /// \endcode
- AIAS_Right,
- /// Don't align array initializer columns.
- AIAS_None
- };
- /// if not ``None``, when using initialization for an array of structs
- /// aligns the fields into columns.
- /// \version 13
- ArrayInitializerAlignmentStyle AlignArrayOfStructures;
- /// Styles for alignment of consecutive tokens. Tokens can be assignment signs
- /// (see
- /// ``AlignConsecutiveAssignments``), bitfield member separators (see
- /// ``AlignConsecutiveBitFields``), names in declarations (see
- /// ``AlignConsecutiveDeclarations``) or macro definitions (see
- /// ``AlignConsecutiveMacros``).
- enum AlignConsecutiveStyle {
- ACS_None,
- ACS_Consecutive,
- ACS_AcrossEmptyLines,
- ACS_AcrossComments,
- ACS_AcrossEmptyLinesAndComments
- };
- /// Style of aligning consecutive macro definitions.
- ///
- /// ``Consecutive`` will result in formattings like:
- /// \code
- /// #define SHORT_NAME 42
- /// #define LONGER_NAME 0x007f
- /// #define EVEN_LONGER_NAME (2)
- /// #define foo(x) (x * x)
- /// #define bar(y, z) (y + z)
- /// \endcode
- ///
- /// Possible values:
- ///
- /// * ``ACS_None`` (in configuration: ``None``)
- /// Do not align macro definitions on consecutive lines.
- ///
- /// * ``ACS_Consecutive`` (in configuration: ``Consecutive``)
- /// Align macro definitions on consecutive lines. This will result in
- /// formattings like:
- /// \code
- /// #define SHORT_NAME 42
- /// #define LONGER_NAME 0x007f
- /// #define EVEN_LONGER_NAME (2)
- ///
- /// #define foo(x) (x * x)
- /// /* some comment */
- /// #define bar(y, z) (y + z)
- /// \endcode
- ///
- /// * ``ACS_AcrossEmptyLines`` (in configuration: ``AcrossEmptyLines``)
- /// Same as ACS_Consecutive, but also spans over empty lines, e.g.
- /// \code
- /// #define SHORT_NAME 42
- /// #define LONGER_NAME 0x007f
- /// #define EVEN_LONGER_NAME (2)
- ///
- /// #define foo(x) (x * x)
- /// /* some comment */
- /// #define bar(y, z) (y + z)
- /// \endcode
- ///
- /// * ``ACS_AcrossComments`` (in configuration: ``AcrossComments``)
- /// Same as ACS_Consecutive, but also spans over lines only containing
- /// comments, e.g.
- /// \code
- /// #define SHORT_NAME 42
- /// #define LONGER_NAME 0x007f
- /// #define EVEN_LONGER_NAME (2)
- ///
- /// #define foo(x) (x * x)
- /// /* some comment */
- /// #define bar(y, z) (y + z)
- /// \endcode
- ///
- /// * ``ACS_AcrossEmptyLinesAndComments``
- /// (in configuration: ``AcrossEmptyLinesAndComments``)
- ///
- /// Same as ACS_Consecutive, but also spans over lines only containing
- /// comments and empty lines, e.g.
- /// \code
- /// #define SHORT_NAME 42
- /// #define LONGER_NAME 0x007f
- /// #define EVEN_LONGER_NAME (2)
- ///
- /// #define foo(x) (x * x)
- /// /* some comment */
- /// #define bar(y, z) (y + z)
- /// \endcode
- /// \version 9
- AlignConsecutiveStyle AlignConsecutiveMacros;
- /// Style of aligning consecutive assignments.
- ///
- /// ``Consecutive`` will result in formattings like:
- /// \code
- /// int a = 1;
- /// int somelongname = 2;
- /// double c = 3;
- /// \endcode
- ///
- /// Possible values:
- ///
- /// * ``ACS_None`` (in configuration: ``None``)
- /// Do not align assignments on consecutive lines.
- ///
- /// * ``ACS_Consecutive`` (in configuration: ``Consecutive``)
- /// Align assignments on consecutive lines. This will result in
- /// formattings like:
- /// \code
- /// int a = 1;
- /// int somelongname = 2;
- /// double c = 3;
- ///
- /// int d = 3;
- /// /* A comment. */
- /// double e = 4;
- /// \endcode
- ///
- /// * ``ACS_AcrossEmptyLines`` (in configuration: ``AcrossEmptyLines``)
- /// Same as ACS_Consecutive, but also spans over empty lines, e.g.
- /// \code
- /// int a = 1;
- /// int somelongname = 2;
- /// double c = 3;
- ///
- /// int d = 3;
- /// /* A comment. */
- /// double e = 4;
- /// \endcode
- ///
- /// * ``ACS_AcrossComments`` (in configuration: ``AcrossComments``)
- /// Same as ACS_Consecutive, but also spans over lines only containing
- /// comments, e.g.
- /// \code
- /// int a = 1;
- /// int somelongname = 2;
- /// double c = 3;
- ///
- /// int d = 3;
- /// /* A comment. */
- /// double e = 4;
- /// \endcode
- ///
- /// * ``ACS_AcrossEmptyLinesAndComments``
- /// (in configuration: ``AcrossEmptyLinesAndComments``)
- ///
- /// Same as ACS_Consecutive, but also spans over lines only containing
- /// comments and empty lines, e.g.
- /// \code
- /// int a = 1;
- /// int somelongname = 2;
- /// double c = 3;
- ///
- /// int d = 3;
- /// /* A comment. */
- /// double e = 4;
- /// \endcode
- /// \version 3.8
- AlignConsecutiveStyle AlignConsecutiveAssignments;
- /// Style of aligning consecutive bit field.
- ///
- /// ``Consecutive`` will align the bitfield separators of consecutive lines.
- /// This will result in formattings like:
- /// \code
- /// int aaaa : 1;
- /// int b : 12;
- /// int ccc : 8;
- /// \endcode
- ///
- /// Possible values:
- ///
- /// * ``ACS_None`` (in configuration: ``None``)
- /// Do not align bit fields on consecutive lines.
- ///
- /// * ``ACS_Consecutive`` (in configuration: ``Consecutive``)
- /// Align bit fields on consecutive lines. This will result in
- /// formattings like:
- /// \code
- /// int aaaa : 1;
- /// int b : 12;
- /// int ccc : 8;
- ///
- /// int d : 2;
- /// /* A comment. */
- /// int ee : 3;
- /// \endcode
- ///
- /// * ``ACS_AcrossEmptyLines`` (in configuration: ``AcrossEmptyLines``)
- /// Same as ACS_Consecutive, but also spans over empty lines, e.g.
- /// \code
- /// int aaaa : 1;
- /// int b : 12;
- /// int ccc : 8;
- ///
- /// int d : 2;
- /// /* A comment. */
- /// int ee : 3;
- /// \endcode
- ///
- /// * ``ACS_AcrossComments`` (in configuration: ``AcrossComments``)
- /// Same as ACS_Consecutive, but also spans over lines only containing
- /// comments, e.g.
- /// \code
- /// int aaaa : 1;
- /// int b : 12;
- /// int ccc : 8;
- ///
- /// int d : 2;
- /// /* A comment. */
- /// int ee : 3;
- /// \endcode
- ///
- /// * ``ACS_AcrossEmptyLinesAndComments``
- /// (in configuration: ``AcrossEmptyLinesAndComments``)
- ///
- /// Same as ACS_Consecutive, but also spans over lines only containing
- /// comments and empty lines, e.g.
- /// \code
- /// int aaaa : 1;
- /// int b : 12;
- /// int ccc : 8;
- ///
- /// int d : 2;
- /// /* A comment. */
- /// int ee : 3;
- /// \endcode
- /// \version 11
- AlignConsecutiveStyle AlignConsecutiveBitFields;
- /// Style of aligning consecutive declarations.
- ///
- /// ``Consecutive`` will align the declaration names of consecutive lines.
- /// This will result in formattings like:
- /// \code
- /// int aaaa = 12;
- /// float b = 23;
- /// std::string ccc;
- /// \endcode
- ///
- /// Possible values:
- ///
- /// * ``ACS_None`` (in configuration: ``None``)
- /// Do not align bit declarations on consecutive lines.
- ///
- /// * ``ACS_Consecutive`` (in configuration: ``Consecutive``)
- /// Align declarations on consecutive lines. This will result in
- /// formattings like:
- /// \code
- /// int aaaa = 12;
- /// float b = 23;
- /// std::string ccc;
- ///
- /// int a = 42;
- /// /* A comment. */
- /// bool c = false;
- /// \endcode
- ///
- /// * ``ACS_AcrossEmptyLines`` (in configuration: ``AcrossEmptyLines``)
- /// Same as ACS_Consecutive, but also spans over empty lines, e.g.
- /// \code
- /// int aaaa = 12;
- /// float b = 23;
- /// std::string ccc;
- ///
- /// int a = 42;
- /// /* A comment. */
- /// bool c = false;
- /// \endcode
- ///
- /// * ``ACS_AcrossComments`` (in configuration: ``AcrossComments``)
- /// Same as ACS_Consecutive, but also spans over lines only containing
- /// comments, e.g.
- /// \code
- /// int aaaa = 12;
- /// float b = 23;
- /// std::string ccc;
- ///
- /// int a = 42;
- /// /* A comment. */
- /// bool c = false;
- /// \endcode
- ///
- /// * ``ACS_AcrossEmptyLinesAndComments``
- /// (in configuration: ``AcrossEmptyLinesAndComments``)
- ///
- /// Same as ACS_Consecutive, but also spans over lines only containing
- /// comments and empty lines, e.g.
- /// \code
- /// int aaaa = 12;
- /// float b = 23;
- /// std::string ccc;
- ///
- /// int a = 42;
- /// /* A comment. */
- /// bool c = false;
- /// \endcode
- /// \version 3.8
- AlignConsecutiveStyle AlignConsecutiveDeclarations;
- /// Different styles for aligning escaped newlines.
- enum EscapedNewlineAlignmentStyle : unsigned char {
- /// Don't align escaped newlines.
- /// \code
- /// #define A \
- /// int aaaa; \
- /// int b; \
- /// int dddddddddd;
- /// \endcode
- ENAS_DontAlign,
- /// Align escaped newlines as far left as possible.
- /// \code
- /// true:
- /// #define A \
- /// int aaaa; \
- /// int b; \
- /// int dddddddddd;
- ///
- /// false:
- /// \endcode
- ENAS_Left,
- /// Align escaped newlines in the right-most column.
- /// \code
- /// #define A \
- /// int aaaa; \
- /// int b; \
- /// int dddddddddd;
- /// \endcode
- ENAS_Right,
- };
- /// Options for aligning backslashes in escaped newlines.
- /// \version 5
- EscapedNewlineAlignmentStyle AlignEscapedNewlines;
- /// Different styles for aligning operands.
- enum OperandAlignmentStyle : unsigned char {
- /// Do not align operands of binary and ternary expressions.
- /// The wrapped lines are indented ``ContinuationIndentWidth`` spaces from
- /// the start of the line.
- OAS_DontAlign,
- /// Horizontally align operands of binary and ternary expressions.
- ///
- /// Specifically, this aligns operands of a single expression that needs
- /// to be split over multiple lines, e.g.:
- /// \code
- /// int aaa = bbbbbbbbbbbbbbb +
- /// ccccccccccccccc;
- /// \endcode
- ///
- /// When ``BreakBeforeBinaryOperators`` is set, the wrapped operator is
- /// aligned with the operand on the first line.
- /// \code
- /// int aaa = bbbbbbbbbbbbbbb
- /// + ccccccccccccccc;
- /// \endcode
- OAS_Align,
- /// Horizontally align operands of binary and ternary expressions.
- ///
- /// This is similar to ``AO_Align``, except when
- /// ``BreakBeforeBinaryOperators`` is set, the operator is un-indented so
- /// that the wrapped operand is aligned with the operand on the first line.
- /// \code
- /// int aaa = bbbbbbbbbbbbbbb
- /// + ccccccccccccccc;
- /// \endcode
- OAS_AlignAfterOperator,
- };
- /// If ``true``, horizontally align operands of binary and ternary
- /// expressions.
- /// \version 12
- OperandAlignmentStyle AlignOperands;
- /// If ``true``, aligns trailing comments.
- /// \code
- /// true: false:
- /// int a; // My comment a vs. int a; // My comment a
- /// int b = 2; // comment b int b = 2; // comment about b
- /// \endcode
- /// \version 3.7
- bool AlignTrailingComments;
- /// \brief If a function call or braced initializer list doesn't fit on a
- /// line, allow putting all arguments onto the next line, even if
- /// ``BinPackArguments`` is ``false``.
- /// \code
- /// true:
- /// callFunction(
- /// a, b, c, d);
- ///
- /// false:
- /// callFunction(a,
- /// b,
- /// c,
- /// d);
- /// \endcode
- /// \version 9
- bool AllowAllArgumentsOnNextLine;
- /// This option is **deprecated**. See ``NextLine`` of
- /// ``PackConstructorInitializers``.
- /// \version 9
- bool AllowAllConstructorInitializersOnNextLine;
- /// If the function declaration doesn't fit on a line,
- /// allow putting all parameters of a function declaration onto
- /// the next line even if ``BinPackParameters`` is ``false``.
- /// \code
- /// true:
- /// void myFunction(
- /// int a, int b, int c, int d, int e);
- ///
- /// false:
- /// void myFunction(int a,
- /// int b,
- /// int c,
- /// int d,
- /// int e);
- /// \endcode
- /// \version 3.3
- bool AllowAllParametersOfDeclarationOnNextLine;
- /// Allow short enums on a single line.
- /// \code
- /// true:
- /// enum { A, B } myEnum;
- ///
- /// false:
- /// enum {
- /// A,
- /// B
- /// } myEnum;
- /// \endcode
- /// \version 12
- bool AllowShortEnumsOnASingleLine;
- /// Different styles for merging short blocks containing at most one
- /// statement.
- enum ShortBlockStyle : unsigned char {
- /// Never merge blocks into a single line.
- /// \code
- /// while (true) {
- /// }
- /// while (true) {
- /// continue;
- /// }
- /// \endcode
- SBS_Never,
- /// Only merge empty blocks.
- /// \code
- /// while (true) {}
- /// while (true) {
- /// continue;
- /// }
- /// \endcode
- SBS_Empty,
- /// Always merge short blocks into a single line.
- /// \code
- /// while (true) {}
- /// while (true) { continue; }
- /// \endcode
- SBS_Always,
- };
- /// Dependent on the value, ``while (true) { continue; }`` can be put on a
- /// single line.
- /// \version 11
- ShortBlockStyle AllowShortBlocksOnASingleLine;
- /// If ``true``, short case labels will be contracted to a single line.
- /// \code
- /// true: false:
- /// switch (a) { vs. switch (a) {
- /// case 1: x = 1; break; case 1:
- /// case 2: return; x = 1;
- /// } break;
- /// case 2:
- /// return;
- /// }
- /// \endcode
- /// \version 3.6
- bool AllowShortCaseLabelsOnASingleLine;
- /// Different styles for merging short functions containing at most one
- /// statement.
- enum ShortFunctionStyle : unsigned char {
- /// Never merge functions into a single line.
- SFS_None,
- /// Only merge functions defined inside a class. Same as "inline",
- /// except it does not implies "empty": i.e. top level empty functions
- /// are not merged either.
- /// \code
- /// class Foo {
- /// void f() { foo(); }
- /// };
- /// void f() {
- /// foo();
- /// }
- /// void f() {
- /// }
- /// \endcode
- SFS_InlineOnly,
- /// Only merge empty functions.
- /// \code
- /// void f() {}
- /// void f2() {
- /// bar2();
- /// }
- /// \endcode
- SFS_Empty,
- /// Only merge functions defined inside a class. Implies "empty".
- /// \code
- /// class Foo {
- /// void f() { foo(); }
- /// };
- /// void f() {
- /// foo();
- /// }
- /// void f() {}
- /// \endcode
- SFS_Inline,
- /// Merge all functions fitting on a single line.
- /// \code
- /// class Foo {
- /// void f() { foo(); }
- /// };
- /// void f() { bar(); }
- /// \endcode
- SFS_All,
- };
- /// Dependent on the value, ``int f() { return 0; }`` can be put on a
- /// single line.
- /// \version 3.5
- ShortFunctionStyle AllowShortFunctionsOnASingleLine;
- /// Different styles for handling short if statements.
- enum ShortIfStyle : unsigned char {
- /// Never put short ifs on the same line.
- /// \code
- /// if (a)
- /// return;
- ///
- /// if (b)
- /// return;
- /// else
- /// return;
- ///
- /// if (c)
- /// return;
- /// else {
- /// return;
- /// }
- /// \endcode
- SIS_Never,
- /// Put short ifs on the same line only if there is no else statement.
- /// \code
- /// if (a) return;
- ///
- /// if (b)
- /// return;
- /// else
- /// return;
- ///
- /// if (c)
- /// return;
- /// else {
- /// return;
- /// }
- /// \endcode
- SIS_WithoutElse,
- /// Put short ifs, but not else ifs nor else statements, on the same line.
- /// \code
- /// if (a) return;
- ///
- /// if (b) return;
- /// else if (b)
- /// return;
- /// else
- /// return;
- ///
- /// if (c) return;
- /// else {
- /// return;
- /// }
- /// \endcode
- SIS_OnlyFirstIf,
- /// Always put short ifs, else ifs and else statements on the same
- /// line.
- /// \code
- /// if (a) return;
- ///
- /// if (b) return;
- /// else return;
- ///
- /// if (c) return;
- /// else {
- /// return;
- /// }
- /// \endcode
- SIS_AllIfsAndElse,
- };
- /// Dependent on the value, ``if (a) return;`` can be put on a single line.
- /// \version 9
- ShortIfStyle AllowShortIfStatementsOnASingleLine;
- /// Different styles for merging short lambdas containing at most one
- /// statement.
- enum ShortLambdaStyle : unsigned char {
- /// Never merge lambdas into a single line.
- SLS_None,
- /// Only merge empty lambdas.
- /// \code
- /// auto lambda = [](int a) {}
- /// auto lambda2 = [](int a) {
- /// return a;
- /// };
- /// \endcode
- SLS_Empty,
- /// Merge lambda into a single line if argument of a function.
- /// \code
- /// auto lambda = [](int a) {
- /// return a;
- /// };
- /// sort(a.begin(), a.end(), ()[] { return x < y; })
- /// \endcode
- SLS_Inline,
- /// Merge all lambdas fitting on a single line.
- /// \code
- /// auto lambda = [](int a) {}
- /// auto lambda2 = [](int a) { return a; };
- /// \endcode
- SLS_All,
- };
- /// Dependent on the value, ``auto lambda []() { return 0; }`` can be put on a
- /// single line.
- /// \version 9
- ShortLambdaStyle AllowShortLambdasOnASingleLine;
- /// If ``true``, ``while (true) continue;`` can be put on a single
- /// line.
- /// \version 3.7
- bool AllowShortLoopsOnASingleLine;
- /// Different ways to break after the function definition return type.
- /// This option is **deprecated** and is retained for backwards compatibility.
- enum DefinitionReturnTypeBreakingStyle : unsigned char {
- /// Break after return type automatically.
- /// ``PenaltyReturnTypeOnItsOwnLine`` is taken into account.
- DRTBS_None,
- /// Always break after the return type.
- DRTBS_All,
- /// Always break after the return types of top-level functions.
- DRTBS_TopLevel,
- };
- /// Different ways to break after the function definition or
- /// declaration return type.
- enum ReturnTypeBreakingStyle : unsigned char {
- /// Break after return type automatically.
- /// ``PenaltyReturnTypeOnItsOwnLine`` is taken into account.
- /// \code
- /// class A {
- /// int f() { return 0; };
- /// };
- /// int f();
- /// int f() { return 1; }
- /// \endcode
- RTBS_None,
- /// Always break after the return type.
- /// \code
- /// class A {
- /// int
- /// f() {
- /// return 0;
- /// };
- /// };
- /// int
- /// f();
- /// int
- /// f() {
- /// return 1;
- /// }
- /// \endcode
- RTBS_All,
- /// Always break after the return types of top-level functions.
- /// \code
- /// class A {
- /// int f() { return 0; };
- /// };
- /// int
- /// f();
- /// int
- /// f() {
- /// return 1;
- /// }
- /// \endcode
- RTBS_TopLevel,
- /// Always break after the return type of function definitions.
- /// \code
- /// class A {
- /// int
- /// f() {
- /// return 0;
- /// };
- /// };
- /// int f();
- /// int
- /// f() {
- /// return 1;
- /// }
- /// \endcode
- RTBS_AllDefinitions,
- /// Always break after the return type of top-level definitions.
- /// \code
- /// class A {
- /// int f() { return 0; };
- /// };
- /// int f();
- /// int
- /// f() {
- /// return 1;
- /// }
- /// \endcode
- RTBS_TopLevelDefinitions,
- };
- /// The function definition return type breaking style to use. This
- /// option is **deprecated** and is retained for backwards compatibility.
- /// \version 3.7
- DefinitionReturnTypeBreakingStyle AlwaysBreakAfterDefinitionReturnType;
- /// The function declaration return type breaking style to use.
- /// \version 3.8
- ReturnTypeBreakingStyle AlwaysBreakAfterReturnType;
- /// If ``true``, always break before multiline string literals.
- ///
- /// This flag is mean to make cases where there are multiple multiline strings
- /// in a file look more consistent. Thus, it will only take effect if wrapping
- /// the string at that point leads to it being indented
- /// ``ContinuationIndentWidth`` spaces from the start of the line.
- /// \code
- /// true: false:
- /// aaaa = vs. aaaa = "bbbb"
- /// "bbbb" "cccc";
- /// "cccc";
- /// \endcode
- /// \version 3.4
- bool AlwaysBreakBeforeMultilineStrings;
- /// Different ways to break after the template declaration.
- enum BreakTemplateDeclarationsStyle : unsigned char {
- /// Do not force break before declaration.
- /// ``PenaltyBreakTemplateDeclaration`` is taken into account.
- /// \code
- /// template <typename T> T foo() {
- /// }
- /// template <typename T> T foo(int aaaaaaaaaaaaaaaaaaaaa,
- /// int bbbbbbbbbbbbbbbbbbbbb) {
- /// }
- /// \endcode
- BTDS_No,
- /// Force break after template declaration only when the following
- /// declaration spans multiple lines.
- /// \code
- /// template <typename T> T foo() {
- /// }
- /// template <typename T>
- /// T foo(int aaaaaaaaaaaaaaaaaaaaa,
- /// int bbbbbbbbbbbbbbbbbbbbb) {
- /// }
- /// \endcode
- BTDS_MultiLine,
- /// Always break after template declaration.
- /// \code
- /// template <typename T>
- /// T foo() {
- /// }
- /// template <typename T>
- /// T foo(int aaaaaaaaaaaaaaaaaaaaa,
- /// int bbbbbbbbbbbbbbbbbbbbb) {
- /// }
- /// \endcode
- BTDS_Yes
- };
- /// The template declaration breaking style to use.
- /// \version 7
- BreakTemplateDeclarationsStyle AlwaysBreakTemplateDeclarations;
- /// A vector of strings that should be interpreted as attributes/qualifiers
- /// instead of identifiers. This can be useful for language extensions or
- /// static analyzer annotations.
- ///
- /// For example:
- /// \code
- /// x = (char *__capability)&y;
- /// int function(void) __ununsed;
- /// void only_writes_to_buffer(char *__output buffer);
- /// \endcode
- ///
- /// In the .clang-format configuration file, this can be configured like:
- /// \code{.yaml}
- /// AttributeMacros: ['__capability', '__output', '__ununsed']
- /// \endcode
- ///
- /// \version 12
- std::vector<std::string> AttributeMacros;
- /// If ``false``, a function call's arguments will either be all on the
- /// same line or will have one line each.
- /// \code
- /// true:
- /// void f() {
- /// f(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa,
- /// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);
- /// }
- ///
- /// false:
- /// void f() {
- /// f(aaaaaaaaaaaaaaaaaaaa,
- /// aaaaaaaaaaaaaaaaaaaa,
- /// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);
- /// }
- /// \endcode
- /// \version 3.7
- bool BinPackArguments;
- /// The style of inserting trailing commas into container literals.
- enum TrailingCommaStyle : unsigned char {
- /// Do not insert trailing commas.
- TCS_None,
- /// Insert trailing commas in container literals that were wrapped over
- /// multiple lines. Note that this is conceptually incompatible with
- /// bin-packing, because the trailing comma is used as an indicator
- /// that a container should be formatted one-per-line (i.e. not bin-packed).
- /// So inserting a trailing comma counteracts bin-packing.
- TCS_Wrapped,
- };
- /// If set to ``TCS_Wrapped`` will insert trailing commas in container
- /// literals (arrays and objects) that wrap across multiple lines.
- /// It is currently only available for JavaScript
- /// and disabled by default ``TCS_None``.
- /// ``InsertTrailingCommas`` cannot be used together with ``BinPackArguments``
- /// as inserting the comma disables bin-packing.
- /// \code
- /// TSC_Wrapped:
- /// const someArray = [
- /// aaaaaaaaaaaaaaaaaaaaaaaaaa,
- /// aaaaaaaaaaaaaaaaaaaaaaaaaa,
- /// aaaaaaaaaaaaaaaaaaaaaaaaaa,
- /// // ^ inserted
- /// ]
- /// \endcode
- /// \version 12
- TrailingCommaStyle InsertTrailingCommas;
- /// If ``false``, a function declaration's or function definition's
- /// parameters will either all be on the same line or will have one line each.
- /// \code
- /// true:
- /// void f(int aaaaaaaaaaaaaaaaaaaa, int aaaaaaaaaaaaaaaaaaaa,
- /// int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}
- ///
- /// false:
- /// void f(int aaaaaaaaaaaaaaaaaaaa,
- /// int aaaaaaaaaaaaaaaaaaaa,
- /// int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}
- /// \endcode
- /// \version 3.7
- bool BinPackParameters;
- /// The style of wrapping parameters on the same line (bin-packed) or
- /// on one line each.
- enum BinPackStyle : unsigned char {
- /// Automatically determine parameter bin-packing behavior.
- BPS_Auto,
- /// Always bin-pack parameters.
- BPS_Always,
- /// Never bin-pack parameters.
- BPS_Never,
- };
- /// The style of breaking before or after binary operators.
- enum BinaryOperatorStyle : unsigned char {
- /// Break after operators.
- /// \code
- /// LooooooooooongType loooooooooooooooooooooongVariable =
- /// someLooooooooooooooooongFunction();
- ///
- /// bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +
- /// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==
- /// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa &&
- /// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >
- /// ccccccccccccccccccccccccccccccccccccccccc;
- /// \endcode
- BOS_None,
- /// Break before operators that aren't assignments.
- /// \code
- /// LooooooooooongType loooooooooooooooooooooongVariable =
- /// someLooooooooooooooooongFunction();
- ///
- /// bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
- /// + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
- /// == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
- /// && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
- /// > ccccccccccccccccccccccccccccccccccccccccc;
- /// \endcode
- BOS_NonAssignment,
- /// Break before operators.
- /// \code
- /// LooooooooooongType loooooooooooooooooooooongVariable
- /// = someLooooooooooooooooongFunction();
- ///
- /// bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
- /// + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
- /// == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
- /// && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
- /// > ccccccccccccccccccccccccccccccccccccccccc;
- /// \endcode
- BOS_All,
- };
- /// The way to wrap binary operators.
- /// \version 3.6
- BinaryOperatorStyle BreakBeforeBinaryOperators;
- /// Different ways to attach braces to their surrounding context.
- enum BraceBreakingStyle : unsigned char {
- /// Always attach braces to surrounding context.
- /// \code
- /// namespace N {
- /// enum E {
- /// E1,
- /// E2,
- /// };
- ///
- /// class C {
- /// public:
- /// C();
- /// };
- ///
- /// bool baz(int i) {
- /// try {
- /// do {
- /// switch (i) {
- /// case 1: {
- /// foobar();
- /// break;
- /// }
- /// default: {
- /// break;
- /// }
- /// }
- /// } while (--i);
- /// return true;
- /// } catch (...) {
- /// handleError();
- /// return false;
- /// }
- /// }
- ///
- /// void foo(bool b) {
- /// if (b) {
- /// baz(2);
- /// } else {
- /// baz(5);
- /// }
- /// }
- ///
- /// void bar() { foo(true); }
- /// } // namespace N
- /// \endcode
- BS_Attach,
- /// Like ``Attach``, but break before braces on function, namespace and
- /// class definitions.
- /// \code
- /// namespace N
- /// {
- /// enum E {
- /// E1,
- /// E2,
- /// };
- ///
- /// class C
- /// {
- /// public:
- /// C();
- /// };
- ///
- /// bool baz(int i)
- /// {
- /// try {
- /// do {
- /// switch (i) {
- /// case 1: {
- /// foobar();
- /// break;
- /// }
- /// default: {
- /// break;
- /// }
- /// }
- /// } while (--i);
- /// return true;
- /// } catch (...) {
- /// handleError();
- /// return false;
- /// }
- /// }
- ///
- /// void foo(bool b)
- /// {
- /// if (b) {
- /// baz(2);
- /// } else {
- /// baz(5);
- /// }
- /// }
- ///
- /// void bar() { foo(true); }
- /// } // namespace N
- /// \endcode
- BS_Linux,
- /// Like ``Attach``, but break before braces on enum, function, and record
- /// definitions.
- /// \code
- /// namespace N {
- /// enum E
- /// {
- /// E1,
- /// E2,
- /// };
- ///
- /// class C
- /// {
- /// public:
- /// C();
- /// };
- ///
- /// bool baz(int i)
- /// {
- /// try {
- /// do {
- /// switch (i) {
- /// case 1: {
- /// foobar();
- /// break;
- /// }
- /// default: {
- /// break;
- /// }
- /// }
- /// } while (--i);
- /// return true;
- /// } catch (...) {
- /// handleError();
- /// return false;
- /// }
- /// }
- ///
- /// void foo(bool b)
- /// {
- /// if (b) {
- /// baz(2);
- /// } else {
- /// baz(5);
- /// }
- /// }
- ///
- /// void bar() { foo(true); }
- /// } // namespace N
- /// \endcode
- BS_Mozilla,
- /// Like ``Attach``, but break before function definitions, ``catch``, and
- /// ``else``.
- /// \code
- /// namespace N {
- /// enum E {
- /// E1,
- /// E2,
- /// };
- ///
- /// class C {
- /// public:
- /// C();
- /// };
- ///
- /// bool baz(int i)
- /// {
- /// try {
- /// do {
- /// switch (i) {
- /// case 1: {
- /// foobar();
- /// break;
- /// }
- /// default: {
- /// break;
- /// }
- /// }
- /// } while (--i);
- /// return true;
- /// }
- /// catch (...) {
- /// handleError();
- /// return false;
- /// }
- /// }
- ///
- /// void foo(bool b)
- /// {
- /// if (b) {
- /// baz(2);
- /// }
- /// else {
- /// baz(5);
- /// }
- /// }
- ///
- /// void bar() { foo(true); }
- /// } // namespace N
- /// \endcode
- BS_Stroustrup,
- /// Always break before braces.
- /// \code
- /// namespace N
- /// {
- /// enum E
- /// {
- /// E1,
- /// E2,
- /// };
- ///
- /// class C
- /// {
- /// public:
- /// C();
- /// };
- ///
- /// bool baz(int i)
- /// {
- /// try
- /// {
- /// do
- /// {
- /// switch (i)
- /// {
- /// case 1:
- /// {
- /// foobar();
- /// break;
- /// }
- /// default:
- /// {
- /// break;
- /// }
- /// }
- /// } while (--i);
- /// return true;
- /// }
- /// catch (...)
- /// {
- /// handleError();
- /// return false;
- /// }
- /// }
- ///
- /// void foo(bool b)
- /// {
- /// if (b)
- /// {
- /// baz(2);
- /// }
- /// else
- /// {
- /// baz(5);
- /// }
- /// }
- ///
- /// void bar() { foo(true); }
- /// } // namespace N
- /// \endcode
- BS_Allman,
- /// Like ``Allman`` but always indent braces and line up code with braces.
- /// \code
- /// namespace N
- /// {
- /// enum E
- /// {
- /// E1,
- /// E2,
- /// };
- ///
- /// class C
- /// {
- /// public:
- /// C();
- /// };
- ///
- /// bool baz(int i)
- /// {
- /// try
- /// {
- /// do
- /// {
- /// switch (i)
- /// {
- /// case 1:
- /// {
- /// foobar();
- /// break;
- /// }
- /// default:
- /// {
- /// break;
- /// }
- /// }
- /// } while (--i);
- /// return true;
- /// }
- /// catch (...)
- /// {
- /// handleError();
- /// return false;
- /// }
- /// }
- ///
- /// void foo(bool b)
- /// {
- /// if (b)
- /// {
- /// baz(2);
- /// }
- /// else
- /// {
- /// baz(5);
- /// }
- /// }
- ///
- /// void bar() { foo(true); }
- /// } // namespace N
- /// \endcode
- BS_Whitesmiths,
- /// Always break before braces and add an extra level of indentation to
- /// braces of control statements, not to those of class, function
- /// or other definitions.
- /// \code
- /// namespace N
- /// {
- /// enum E
- /// {
- /// E1,
- /// E2,
- /// };
- ///
- /// class C
- /// {
- /// public:
- /// C();
- /// };
- ///
- /// bool baz(int i)
- /// {
- /// try
- /// {
- /// do
- /// {
- /// switch (i)
- /// {
- /// case 1:
- /// {
- /// foobar();
- /// break;
- /// }
- /// default:
- /// {
- /// break;
- /// }
- /// }
- /// }
- /// while (--i);
- /// return true;
- /// }
- /// catch (...)
- /// {
- /// handleError();
- /// return false;
- /// }
- /// }
- ///
- /// void foo(bool b)
- /// {
- /// if (b)
- /// {
- /// baz(2);
- /// }
- /// else
- /// {
- /// baz(5);
- /// }
- /// }
- ///
- /// void bar() { foo(true); }
- /// } // namespace N
- /// \endcode
- BS_GNU,
- /// Like ``Attach``, but break before functions.
- /// \code
- /// namespace N {
- /// enum E {
- /// E1,
- /// E2,
- /// };
- ///
- /// class C {
- /// public:
- /// C();
- /// };
- ///
- /// bool baz(int i)
- /// {
- /// try {
- /// do {
- /// switch (i) {
- /// case 1: {
- /// foobar();
- /// break;
- /// }
- /// default: {
- /// break;
- /// }
- /// }
- /// } while (--i);
- /// return true;
- /// } catch (...) {
- /// handleError();
- /// return false;
- /// }
- /// }
- ///
- /// void foo(bool b)
- /// {
- /// if (b) {
- /// baz(2);
- /// } else {
- /// baz(5);
- /// }
- /// }
- ///
- /// void bar() { foo(true); }
- /// } // namespace N
- /// \endcode
- BS_WebKit,
- /// Configure each individual brace in `BraceWrapping`.
- BS_Custom
- };
- /// The brace breaking style to use.
- /// \version 3.7
- BraceBreakingStyle BreakBeforeBraces;
- /// Different ways to wrap braces after control statements.
- enum BraceWrappingAfterControlStatementStyle : unsigned char {
- /// Never wrap braces after a control statement.
- /// \code
- /// if (foo()) {
- /// } else {
- /// }
- /// for (int i = 0; i < 10; ++i) {
- /// }
- /// \endcode
- BWACS_Never,
- /// Only wrap braces after a multi-line control statement.
- /// \code
- /// if (foo && bar &&
- /// baz)
- /// {
- /// quux();
- /// }
- /// while (foo || bar) {
- /// }
- /// \endcode
- BWACS_MultiLine,
- /// Always wrap braces after a control statement.
- /// \code
- /// if (foo())
- /// {
- /// } else
- /// {}
- /// for (int i = 0; i < 10; ++i)
- /// {}
- /// \endcode
- BWACS_Always
- };
- /// Precise control over the wrapping of braces.
- /// \code
- /// # Should be declared this way:
- /// BreakBeforeBraces: Custom
- /// BraceWrapping:
- /// AfterClass: true
- /// \endcode
- struct BraceWrappingFlags {
- /// Wrap case labels.
- /// \code
- /// false: true:
- /// switch (foo) { vs. switch (foo) {
- /// case 1: { case 1:
- /// bar(); {
- /// break; bar();
- /// } break;
- /// default: { }
- /// plop(); default:
- /// } {
- /// } plop();
- /// }
- /// }
- /// \endcode
- bool AfterCaseLabel;
- /// Wrap class definitions.
- /// \code
- /// true:
- /// class foo {};
- ///
- /// false:
- /// class foo
- /// {};
- /// \endcode
- bool AfterClass;
- /// Wrap control statements (``if``/``for``/``while``/``switch``/..).
- BraceWrappingAfterControlStatementStyle AfterControlStatement;
- /// Wrap enum definitions.
- /// \code
- /// true:
- /// enum X : int
- /// {
- /// B
- /// };
- ///
- /// false:
- /// enum X : int { B };
- /// \endcode
- bool AfterEnum;
- /// Wrap function definitions.
- /// \code
- /// true:
- /// void foo()
- /// {
- /// bar();
- /// bar2();
- /// }
- ///
- /// false:
- /// void foo() {
- /// bar();
- /// bar2();
- /// }
- /// \endcode
- bool AfterFunction;
- /// Wrap namespace definitions.
- /// \code
- /// true:
- /// namespace
- /// {
- /// int foo();
- /// int bar();
- /// }
- ///
- /// false:
- /// namespace {
- /// int foo();
- /// int bar();
- /// }
- /// \endcode
- bool AfterNamespace;
- /// Wrap ObjC definitions (interfaces, implementations...).
- /// \note @autoreleasepool and @synchronized blocks are wrapped
- /// according to `AfterControlStatement` flag.
- bool AfterObjCDeclaration;
- /// Wrap struct definitions.
- /// \code
- /// true:
- /// struct foo
- /// {
- /// int x;
- /// };
- ///
- /// false:
- /// struct foo {
- /// int x;
- /// };
- /// \endcode
- bool AfterStruct;
- /// Wrap union definitions.
- /// \code
- /// true:
- /// union foo
- /// {
- /// int x;
- /// }
- ///
- /// false:
- /// union foo {
- /// int x;
- /// }
- /// \endcode
- bool AfterUnion;
- /// Wrap extern blocks.
- /// \code
- /// true:
- /// extern "C"
- /// {
- /// int foo();
- /// }
- ///
- /// false:
- /// extern "C" {
- /// int foo();
- /// }
- /// \endcode
- bool AfterExternBlock; // Partially superseded by IndentExternBlock
- /// Wrap before ``catch``.
- /// \code
- /// true:
- /// try {
- /// foo();
- /// }
- /// catch () {
- /// }
- ///
- /// false:
- /// try {
- /// foo();
- /// } catch () {
- /// }
- /// \endcode
- bool BeforeCatch;
- /// Wrap before ``else``.
- /// \code
- /// true:
- /// if (foo()) {
- /// }
- /// else {
- /// }
- ///
- /// false:
- /// if (foo()) {
- /// } else {
- /// }
- /// \endcode
- bool BeforeElse;
- /// Wrap lambda block.
- /// \code
- /// true:
- /// connect(
- /// []()
- /// {
- /// foo();
- /// bar();
- /// });
- ///
- /// false:
- /// connect([]() {
- /// foo();
- /// bar();
- /// });
- /// \endcode
- bool BeforeLambdaBody;
- /// Wrap before ``while``.
- /// \code
- /// true:
- /// do {
- /// foo();
- /// }
- /// while (1);
- ///
- /// false:
- /// do {
- /// foo();
- /// } while (1);
- /// \endcode
- bool BeforeWhile;
- /// Indent the wrapped braces themselves.
- bool IndentBraces;
- /// If ``false``, empty function body can be put on a single line.
- /// This option is used only if the opening brace of the function has
- /// already been wrapped, i.e. the `AfterFunction` brace wrapping mode is
- /// set, and the function could/should not be put on a single line (as per
- /// `AllowShortFunctionsOnASingleLine` and constructor formatting options).
- /// \code
- /// int f() vs. int f()
- /// {} {
- /// }
- /// \endcode
- ///
- bool SplitEmptyFunction;
- /// If ``false``, empty record (e.g. class, struct or union) body
- /// can be put on a single line. This option is used only if the opening
- /// brace of the record has already been wrapped, i.e. the `AfterClass`
- /// (for classes) brace wrapping mode is set.
- /// \code
- /// class Foo vs. class Foo
- /// {} {
- /// }
- /// \endcode
- ///
- bool SplitEmptyRecord;
- /// If ``false``, empty namespace body can be put on a single line.
- /// This option is used only if the opening brace of the namespace has
- /// already been wrapped, i.e. the `AfterNamespace` brace wrapping mode is
- /// set.
- /// \code
- /// namespace Foo vs. namespace Foo
- /// {} {
- /// }
- /// \endcode
- ///
- bool SplitEmptyNamespace;
- };
- /// Control of individual brace wrapping cases.
- ///
- /// If ``BreakBeforeBraces`` is set to ``BS_Custom``, use this to specify how
- /// each individual brace case should be handled. Otherwise, this is ignored.
- /// \code{.yaml}
- /// # Example of usage:
- /// BreakBeforeBraces: Custom
- /// BraceWrapping:
- /// AfterEnum: true
- /// AfterStruct: false
- /// SplitEmptyFunction: false
- /// \endcode
- /// \version 3.8
- BraceWrappingFlags BraceWrapping;
- /// If ``true``, concept will be placed on a new line.
- /// \code
- /// true:
- /// template<typename T>
- /// concept ...
- ///
- /// false:
- /// template<typename T> concept ...
- /// \endcode
- /// \version 13
- bool BreakBeforeConceptDeclarations;
- /// If ``true``, ternary operators will be placed after line breaks.
- /// \code
- /// true:
- /// veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongDescription
- /// ? firstValue
- /// : SecondValueVeryVeryVeryVeryLong;
- ///
- /// false:
- /// veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongDescription ?
- /// firstValue :
- /// SecondValueVeryVeryVeryVeryLong;
- /// \endcode
- /// \version 3.7
- bool BreakBeforeTernaryOperators;
- /// Different ways to break initializers.
- enum BreakConstructorInitializersStyle : unsigned char {
- /// Break constructor initializers before the colon and after the commas.
- /// \code
- /// Constructor()
- /// : initializer1(),
- /// initializer2()
- /// \endcode
- BCIS_BeforeColon,
- /// Break constructor initializers before the colon and commas, and align
- /// the commas with the colon.
- /// \code
- /// Constructor()
- /// : initializer1()
- /// , initializer2()
- /// \endcode
- BCIS_BeforeComma,
- /// Break constructor initializers after the colon and commas.
- /// \code
- /// Constructor() :
- /// initializer1(),
- /// initializer2()
- /// \endcode
- BCIS_AfterColon
- };
- /// The break constructor initializers style to use.
- /// \version 5
- BreakConstructorInitializersStyle BreakConstructorInitializers;
- /// Break after each annotation on a field in Java files.
- /// \code{.java}
- /// true: false:
- /// @Partial vs. @Partial @Mock DataLoad loader;
- /// @Mock
- /// DataLoad loader;
- /// \endcode
- /// \version 3.8
- bool BreakAfterJavaFieldAnnotations;
- /// Allow breaking string literals when formatting.
- /// \code
- /// true:
- /// const char* x = "veryVeryVeryVeryVeryVe"
- /// "ryVeryVeryVeryVeryVery"
- /// "VeryLongString";
- ///
- /// false:
- /// const char* x =
- /// "veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongString";
- /// \endcode
- /// \version 3.9
- bool BreakStringLiterals;
- /// The column limit.
- ///
- /// A column limit of ``0`` means that there is no column limit. In this case,
- /// clang-format will respect the input's line breaking decisions within
- /// statements unless they contradict other rules.
- /// \version 3.7
- unsigned ColumnLimit;
- /// A regular expression that describes comments with special meaning,
- /// which should not be split into lines or otherwise changed.
- /// \code
- /// // CommentPragmas: '^ FOOBAR pragma:'
- /// // Will leave the following line unaffected
- /// #include <vector> // FOOBAR pragma: keep
- /// \endcode
- /// \version 3.7
- std::string CommentPragmas;
- /// Different specifiers and qualifiers alignment styles.
- enum QualifierAlignmentStyle {
- /// Don't change specifiers/qualifiers to either Left or Right alignment
- /// (default).
- /// \code
- /// int const a;
- /// const int *a;
- /// \endcode
- QAS_Leave,
- /// Change specifiers/qualifiers to be left-aligned.
- /// \code
- /// const int a;
- /// const int *a;
- /// \endcode
- QAS_Left,
- /// Change specifiers/qualifiers to be right-aligned.
- /// \code
- /// int const a;
- /// int const *a;
- /// \endcode
- QAS_Right,
- /// Change specifiers/qualifiers to be aligned based on ``QualifierOrder``.
- /// With:
- /// \code{.yaml}
- /// QualifierOrder: ['inline', 'static' , 'type', 'const']
- /// \endcode
- ///
- /// \code
- ///
- /// int const a;
- /// int const *a;
- /// \endcode
- QAS_Custom
- };
- /// Different ways to arrange specifiers and qualifiers (e.g. const/volatile).
- /// \warning
- /// Setting ``QualifierAlignment`` to something other than `Leave`, COULD
- /// lead to incorrect code formatting due to incorrect decisions made due to
- /// clang-formats lack of complete semantic information.
- /// As such extra care should be taken to review code changes made by the use
- /// of this option.
- /// \endwarning
- /// \version 14
- QualifierAlignmentStyle QualifierAlignment;
- /// The order in which the qualifiers appear.
- /// Order is an array that can contain any of the following:
- ///
- /// * const
- /// * inline
- /// * static
- /// * constexpr
- /// * volatile
- /// * restrict
- /// * type
- ///
- /// Note: it MUST contain 'type'.
- /// Items to the left of 'type' will be placed to the left of the type and
- /// aligned in the order supplied. Items to the right of 'type' will be placed
- /// to the right of the type and aligned in the order supplied.
- ///
- /// \code{.yaml}
- /// QualifierOrder: ['inline', 'static', 'type', 'const', 'volatile' ]
- /// \endcode
- /// \version 14
- std::vector<std::string> QualifierOrder;
- /// Different ways to break inheritance list.
- enum BreakInheritanceListStyle : unsigned char {
- /// Break inheritance list before the colon and after the commas.
- /// \code
- /// class Foo
- /// : Base1,
- /// Base2
- /// {};
- /// \endcode
- BILS_BeforeColon,
- /// Break inheritance list before the colon and commas, and align
- /// the commas with the colon.
- /// \code
- /// class Foo
- /// : Base1
- /// , Base2
- /// {};
- /// \endcode
- BILS_BeforeComma,
- /// Break inheritance list after the colon and commas.
- /// \code
- /// class Foo :
- /// Base1,
- /// Base2
- /// {};
- /// \endcode
- BILS_AfterColon,
- /// Break inheritance list only after the commas.
- /// \code
- /// class Foo : Base1,
- /// Base2
- /// {};
- /// \endcode
- BILS_AfterComma,
- };
- /// The inheritance list style to use.
- /// \version 7
- BreakInheritanceListStyle BreakInheritanceList;
- /// If ``true``, consecutive namespace declarations will be on the same
- /// line. If ``false``, each namespace is declared on a new line.
- /// \code
- /// true:
- /// namespace Foo { namespace Bar {
- /// }}
- ///
- /// false:
- /// namespace Foo {
- /// namespace Bar {
- /// }
- /// }
- /// \endcode
- ///
- /// If it does not fit on a single line, the overflowing namespaces get
- /// wrapped:
- /// \code
- /// namespace Foo { namespace Bar {
- /// namespace Extra {
- /// }}}
- /// \endcode
- /// \version 5
- bool CompactNamespaces;
- /// This option is **deprecated**. See ``CurrentLine`` of
- /// ``PackConstructorInitializers``.
- /// \version 3.7
- bool ConstructorInitializerAllOnOneLineOrOnePerLine;
- /// The number of characters to use for indentation of constructor
- /// initializer lists as well as inheritance lists.
- /// \version 3.7
- unsigned ConstructorInitializerIndentWidth;
- /// Indent width for line continuations.
- /// \code
- /// ContinuationIndentWidth: 2
- ///
- /// int i = // VeryVeryVeryVeryVeryLongComment
- /// longFunction( // Again a long comment
- /// arg);
- /// \endcode
- /// \version 3.7
- unsigned ContinuationIndentWidth;
- /// If ``true``, format braced lists as best suited for C++11 braced
- /// lists.
- ///
- /// Important differences:
- /// - No spaces inside the braced list.
- /// - No line break before the closing brace.
- /// - Indentation with the continuation indent, not with the block indent.
- ///
- /// Fundamentally, C++11 braced lists are formatted exactly like function
- /// calls would be formatted in their place. If the braced list follows a name
- /// (e.g. a type or variable name), clang-format formats as if the ``{}`` were
- /// the parentheses of a function call with that name. If there is no name,
- /// a zero-length name is assumed.
- /// \code
- /// true: false:
- /// vector<int> x{1, 2, 3, 4}; vs. vector<int> x{ 1, 2, 3, 4 };
- /// vector<T> x{{}, {}, {}, {}}; vector<T> x{ {}, {}, {}, {} };
- /// f(MyMap[{composite, key}]); f(MyMap[{ composite, key }]);
- /// new int[3]{1, 2, 3}; new int[3]{ 1, 2, 3 };
- /// \endcode
- /// \version 3.4
- bool Cpp11BracedListStyle;
- /// \brief Analyze the formatted file for the most used line ending (``\r\n``
- /// or ``\n``). ``UseCRLF`` is only used as a fallback if none can be derived.
- /// \version 11
- bool DeriveLineEnding;
- /// If ``true``, analyze the formatted file for the most common
- /// alignment of ``&`` and ``*``.
- /// Pointer and reference alignment styles are going to be updated according
- /// to the preferences found in the file.
- /// ``PointerAlignment`` is then used only as fallback.
- /// \version 3.7
- bool DerivePointerAlignment;
- /// Disables formatting completely.
- /// \version 3.7
- bool DisableFormat;
- /// Different styles for empty line after access modifiers.
- /// ``EmptyLineBeforeAccessModifier`` configuration handles the number of
- /// empty lines between two access modifiers.
- enum EmptyLineAfterAccessModifierStyle : unsigned char {
- /// Remove all empty lines after access modifiers.
- /// \code
- /// struct foo {
- /// private:
- /// int i;
- /// protected:
- /// int j;
- /// /* comment */
- /// public:
- /// foo() {}
- /// private:
- /// protected:
- /// };
- /// \endcode
- ELAAMS_Never,
- /// Keep existing empty lines after access modifiers.
- /// MaxEmptyLinesToKeep is applied instead.
- ELAAMS_Leave,
- /// Always add empty line after access modifiers if there are none.
- /// MaxEmptyLinesToKeep is applied also.
- /// \code
- /// struct foo {
- /// private:
- ///
- /// int i;
- /// protected:
- ///
- /// int j;
- /// /* comment */
- /// public:
- ///
- /// foo() {}
- /// private:
- ///
- /// protected:
- ///
- /// };
- /// \endcode
- ELAAMS_Always,
- };
- /// Defines when to put an empty line after access modifiers.
- /// ``EmptyLineBeforeAccessModifier`` configuration handles the number of
- /// empty lines between two access modifiers.
- /// \version 14
- EmptyLineAfterAccessModifierStyle EmptyLineAfterAccessModifier;
- /// Different styles for empty line before access modifiers.
- enum EmptyLineBeforeAccessModifierStyle : unsigned char {
- /// Remove all empty lines before access modifiers.
- /// \code
- /// struct foo {
- /// private:
- /// int i;
- /// protected:
- /// int j;
- /// /* comment */
- /// public:
- /// foo() {}
- /// private:
- /// protected:
- /// };
- /// \endcode
- ELBAMS_Never,
- /// Keep existing empty lines before access modifiers.
- ELBAMS_Leave,
- /// Add empty line only when access modifier starts a new logical block.
- /// Logical block is a group of one or more member fields or functions.
- /// \code
- /// struct foo {
- /// private:
- /// int i;
- ///
- /// protected:
- /// int j;
- /// /* comment */
- /// public:
- /// foo() {}
- ///
- /// private:
- /// protected:
- /// };
- /// \endcode
- ELBAMS_LogicalBlock,
- /// Always add empty line before access modifiers unless access modifier
- /// is at the start of struct or class definition.
- /// \code
- /// struct foo {
- /// private:
- /// int i;
- ///
- /// protected:
- /// int j;
- /// /* comment */
- ///
- /// public:
- /// foo() {}
- ///
- /// private:
- ///
- /// protected:
- /// };
- /// \endcode
- ELBAMS_Always,
- };
- /// Defines in which cases to put empty line before access modifiers.
- /// \version 13
- EmptyLineBeforeAccessModifierStyle EmptyLineBeforeAccessModifier;
- /// If ``true``, clang-format detects whether function calls and
- /// definitions are formatted with one parameter per line.
- ///
- /// Each call can be bin-packed, one-per-line or inconclusive. If it is
- /// inconclusive, e.g. completely on one line, but a decision needs to be
- /// made, clang-format analyzes whether there are other bin-packed cases in
- /// the input file and act accordingly.
- ///
- /// NOTE: This is an experimental flag, that might go away or be renamed. Do
- /// not use this in config files, etc. Use at your own risk.
- /// \version 3.7
- bool ExperimentalAutoDetectBinPacking;
- /// Different ways to try to fit all constructor initializers on a line.
- enum PackConstructorInitializersStyle : unsigned char {
- /// Always put each constructor initializer on its own line.
- /// \code
- /// Constructor()
- /// : a(),
- /// b()
- /// \endcode
- PCIS_Never,
- /// Bin-pack constructor initializers.
- /// \code
- /// Constructor()
- /// : aaaaaaaaaaaaaaaaaaaa(), bbbbbbbbbbbbbbbbbbbb(),
- /// cccccccccccccccccccc()
- /// \endcode
- PCIS_BinPack,
- /// Put all constructor initializers on the current line if they fit.
- /// Otherwise, put each one on its own line.
- /// \code
- /// Constructor() : a(), b()
- ///
- /// Constructor()
- /// : aaaaaaaaaaaaaaaaaaaa(),
- /// bbbbbbbbbbbbbbbbbbbb(),
- /// ddddddddddddd()
- /// \endcode
- PCIS_CurrentLine,
- /// Same as ``PCIS_CurrentLine`` except that if all constructor initializers
- /// do not fit on the current line, try to fit them on the next line.
- /// \code
- /// Constructor() : a(), b()
- ///
- /// Constructor()
- /// : aaaaaaaaaaaaaaaaaaaa(), bbbbbbbbbbbbbbbbbbbb(), ddddddddddddd()
- ///
- /// Constructor()
- /// : aaaaaaaaaaaaaaaaaaaa(),
- /// bbbbbbbbbbbbbbbbbbbb(),
- /// cccccccccccccccccccc()
- /// \endcode
- PCIS_NextLine,
- };
- /// The pack constructor initializers style to use.
- /// \version 14;
- PackConstructorInitializersStyle PackConstructorInitializers;
- /// If ``true``, clang-format adds missing namespace end comments for
- /// short namespaces and fixes invalid existing ones. Short ones are
- /// controlled by "ShortNamespaceLines".
- /// \code
- /// true: false:
- /// namespace a { vs. namespace a {
- /// foo(); foo();
- /// bar(); bar();
- /// } // namespace a }
- /// \endcode
- /// \version 5
- bool FixNamespaceComments;
- /// A vector of macros that should be interpreted as foreach loops
- /// instead of as function calls.
- ///
- /// These are expected to be macros of the form:
- /// \code
- /// FOREACH(<variable-declaration>, ...)
- /// <loop-body>
- /// \endcode
- ///
- /// In the .clang-format configuration file, this can be configured like:
- /// \code{.yaml}
- /// ForEachMacros: ['RANGES_FOR', 'FOREACH']
- /// \endcode
- ///
- /// For example: BOOST_FOREACH.
- /// \version 3.7
- std::vector<std::string> ForEachMacros;
- /// A vector of macros that should be interpreted as conditionals
- /// instead of as function calls.
- ///
- /// These are expected to be macros of the form:
- /// \code
- /// IF(...)
- /// <conditional-body>
- /// else IF(...)
- /// <conditional-body>
- /// \endcode
- ///
- /// In the .clang-format configuration file, this can be configured like:
- /// \code{.yaml}
- /// IfMacros: ['IF']
- /// \endcode
- ///
- /// For example: `KJ_IF_MAYBE
- /// <https://github.com/capnproto/capnproto/blob/master/kjdoc/tour.md#maybes>`_
- /// \version 14
- std::vector<std::string> IfMacros;
- /// \brief A vector of macros that should be interpreted as type declarations
- /// instead of as function calls.
- ///
- /// These are expected to be macros of the form:
- /// \code
- /// STACK_OF(...)
- /// \endcode
- ///
- /// In the .clang-format configuration file, this can be configured like:
- /// \code{.yaml}
- /// TypenameMacros: ['STACK_OF', 'LIST']
- /// \endcode
- ///
- /// For example: OpenSSL STACK_OF, BSD LIST_ENTRY.
- /// \version 9
- std::vector<std::string> TypenameMacros;
- /// A vector of macros that should be interpreted as complete
- /// statements.
- ///
- /// Typical macros are expressions, and require a semi-colon to be
- /// added; sometimes this is not the case, and this allows to make
- /// clang-format aware of such cases.
- ///
- /// For example: Q_UNUSED
- /// \version 8
- std::vector<std::string> StatementMacros;
- /// A vector of macros which are used to open namespace blocks.
- ///
- /// These are expected to be macros of the form:
- /// \code
- /// NAMESPACE(<namespace-name>, ...) {
- /// <namespace-content>
- /// }
- /// \endcode
- ///
- /// For example: TESTSUITE
- /// \version 9
- std::vector<std::string> NamespaceMacros;
- /// A vector of macros which are whitespace-sensitive and should not
- /// be touched.
- ///
- /// These are expected to be macros of the form:
- /// \code
- /// STRINGIZE(...)
- /// \endcode
- ///
- /// In the .clang-format configuration file, this can be configured like:
- /// \code{.yaml}
- /// WhitespaceSensitiveMacros: ['STRINGIZE', 'PP_STRINGIZE']
- /// \endcode
- ///
- /// For example: BOOST_PP_STRINGIZE
- /// \version 12
- std::vector<std::string> WhitespaceSensitiveMacros;
- tooling::IncludeStyle IncludeStyle;
- /// Specify whether access modifiers should have their own indentation level.
- ///
- /// When ``false``, access modifiers are indented (or outdented) relative to
- /// the record members, respecting the ``AccessModifierOffset``. Record
- /// members are indented one level below the record.
- /// When ``true``, access modifiers get their own indentation level. As a
- /// consequence, record members are always indented 2 levels below the record,
- /// regardless of the access modifier presence. Value of the
- /// ``AccessModifierOffset`` is ignored.
- /// \code
- /// false: true:
- /// class C { vs. class C {
- /// class D { class D {
- /// void bar(); void bar();
- /// protected: protected:
- /// D(); D();
- /// }; };
- /// public: public:
- /// C(); C();
- /// }; };
- /// void foo() { void foo() {
- /// return 1; return 1;
- /// } }
- /// \endcode
- /// \version 13
- bool IndentAccessModifiers;
- /// Indent case labels one level from the switch statement.
- ///
- /// When ``false``, use the same indentation level as for the switch
- /// statement. Switch statement body is always indented one level more than
- /// case labels (except the first block following the case label, which
- /// itself indents the code - unless IndentCaseBlocks is enabled).
- /// \code
- /// false: true:
- /// switch (fool) { vs. switch (fool) {
- /// case 1: case 1:
- /// bar(); bar();
- /// break; break;
- /// default: default:
- /// plop(); plop();
- /// } }
- /// \endcode
- /// \version 3.3
- bool IndentCaseLabels;
- /// Indent case label blocks one level from the case label.
- ///
- /// When ``false``, the block following the case label uses the same
- /// indentation level as for the case label, treating the case label the same
- /// as an if-statement.
- /// When ``true``, the block gets indented as a scope block.
- /// \code
- /// false: true:
- /// switch (fool) { vs. switch (fool) {
- /// case 1: { case 1:
- /// bar(); {
- /// } break; bar();
- /// default: { }
- /// plop(); break;
- /// } default:
- /// } {
- /// plop();
- /// }
- /// }
- /// \endcode
- /// \version 11
- bool IndentCaseBlocks;
- /// Indent goto labels.
- ///
- /// When ``false``, goto labels are flushed left.
- /// \code
- /// true: false:
- /// int f() { vs. int f() {
- /// if (foo()) { if (foo()) {
- /// label1: label1:
- /// bar(); bar();
- /// } }
- /// label2: label2:
- /// return 1; return 1;
- /// } }
- /// \endcode
- /// \version 10
- bool IndentGotoLabels;
- /// Options for indenting preprocessor directives.
- enum PPDirectiveIndentStyle : unsigned char {
- /// Does not indent any directives.
- /// \code
- /// #if FOO
- /// #if BAR
- /// #include <foo>
- /// #endif
- /// #endif
- /// \endcode
- PPDIS_None,
- /// Indents directives after the hash.
- /// \code
- /// #if FOO
- /// # if BAR
- /// # include <foo>
- /// # endif
- /// #endif
- /// \endcode
- PPDIS_AfterHash,
- /// Indents directives before the hash.
- /// \code
- /// #if FOO
- /// #if BAR
- /// #include <foo>
- /// #endif
- /// #endif
- /// \endcode
- PPDIS_BeforeHash
- };
- /// The preprocessor directive indenting style to use.
- /// \version 6
- PPDirectiveIndentStyle IndentPPDirectives;
- /// Indents extern blocks
- enum IndentExternBlockStyle : unsigned char {
- /// Backwards compatible with AfterExternBlock's indenting.
- /// \code
- /// IndentExternBlock: AfterExternBlock
- /// BraceWrapping.AfterExternBlock: true
- /// extern "C"
- /// {
- /// void foo();
- /// }
- /// \endcode
- ///
- /// \code
- /// IndentExternBlock: AfterExternBlock
- /// BraceWrapping.AfterExternBlock: false
- /// extern "C" {
- /// void foo();
- /// }
- /// \endcode
- IEBS_AfterExternBlock,
- /// Does not indent extern blocks.
- /// \code
- /// extern "C" {
- /// void foo();
- /// }
- /// \endcode
- IEBS_NoIndent,
- /// Indents extern blocks.
- /// \code
- /// extern "C" {
- /// void foo();
- /// }
- /// \endcode
- IEBS_Indent,
- };
- /// IndentExternBlockStyle is the type of indenting of extern blocks.
- /// \version 12
- IndentExternBlockStyle IndentExternBlock;
- /// Indent the requires clause in a template
- /// \code
- /// true:
- /// template <typename It>
- /// requires Iterator<It>
- /// void sort(It begin, It end) {
- /// //....
- /// }
- ///
- /// false:
- /// template <typename It>
- /// requires Iterator<It>
- /// void sort(It begin, It end) {
- /// //....
- /// }
- /// \endcode
- /// \version 13
- bool IndentRequires;
- /// The number of columns to use for indentation.
- /// \code
- /// IndentWidth: 3
- ///
- /// void f() {
- /// someFunction();
- /// if (true, false) {
- /// f();
- /// }
- /// }
- /// \endcode
- /// \version 3.7
- unsigned IndentWidth;
- /// Indent if a function definition or declaration is wrapped after the
- /// type.
- /// \code
- /// true:
- /// LoooooooooooooooooooooooooooooooooooooooongReturnType
- /// LoooooooooooooooooooooooooooooooongFunctionDeclaration();
- ///
- /// false:
- /// LoooooooooooooooooooooooooooooooooooooooongReturnType
- /// LoooooooooooooooooooooooooooooooongFunctionDeclaration();
- /// \endcode
- /// \version 3.7
- bool IndentWrappedFunctionNames;
- /// A vector of prefixes ordered by the desired groups for Java imports.
- ///
- /// One group's prefix can be a subset of another - the longest prefix is
- /// always matched. Within a group, the imports are ordered lexicographically.
- /// Static imports are grouped separately and follow the same group rules.
- /// By default, static imports are placed before non-static imports,
- /// but this behavior is changed by another option,
- /// ``SortJavaStaticImport``.
- ///
- /// In the .clang-format configuration file, this can be configured like
- /// in the following yaml example. This will result in imports being
- /// formatted as in the Java example below.
- /// \code{.yaml}
- /// JavaImportGroups: ['com.example', 'com', 'org']
- /// \endcode
- ///
- /// \code{.java}
- /// import static com.example.function1;
- ///
- /// import static com.test.function2;
- ///
- /// import static org.example.function3;
- ///
- /// import com.example.ClassA;
- /// import com.example.Test;
- /// import com.example.a.ClassB;
- ///
- /// import com.test.ClassC;
- ///
- /// import org.example.ClassD;
- /// \endcode
- /// \version 8
- std::vector<std::string> JavaImportGroups;
- /// Quotation styles for JavaScript strings. Does not affect template
- /// strings.
- enum JavaScriptQuoteStyle : unsigned char {
- /// Leave string quotes as they are.
- /// \code{.js}
- /// string1 = "foo";
- /// string2 = 'bar';
- /// \endcode
- JSQS_Leave,
- /// Always use single quotes.
- /// \code{.js}
- /// string1 = 'foo';
- /// string2 = 'bar';
- /// \endcode
- JSQS_Single,
- /// Always use double quotes.
- /// \code{.js}
- /// string1 = "foo";
- /// string2 = "bar";
- /// \endcode
- JSQS_Double
- };
- /// The JavaScriptQuoteStyle to use for JavaScript strings.
- /// \version 3.9
- JavaScriptQuoteStyle JavaScriptQuotes;
- // clang-format off
- /// Whether to wrap JavaScript import/export statements.
- /// \code{.js}
- /// true:
- /// import {
- /// VeryLongImportsAreAnnoying,
- /// VeryLongImportsAreAnnoying,
- /// VeryLongImportsAreAnnoying,
- /// } from 'some/module.js'
- ///
- /// false:
- /// import {VeryLongImportsAreAnnoying, VeryLongImportsAreAnnoying, VeryLongImportsAreAnnoying,} from "some/module.js"
- /// \endcode
- /// \version 3.9
- bool JavaScriptWrapImports;
- // clang-format on
- /// If true, the empty line at the start of blocks is kept.
- /// \code
- /// true: false:
- /// if (foo) { vs. if (foo) {
- /// bar();
- /// bar(); }
- /// }
- /// \endcode
- /// \version 3.7
- bool KeepEmptyLinesAtTheStartOfBlocks;
- /// Supported languages.
- ///
- /// When stored in a configuration file, specifies the language, that the
- /// configuration targets. When passed to the ``reformat()`` function, enables
- /// syntax features specific to the language.
- enum LanguageKind : unsigned char {
- /// Do not use.
- LK_None,
- /// Should be used for C, C++.
- LK_Cpp,
- /// Should be used for C#.
- LK_CSharp,
- /// Should be used for Java.
- LK_Java,
- /// Should be used for JavaScript.
- LK_JavaScript,
- /// Should be used for JSON.
- LK_Json,
- /// Should be used for Objective-C, Objective-C++.
- LK_ObjC,
- /// Should be used for Protocol Buffers
- /// (https://developers.google.com/protocol-buffers/).
- LK_Proto,
- /// Should be used for TableGen code.
- LK_TableGen,
- /// Should be used for Protocol Buffer messages in text format
- /// (https://developers.google.com/protocol-buffers/).
- LK_TextProto
- };
- bool isCpp() const { return Language == LK_Cpp || Language == LK_ObjC; }
- bool isCSharp() const { return Language == LK_CSharp; }
- bool isJson() const { return Language == LK_Json; }
- bool isJavaScript() const { return Language == LK_JavaScript; }
- /// Language, this format style is targeted at.
- /// \version 3.5
- LanguageKind Language;
- /// Indentation logic for lambda bodies.
- enum LambdaBodyIndentationKind : unsigned char {
- /// Align lambda body relative to the lambda signature. This is the default.
- /// \code
- /// someMethod(
- /// [](SomeReallyLongLambdaSignatureArgument foo) {
- /// return;
- /// });
- /// \endcode
- LBI_Signature,
- /// Align lambda body relative to the indentation level of the outer scope
- /// the lambda signature resides in.
- /// \code
- /// someMethod(
- /// [](SomeReallyLongLambdaSignatureArgument foo) {
- /// return;
- /// });
- /// \endcode
- LBI_OuterScope,
- };
- /// The indentation style of lambda bodies. ``Signature`` (the default)
- /// causes the lambda body to be indented one additional level relative to
- /// the indentation level of the signature. ``OuterScope`` forces the lambda
- /// body to be indented one additional level relative to the parent scope
- /// containing the lambda signature. For callback-heavy code, it may improve
- /// readability to have the signature indented two levels and to use
- /// ``OuterScope``. The KJ style guide requires ``OuterScope``.
- /// `KJ style guide
- /// <https://github.com/capnproto/capnproto/blob/master/style-guide.md>`_
- /// \version 13
- LambdaBodyIndentationKind LambdaBodyIndentation;
- /// A regular expression matching macros that start a block.
- /// \code
- /// # With:
- /// MacroBlockBegin: "^NS_MAP_BEGIN|\
- /// NS_TABLE_HEAD$"
- /// MacroBlockEnd: "^\
- /// NS_MAP_END|\
- /// NS_TABLE_.*_END$"
- ///
- /// NS_MAP_BEGIN
- /// foo();
- /// NS_MAP_END
- ///
- /// NS_TABLE_HEAD
- /// bar();
- /// NS_TABLE_FOO_END
- ///
- /// # Without:
- /// NS_MAP_BEGIN
- /// foo();
- /// NS_MAP_END
- ///
- /// NS_TABLE_HEAD
- /// bar();
- /// NS_TABLE_FOO_END
- /// \endcode
- /// \version 3.7
- std::string MacroBlockBegin;
- /// A regular expression matching macros that end a block.
- /// \version 3.7
- std::string MacroBlockEnd;
- /// The maximum number of consecutive empty lines to keep.
- /// \code
- /// MaxEmptyLinesToKeep: 1 vs. MaxEmptyLinesToKeep: 0
- /// int f() { int f() {
- /// int = 1; int i = 1;
- /// i = foo();
- /// i = foo(); return i;
- /// }
- /// return i;
- /// }
- /// \endcode
- /// \version 3.7
- unsigned MaxEmptyLinesToKeep;
- /// Different ways to indent namespace contents.
- enum NamespaceIndentationKind : unsigned char {
- /// Don't indent in namespaces.
- /// \code
- /// namespace out {
- /// int i;
- /// namespace in {
- /// int i;
- /// }
- /// }
- /// \endcode
- NI_None,
- /// Indent only in inner namespaces (nested in other namespaces).
- /// \code
- /// namespace out {
- /// int i;
- /// namespace in {
- /// int i;
- /// }
- /// }
- /// \endcode
- NI_Inner,
- /// Indent in all namespaces.
- /// \code
- /// namespace out {
- /// int i;
- /// namespace in {
- /// int i;
- /// }
- /// }
- /// \endcode
- NI_All
- };
- /// The indentation used for namespaces.
- /// \version 3.7
- NamespaceIndentationKind NamespaceIndentation;
- /// Controls bin-packing Objective-C protocol conformance list
- /// items into as few lines as possible when they go over ``ColumnLimit``.
- ///
- /// If ``Auto`` (the default), delegates to the value in
- /// ``BinPackParameters``. If that is ``true``, bin-packs Objective-C
- /// protocol conformance list items into as few lines as possible
- /// whenever they go over ``ColumnLimit``.
- ///
- /// If ``Always``, always bin-packs Objective-C protocol conformance
- /// list items into as few lines as possible whenever they go over
- /// ``ColumnLimit``.
- ///
- /// If ``Never``, lays out Objective-C protocol conformance list items
- /// onto individual lines whenever they go over ``ColumnLimit``.
- ///
- /// \code{.objc}
- /// Always (or Auto, if BinPackParameters=true):
- /// @interface ccccccccccccc () <
- /// ccccccccccccc, ccccccccccccc,
- /// ccccccccccccc, ccccccccccccc> {
- /// }
- ///
- /// Never (or Auto, if BinPackParameters=false):
- /// @interface ddddddddddddd () <
- /// ddddddddddddd,
- /// ddddddddddddd,
- /// ddddddddddddd,
- /// ddddddddddddd> {
- /// }
- /// \endcode
- /// \version 7
- BinPackStyle ObjCBinPackProtocolList;
- /// The number of characters to use for indentation of ObjC blocks.
- /// \code{.objc}
- /// ObjCBlockIndentWidth: 4
- ///
- /// [operation setCompletionBlock:^{
- /// [self onOperationDone];
- /// }];
- /// \endcode
- /// \version 3.7
- unsigned ObjCBlockIndentWidth;
- /// Add a space after ``@property`` in Objective-C, i.e. use
- /// ``@property (readonly)`` instead of ``@property(readonly)``.
- /// \version 3.7
- bool ObjCSpaceAfterProperty;
- /// Break parameters list into lines when there is nested block
- /// parameters in a function call.
- /// \code
- /// false:
- /// - (void)_aMethod
- /// {
- /// [self.test1 t:self w:self callback:^(typeof(self) self, NSNumber
- /// *u, NSNumber *v) {
- /// u = c;
- /// }]
- /// }
- /// true:
- /// - (void)_aMethod
- /// {
- /// [self.test1 t:self
- /// w:self
- /// callback:^(typeof(self) self, NSNumber *u, NSNumber *v) {
- /// u = c;
- /// }]
- /// }
- /// \endcode
- /// \version 12
- bool ObjCBreakBeforeNestedBlockParam;
- /// Add a space in front of an Objective-C protocol list, i.e. use
- /// ``Foo <Protocol>`` instead of ``Foo<Protocol>``.
- /// \version 3.7
- bool ObjCSpaceBeforeProtocolList;
- /// The penalty for breaking around an assignment operator.
- /// \version 5
- unsigned PenaltyBreakAssignment;
- /// The penalty for breaking a function call after ``call(``.
- /// \version 3.7
- unsigned PenaltyBreakBeforeFirstCallParameter;
- /// The penalty for each line break introduced inside a comment.
- /// \version 3.7
- unsigned PenaltyBreakComment;
- /// The penalty for breaking before the first ``<<``.
- /// \version 3.7
- unsigned PenaltyBreakFirstLessLess;
- /// The penalty for breaking after ``(``.
- /// \version 14
- unsigned PenaltyBreakOpenParenthesis;
- /// The penalty for each line break introduced inside a string literal.
- /// \version 3.7
- unsigned PenaltyBreakString;
- /// The penalty for breaking after template declaration.
- /// \version 7
- unsigned PenaltyBreakTemplateDeclaration;
- /// The penalty for each character outside of the column limit.
- /// \version 3.7
- unsigned PenaltyExcessCharacter;
- /// Penalty for putting the return type of a function onto its own
- /// line.
- /// \version 3.7
- unsigned PenaltyReturnTypeOnItsOwnLine;
- /// Penalty for each character of whitespace indentation
- /// (counted relative to leading non-whitespace column).
- /// \version 12
- unsigned PenaltyIndentedWhitespace;
- /// The ``&``, ``&&`` and ``*`` alignment style.
- enum PointerAlignmentStyle : unsigned char {
- /// Align pointer to the left.
- /// \code
- /// int* a;
- /// \endcode
- PAS_Left,
- /// Align pointer to the right.
- /// \code
- /// int *a;
- /// \endcode
- PAS_Right,
- /// Align pointer in the middle.
- /// \code
- /// int * a;
- /// \endcode
- PAS_Middle
- };
- /// Pointer and reference alignment style.
- /// \version 3.7
- PointerAlignmentStyle PointerAlignment;
- /// The number of columns to use for indentation of preprocessor statements.
- /// When set to -1 (default) ``IndentWidth`` is used also for preprocessor
- /// statements.
- /// \code
- /// PPIndentWidth: 1
- ///
- /// #ifdef __linux__
- /// # define FOO
- /// #else
- /// # define BAR
- /// #endif
- /// \endcode
- /// \version 14
- int PPIndentWidth;
- /// See documentation of ``RawStringFormats``.
- struct RawStringFormat {
- /// The language of this raw string.
- LanguageKind Language;
- /// A list of raw string delimiters that match this language.
- std::vector<std::string> Delimiters;
- /// A list of enclosing function names that match this language.
- std::vector<std::string> EnclosingFunctions;
- /// The canonical delimiter for this language.
- std::string CanonicalDelimiter;
- /// The style name on which this raw string format is based on.
- /// If not specified, the raw string format is based on the style that this
- /// format is based on.
- std::string BasedOnStyle;
- bool operator==(const RawStringFormat &Other) const {
- return Language == Other.Language && Delimiters == Other.Delimiters &&
- EnclosingFunctions == Other.EnclosingFunctions &&
- CanonicalDelimiter == Other.CanonicalDelimiter &&
- BasedOnStyle == Other.BasedOnStyle;
- }
- };
- /// Defines hints for detecting supported languages code blocks in raw
- /// strings.
- ///
- /// A raw string with a matching delimiter or a matching enclosing function
- /// name will be reformatted assuming the specified language based on the
- /// style for that language defined in the .clang-format file. If no style has
- /// been defined in the .clang-format file for the specific language, a
- /// predefined style given by 'BasedOnStyle' is used. If 'BasedOnStyle' is not
- /// found, the formatting is based on llvm style. A matching delimiter takes
- /// precedence over a matching enclosing function name for determining the
- /// language of the raw string contents.
- ///
- /// If a canonical delimiter is specified, occurrences of other delimiters for
- /// the same language will be updated to the canonical if possible.
- ///
- /// There should be at most one specification per language and each delimiter
- /// and enclosing function should not occur in multiple specifications.
- ///
- /// To configure this in the .clang-format file, use:
- /// \code{.yaml}
- /// RawStringFormats:
- /// - Language: TextProto
- /// Delimiters:
- /// - 'pb'
- /// - 'proto'
- /// EnclosingFunctions:
- /// - 'PARSE_TEXT_PROTO'
- /// BasedOnStyle: google
- /// - Language: Cpp
- /// Delimiters:
- /// - 'cc'
- /// - 'cpp'
- /// BasedOnStyle: llvm
- /// CanonicalDelimiter: 'cc'
- /// \endcode
- /// \version 6
- std::vector<RawStringFormat> RawStringFormats;
- /// \brief The ``&`` and ``&&`` alignment style.
- enum ReferenceAlignmentStyle {
- /// Align reference like ``PointerAlignment``.
- RAS_Pointer,
- /// Align reference to the left.
- /// \code
- /// int& a;
- /// \endcode
- RAS_Left,
- /// Align reference to the right.
- /// \code
- /// int &a;
- /// \endcode
- RAS_Right,
- /// Align reference in the middle.
- /// \code
- /// int & a;
- /// \endcode
- RAS_Middle
- };
- /// \brief Reference alignment style (overrides ``PointerAlignment`` for
- /// references).
- /// \version 14
- ReferenceAlignmentStyle ReferenceAlignment;
- // clang-format off
- /// If ``true``, clang-format will attempt to re-flow comments.
- /// \code
- /// false:
- /// // veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of information
- /// /* second veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of information */
- ///
- /// true:
- /// // veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of
- /// // information
- /// /* second veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of
- /// * information */
- /// \endcode
- /// \version 4
- bool ReflowComments;
- // clang-format on
- /// Remove optional braces of control statements (``if``, ``else``, ``for``,
- /// and ``while``) in C++ according to the LLVM coding style.
- /// \warning
- /// This option will be renamed and expanded to support other styles.
- /// \endwarning
- /// \warning
- /// Setting this option to `true` could lead to incorrect code formatting due
- /// to clang-format's lack of complete semantic information. As such, extra
- /// care should be taken to review code changes made by this option.
- /// \endwarning
- /// \code
- /// false: true:
- ///
- /// if (isa<FunctionDecl>(D)) { vs. if (isa<FunctionDecl>(D))
- /// handleFunctionDecl(D); handleFunctionDecl(D);
- /// } else if (isa<VarDecl>(D)) { else if (isa<VarDecl>(D))
- /// handleVarDecl(D); handleVarDecl(D);
- /// }
- ///
- /// if (isa<VarDecl>(D)) { vs. if (isa<VarDecl>(D)) {
- /// for (auto *A : D.attrs()) { for (auto *A : D.attrs())
- /// if (shouldProcessAttr(A)) { if (shouldProcessAttr(A))
- /// handleAttr(A); handleAttr(A);
- /// } }
- /// }
- /// }
- ///
- /// if (isa<FunctionDecl>(D)) { vs. if (isa<FunctionDecl>(D))
- /// for (auto *A : D.attrs()) { for (auto *A : D.attrs())
- /// handleAttr(A); handleAttr(A);
- /// }
- /// }
- ///
- /// if (auto *D = (T)(D)) { vs. if (auto *D = (T)(D)) {
- /// if (shouldProcess(D)) { if (shouldProcess(D))
- /// handleVarDecl(D); handleVarDecl(D);
- /// } else { else
- /// markAsIgnored(D); markAsIgnored(D);
- /// } }
- /// }
- ///
- /// if (a) { vs. if (a)
- /// b(); b();
- /// } else { else if (c)
- /// if (c) { d();
- /// d(); else
- /// } else { e();
- /// e();
- /// }
- /// }
- /// \endcode
- /// \version 14
- bool RemoveBracesLLVM;
- /// \brief The style if definition blocks should be separated.
- enum SeparateDefinitionStyle {
- /// Leave definition blocks as they are.
- SDS_Leave,
- /// Insert an empty line between definition blocks.
- SDS_Always,
- /// Remove any empty line between definition blocks.
- SDS_Never
- };
- /// Specifies the use of empty lines to separate definition blocks, including
- /// classes, structs, enums, and functions.
- /// \code
- /// Never v.s. Always
- /// #include <cstring> #include <cstring>
- /// struct Foo {
- /// int a, b, c; struct Foo {
- /// }; int a, b, c;
- /// namespace Ns { };
- /// class Bar {
- /// public: namespace Ns {
- /// struct Foobar { class Bar {
- /// int a; public:
- /// int b; struct Foobar {
- /// }; int a;
- /// private: int b;
- /// int t; };
- /// int method1() {
- /// // ... private:
- /// } int t;
- /// enum List {
- /// ITEM1, int method1() {
- /// ITEM2 // ...
- /// }; }
- /// template<typename T>
- /// int method2(T x) { enum List {
- /// // ... ITEM1,
- /// } ITEM2
- /// int i, j, k; };
- /// int method3(int par) {
- /// // ... template<typename T>
- /// } int method2(T x) {
- /// }; // ...
- /// class C {}; }
- /// }
- /// int i, j, k;
- ///
- /// int method3(int par) {
- /// // ...
- /// }
- /// };
- ///
- /// class C {};
- /// }
- /// \endcode
- /// \version 14
- SeparateDefinitionStyle SeparateDefinitionBlocks;
- /// The maximal number of unwrapped lines that a short namespace spans.
- /// Defaults to 1.
- ///
- /// This determines the maximum length of short namespaces by counting
- /// unwrapped lines (i.e. containing neither opening nor closing
- /// namespace brace) and makes "FixNamespaceComments" omit adding
- /// end comments for those.
- /// \code
- /// ShortNamespaceLines: 1 vs. ShortNamespaceLines: 0
- /// namespace a { namespace a {
- /// int foo; int foo;
- /// } } // namespace a
- ///
- /// ShortNamespaceLines: 1 vs. ShortNamespaceLines: 0
- /// namespace b { namespace b {
- /// int foo; int foo;
- /// int bar; int bar;
- /// } // namespace b } // namespace b
- /// \endcode
- /// \version 14
- unsigned ShortNamespaceLines;
- /// Include sorting options.
- enum SortIncludesOptions : unsigned char {
- /// Includes are never sorted.
- /// \code
- /// #include "B/A.h"
- /// #include "A/B.h"
- /// #include "a/b.h"
- /// #include "A/b.h"
- /// #include "B/a.h"
- /// \endcode
- SI_Never,
- /// Includes are sorted in an ASCIIbetical or case sensitive fashion.
- /// \code
- /// #include "A/B.h"
- /// #include "A/b.h"
- /// #include "B/A.h"
- /// #include "B/a.h"
- /// #include "a/b.h"
- /// \endcode
- SI_CaseSensitive,
- /// Includes are sorted in an alphabetical or case insensitive fashion.
- /// \code
- /// #include "A/B.h"
- /// #include "A/b.h"
- /// #include "a/b.h"
- /// #include "B/A.h"
- /// #include "B/a.h"
- /// \endcode
- SI_CaseInsensitive,
- };
- /// Controls if and how clang-format will sort ``#includes``.
- /// If ``Never``, includes are never sorted.
- /// If ``CaseInsensitive``, includes are sorted in an ASCIIbetical or case
- /// insensitive fashion.
- /// If ``CaseSensitive``, includes are sorted in an alphabetical or case
- /// sensitive fashion.
- /// \version 4
- SortIncludesOptions SortIncludes;
- /// Position for Java Static imports.
- enum SortJavaStaticImportOptions : unsigned char {
- /// Static imports are placed before non-static imports.
- /// \code{.java}
- /// import static org.example.function1;
- ///
- /// import org.example.ClassA;
- /// \endcode
- SJSIO_Before,
- /// Static imports are placed after non-static imports.
- /// \code{.java}
- /// import org.example.ClassA;
- ///
- /// import static org.example.function1;
- /// \endcode
- SJSIO_After,
- };
- /// When sorting Java imports, by default static imports are placed before
- /// non-static imports. If ``JavaStaticImportAfterImport`` is ``After``,
- /// static imports are placed after non-static imports.
- /// \version 12
- SortJavaStaticImportOptions SortJavaStaticImport;
- /// If ``true``, clang-format will sort using declarations.
- ///
- /// The order of using declarations is defined as follows:
- /// Split the strings by "::" and discard any initial empty strings. The last
- /// element of each list is a non-namespace name; all others are namespace
- /// names. Sort the lists of names lexicographically, where the sort order of
- /// individual names is that all non-namespace names come before all namespace
- /// names, and within those groups, names are in case-insensitive
- /// lexicographic order.
- /// \code
- /// false: true:
- /// using std::cout; vs. using std::cin;
- /// using std::cin; using std::cout;
- /// \endcode
- /// \version 5
- bool SortUsingDeclarations;
- /// If ``true``, a space is inserted after C style casts.
- /// \code
- /// true: false:
- /// (int) i; vs. (int)i;
- /// \endcode
- /// \version 3.5
- bool SpaceAfterCStyleCast;
- /// If ``true``, a space is inserted after the logical not operator (``!``).
- /// \code
- /// true: false:
- /// ! someExpression(); vs. !someExpression();
- /// \endcode
- /// \version 9
- bool SpaceAfterLogicalNot;
- /// If \c true, a space will be inserted after the 'template' keyword.
- /// \code
- /// true: false:
- /// template <int> void foo(); vs. template<int> void foo();
- /// \endcode
- /// \version 4
- bool SpaceAfterTemplateKeyword;
- /// Different ways to put a space before opening parentheses.
- enum SpaceAroundPointerQualifiersStyle : unsigned char {
- /// Don't ensure spaces around pointer qualifiers and use PointerAlignment
- /// instead.
- /// \code
- /// PointerAlignment: Left PointerAlignment: Right
- /// void* const* x = NULL; vs. void *const *x = NULL;
- /// \endcode
- SAPQ_Default,
- /// Ensure that there is a space before pointer qualifiers.
- /// \code
- /// PointerAlignment: Left PointerAlignment: Right
- /// void* const* x = NULL; vs. void * const *x = NULL;
- /// \endcode
- SAPQ_Before,
- /// Ensure that there is a space after pointer qualifiers.
- /// \code
- /// PointerAlignment: Left PointerAlignment: Right
- /// void* const * x = NULL; vs. void *const *x = NULL;
- /// \endcode
- SAPQ_After,
- /// Ensure that there is a space both before and after pointer qualifiers.
- /// \code
- /// PointerAlignment: Left PointerAlignment: Right
- /// void* const * x = NULL; vs. void * const *x = NULL;
- /// \endcode
- SAPQ_Both,
- };
- /// Defines in which cases to put a space before or after pointer qualifiers
- /// \version 12
- SpaceAroundPointerQualifiersStyle SpaceAroundPointerQualifiers;
- /// If ``false``, spaces will be removed before assignment operators.
- /// \code
- /// true: false:
- /// int a = 5; vs. int a= 5;
- /// a += 42; a+= 42;
- /// \endcode
- /// \version 3.7
- bool SpaceBeforeAssignmentOperators;
- /// If ``false``, spaces will be removed before case colon.
- /// \code
- /// true: false
- /// switch (x) { vs. switch (x) {
- /// case 1 : break; case 1: break;
- /// } }
- /// \endcode
- /// \version 12
- bool SpaceBeforeCaseColon;
- /// If ``true``, a space will be inserted before a C++11 braced list
- /// used to initialize an object (after the preceding identifier or type).
- /// \code
- /// true: false:
- /// Foo foo { bar }; vs. Foo foo{ bar };
- /// Foo {}; Foo{};
- /// vector<int> { 1, 2, 3 }; vector<int>{ 1, 2, 3 };
- /// new int[3] { 1, 2, 3 }; new int[3]{ 1, 2, 3 };
- /// \endcode
- /// \version 7
- bool SpaceBeforeCpp11BracedList;
- /// If ``false``, spaces will be removed before constructor initializer
- /// colon.
- /// \code
- /// true: false:
- /// Foo::Foo() : a(a) {} Foo::Foo(): a(a) {}
- /// \endcode
- /// \version 7
- bool SpaceBeforeCtorInitializerColon;
- /// If ``false``, spaces will be removed before inheritance colon.
- /// \code
- /// true: false:
- /// class Foo : Bar {} vs. class Foo: Bar {}
- /// \endcode
- /// \version 7
- bool SpaceBeforeInheritanceColon;
- /// Different ways to put a space before opening parentheses.
- enum SpaceBeforeParensStyle : unsigned char {
- /// Never put a space before opening parentheses.
- /// \code
- /// void f() {
- /// if(true) {
- /// f();
- /// }
- /// }
- /// \endcode
- SBPO_Never,
- /// Put a space before opening parentheses only after control statement
- /// keywords (``for/if/while...``).
- /// \code
- /// void f() {
- /// if (true) {
- /// f();
- /// }
- /// }
- /// \endcode
- SBPO_ControlStatements,
- /// Same as ``SBPO_ControlStatements`` except this option doesn't apply to
- /// ForEach and If macros. This is useful in projects where ForEach/If
- /// macros are treated as function calls instead of control statements.
- /// ``SBPO_ControlStatementsExceptForEachMacros`` remains an alias for
- /// backward compatibility.
- /// \code
- /// void f() {
- /// Q_FOREACH(...) {
- /// f();
- /// }
- /// }
- /// \endcode
- SBPO_ControlStatementsExceptControlMacros,
- /// Put a space before opening parentheses only if the parentheses are not
- /// empty i.e. '()'
- /// \code
- /// void() {
- /// if (true) {
- /// f();
- /// g (x, y, z);
- /// }
- /// }
- /// \endcode
- SBPO_NonEmptyParentheses,
- /// Always put a space before opening parentheses, except when it's
- /// prohibited by the syntax rules (in function-like macro definitions) or
- /// when determined by other style rules (after unary operators, opening
- /// parentheses, etc.)
- /// \code
- /// void f () {
- /// if (true) {
- /// f ();
- /// }
- /// }
- /// \endcode
- SBPO_Always,
- /// Configure each individual space before parentheses in
- /// `SpaceBeforeParensOptions`.
- SBPO_Custom,
- };
- /// Defines in which cases to put a space before opening parentheses.
- /// \version 3.5
- SpaceBeforeParensStyle SpaceBeforeParens;
- /// Precise control over the spacing before parentheses.
- /// \code
- /// # Should be declared this way:
- /// SpaceBeforeParens: Custom
- /// SpaceBeforeParensOptions:
- /// AfterControlStatements: true
- /// AfterFunctionDefinitionName: true
- /// \endcode
- struct SpaceBeforeParensCustom {
- /// If ``true``, put space betwee control statement keywords
- /// (for/if/while...) and opening parentheses.
- /// \code
- /// true: false:
- /// if (...) {} vs. if(...) {}
- /// \endcode
- bool AfterControlStatements;
- /// If ``true``, put space between foreach macros and opening parentheses.
- /// \code
- /// true: false:
- /// FOREACH (...) vs. FOREACH(...)
- /// <loop-body> <loop-body>
- /// \endcode
- bool AfterForeachMacros;
- /// If ``true``, put a space between function declaration name and opening
- /// parentheses.
- /// \code
- /// true: false:
- /// void f (); vs. void f();
- /// \endcode
- bool AfterFunctionDeclarationName;
- /// If ``true``, put a space between function definition name and opening
- /// parentheses.
- /// \code
- /// true: false:
- /// void f () {} vs. void f() {}
- /// \endcode
- bool AfterFunctionDefinitionName;
- /// If ``true``, put space between if macros and opening parentheses.
- /// \code
- /// true: false:
- /// IF (...) vs. IF(...)
- /// <conditional-body> <conditional-body>
- /// \endcode
- bool AfterIfMacros;
- /// If ``true``, put a space between operator overloading and opening
- /// parentheses.
- /// \code
- /// true: false:
- /// void operator++ (int a); vs. void operator++(int a);
- /// object.operator++ (10); object.operator++(10);
- /// \endcode
- bool AfterOverloadedOperator;
- /// If ``true``, put a space before opening parentheses only if the
- /// parentheses are not empty.
- /// \code
- /// true: false:
- /// void f (int a); vs. void f();
- /// f (a); f();
- /// \endcode
- bool BeforeNonEmptyParentheses;
- SpaceBeforeParensCustom()
- : AfterControlStatements(false), AfterForeachMacros(false),
- AfterFunctionDeclarationName(false),
- AfterFunctionDefinitionName(false), AfterIfMacros(false),
- AfterOverloadedOperator(false), BeforeNonEmptyParentheses(false) {}
- bool operator==(const SpaceBeforeParensCustom &Other) const {
- return AfterControlStatements == Other.AfterControlStatements &&
- AfterForeachMacros == Other.AfterForeachMacros &&
- AfterFunctionDeclarationName ==
- Other.AfterFunctionDeclarationName &&
- AfterFunctionDefinitionName == Other.AfterFunctionDefinitionName &&
- AfterIfMacros == Other.AfterIfMacros &&
- AfterOverloadedOperator == Other.AfterOverloadedOperator &&
- BeforeNonEmptyParentheses == Other.BeforeNonEmptyParentheses;
- }
- };
- /// Control of individual space before parentheses.
- ///
- /// If ``SpaceBeforeParens`` is set to ``Custom``, use this to specify
- /// how each individual space before parentheses case should be handled.
- /// Otherwise, this is ignored.
- /// \code{.yaml}
- /// # Example of usage:
- /// SpaceBeforeParens: Custom
- /// SpaceBeforeParensOptions:
- /// AfterControlStatements: true
- /// AfterFunctionDefinitionName: true
- /// \endcode
- /// \version 14
- SpaceBeforeParensCustom SpaceBeforeParensOptions;
- /// If ``false``, spaces will be removed before range-based for loop
- /// colon.
- /// \code
- /// true: false:
- /// for (auto v : values) {} vs. for(auto v: values) {}
- /// \endcode
- /// \version 7
- bool SpaceBeforeRangeBasedForLoopColon;
- /// If ``true``, spaces will be inserted into ``{}``.
- /// \code
- /// true: false:
- /// void f() { } vs. void f() {}
- /// while (true) { } while (true) {}
- /// \endcode
- /// \version 11
- bool SpaceInEmptyBlock;
- /// If ``true``, spaces may be inserted into ``()``.
- /// \code
- /// true: false:
- /// void f( ) { vs. void f() {
- /// int x[] = {foo( ), bar( )}; int x[] = {foo(), bar()};
- /// if (true) { if (true) {
- /// f( ); f();
- /// } }
- /// } }
- /// \endcode
- /// \version 3.7
- bool SpaceInEmptyParentheses;
- /// The number of spaces before trailing line comments
- /// (``//`` - comments).
- ///
- /// This does not affect trailing block comments (``/*`` - comments) as
- /// those commonly have different usage patterns and a number of special
- /// cases.
- /// \code
- /// SpacesBeforeTrailingComments: 3
- /// void f() {
- /// if (true) { // foo1
- /// f(); // bar
- /// } // foo
- /// }
- /// \endcode
- /// \version 3.7
- unsigned SpacesBeforeTrailingComments;
- /// Styles for adding spacing after ``<`` and before ``>`
- /// in template argument lists.
- enum SpacesInAnglesStyle : unsigned char {
- /// Remove spaces after ``<`` and before ``>``.
- /// \code
- /// static_cast<int>(arg);
- /// std::function<void(int)> fct;
- /// \endcode
- SIAS_Never,
- /// Add spaces after ``<`` and before ``>``.
- /// \code
- /// static_cast< int >(arg);
- /// std::function< void(int) > fct;
- /// \endcode
- SIAS_Always,
- /// Keep a single space after ``<`` and before ``>`` if any spaces were
- /// present. Option ``Standard: Cpp03`` takes precedence.
- SIAS_Leave
- };
- /// The SpacesInAnglesStyle to use for template argument lists.
- /// \version 14
- SpacesInAnglesStyle SpacesInAngles;
- /// If ``true``, spaces will be inserted around if/for/switch/while
- /// conditions.
- /// \code
- /// true: false:
- /// if ( a ) { ... } vs. if (a) { ... }
- /// while ( i < 5 ) { ... } while (i < 5) { ... }
- /// \endcode
- /// \version 11
- bool SpacesInConditionalStatement;
- /// If ``true``, spaces are inserted inside container literals (e.g.
- /// ObjC and Javascript array and dict literals).
- /// \code{.js}
- /// true: false:
- /// var arr = [ 1, 2, 3 ]; vs. var arr = [1, 2, 3];
- /// f({a : 1, b : 2, c : 3}); f({a: 1, b: 2, c: 3});
- /// \endcode
- /// \version 3.7
- bool SpacesInContainerLiterals;
- /// If ``true``, spaces may be inserted into C style casts.
- /// \code
- /// true: false:
- /// x = ( int32 )y vs. x = (int32)y
- /// \endcode
- /// \version 3.7
- bool SpacesInCStyleCastParentheses;
- /// Control of spaces within a single line comment
- struct SpacesInLineComment {
- /// The minimum number of spaces at the start of the comment.
- unsigned Minimum;
- /// The maximum number of spaces at the start of the comment.
- unsigned Maximum;
- };
- /// How many spaces are allowed at the start of a line comment. To disable the
- /// maximum set it to ``-1``, apart from that the maximum takes precedence
- /// over the minimum.
- /// \code
- /// Minimum = 1
- /// Maximum = -1
- /// // One space is forced
- ///
- /// // but more spaces are possible
- ///
- /// Minimum = 0
- /// Maximum = 0
- /// //Forces to start every comment directly after the slashes
- /// \endcode
- ///
- /// Note that in line comment sections the relative indent of the subsequent
- /// lines is kept, that means the following:
- /// \code
- /// before: after:
- /// Minimum: 1
- /// //if (b) { // if (b) {
- /// // return true; // return true;
- /// //} // }
- ///
- /// Maximum: 0
- /// /// List: ///List:
- /// /// - Foo /// - Foo
- /// /// - Bar /// - Bar
- /// \endcode
- /// \version 14
- SpacesInLineComment SpacesInLineCommentPrefix;
- /// If ``true``, spaces will be inserted after ``(`` and before ``)``.
- /// \code
- /// true: false:
- /// t f( Deleted & ) & = delete; vs. t f(Deleted &) & = delete;
- /// \endcode
- /// \version 3.7
- bool SpacesInParentheses;
- /// If ``true``, spaces will be inserted after ``[`` and before ``]``.
- /// Lambdas without arguments or unspecified size array declarations will not
- /// be affected.
- /// \code
- /// true: false:
- /// int a[ 5 ]; vs. int a[5];
- /// std::unique_ptr<int[]> foo() {} // Won't be affected
- /// \endcode
- /// \version 3.7
- bool SpacesInSquareBrackets;
- /// If ``true``, spaces will be before ``[``.
- /// Lambdas will not be affected. Only the first ``[`` will get a space added.
- /// \code
- /// true: false:
- /// int a [5]; vs. int a[5];
- /// int a [5][5]; vs. int a[5][5];
- /// \endcode
- /// \version 11
- bool SpaceBeforeSquareBrackets;
- /// Styles for adding spacing around ``:`` in bitfield definitions.
- enum BitFieldColonSpacingStyle : unsigned char {
- /// Add one space on each side of the ``:``
- /// \code
- /// unsigned bf : 2;
- /// \endcode
- BFCS_Both,
- /// Add no space around the ``:`` (except when needed for
- /// ``AlignConsecutiveBitFields``).
- /// \code
- /// unsigned bf:2;
- /// \endcode
- BFCS_None,
- /// Add space before the ``:`` only
- /// \code
- /// unsigned bf :2;
- /// \endcode
- BFCS_Before,
- /// Add space after the ``:`` only (space may be added before if
- /// needed for ``AlignConsecutiveBitFields``).
- /// \code
- /// unsigned bf: 2;
- /// \endcode
- BFCS_After
- };
- /// The BitFieldColonSpacingStyle to use for bitfields.
- /// \version 12
- BitFieldColonSpacingStyle BitFieldColonSpacing;
- /// Supported language standards for parsing and formatting C++ constructs.
- /// \code
- /// Latest: vector<set<int>>
- /// c++03 vs. vector<set<int> >
- /// \endcode
- ///
- /// The correct way to spell a specific language version is e.g. ``c++11``.
- /// The historical aliases ``Cpp03`` and ``Cpp11`` are deprecated.
- enum LanguageStandard : unsigned char {
- /// Parse and format as C++03.
- /// ``Cpp03`` is a deprecated alias for ``c++03``
- LS_Cpp03, // c++03
- /// Parse and format as C++11.
- LS_Cpp11, // c++11
- /// Parse and format as C++14.
- LS_Cpp14, // c++14
- /// Parse and format as C++17.
- LS_Cpp17, // c++17
- /// Parse and format as C++20.
- LS_Cpp20, // c++20
- /// Parse and format using the latest supported language version.
- /// ``Cpp11`` is a deprecated alias for ``Latest``
- LS_Latest,
- /// Automatic detection based on the input.
- LS_Auto,
- };
- /// Parse and format C++ constructs compatible with this standard.
- /// \code
- /// c++03: latest:
- /// vector<set<int> > x; vs. vector<set<int>> x;
- /// \endcode
- /// \version 3.7
- LanguageStandard Standard;
- /// Macros which are ignored in front of a statement, as if they were an
- /// attribute. So that they are not parsed as identifier, for example for Qts
- /// emit.
- /// \code
- /// AlignConsecutiveDeclarations: true
- /// StatementAttributeLikeMacros: []
- /// unsigned char data = 'x';
- /// emit signal(data); // This is parsed as variable declaration.
- ///
- /// AlignConsecutiveDeclarations: true
- /// StatementAttributeLikeMacros: [emit]
- /// unsigned char data = 'x';
- /// emit signal(data); // Now it's fine again.
- /// \endcode
- /// \version 12
- std::vector<std::string> StatementAttributeLikeMacros;
- /// The number of columns used for tab stops.
- /// \version 3.7
- unsigned TabWidth;
- /// Different ways to use tab in formatting.
- enum UseTabStyle : unsigned char {
- /// Never use tab.
- UT_Never,
- /// Use tabs only for indentation.
- UT_ForIndentation,
- /// Fill all leading whitespace with tabs, and use spaces for alignment that
- /// appears within a line (e.g. consecutive assignments and declarations).
- UT_ForContinuationAndIndentation,
- /// Use tabs for line continuation and indentation, and spaces for
- /// alignment.
- UT_AlignWithSpaces,
- /// Use tabs whenever we need to fill whitespace that spans at least from
- /// one tab stop to the next one.
- UT_Always
- };
- /// \brief Use ``\r\n`` instead of ``\n`` for line breaks.
- /// Also used as fallback if ``DeriveLineEnding`` is true.
- /// \version 11
- bool UseCRLF;
- /// The way to use tab characters in the resulting file.
- /// \version 3.7
- UseTabStyle UseTab;
- bool operator==(const FormatStyle &R) const {
- return AccessModifierOffset == R.AccessModifierOffset &&
- AlignAfterOpenBracket == R.AlignAfterOpenBracket &&
- AlignArrayOfStructures == R.AlignArrayOfStructures &&
- AlignConsecutiveAssignments == R.AlignConsecutiveAssignments &&
- AlignConsecutiveBitFields == R.AlignConsecutiveBitFields &&
- AlignConsecutiveDeclarations == R.AlignConsecutiveDeclarations &&
- AlignConsecutiveMacros == R.AlignConsecutiveMacros &&
- AlignEscapedNewlines == R.AlignEscapedNewlines &&
- AlignOperands == R.AlignOperands &&
- AlignTrailingComments == R.AlignTrailingComments &&
- AllowAllArgumentsOnNextLine == R.AllowAllArgumentsOnNextLine &&
- AllowAllParametersOfDeclarationOnNextLine ==
- R.AllowAllParametersOfDeclarationOnNextLine &&
- AllowShortEnumsOnASingleLine == R.AllowShortEnumsOnASingleLine &&
- AllowShortBlocksOnASingleLine == R.AllowShortBlocksOnASingleLine &&
- AllowShortCaseLabelsOnASingleLine ==
- R.AllowShortCaseLabelsOnASingleLine &&
- AllowShortFunctionsOnASingleLine ==
- R.AllowShortFunctionsOnASingleLine &&
- AllowShortIfStatementsOnASingleLine ==
- R.AllowShortIfStatementsOnASingleLine &&
- AllowShortLambdasOnASingleLine == R.AllowShortLambdasOnASingleLine &&
- AllowShortLoopsOnASingleLine == R.AllowShortLoopsOnASingleLine &&
- AlwaysBreakAfterReturnType == R.AlwaysBreakAfterReturnType &&
- AlwaysBreakBeforeMultilineStrings ==
- R.AlwaysBreakBeforeMultilineStrings &&
- AlwaysBreakTemplateDeclarations ==
- R.AlwaysBreakTemplateDeclarations &&
- AttributeMacros == R.AttributeMacros &&
- BinPackArguments == R.BinPackArguments &&
- BinPackParameters == R.BinPackParameters &&
- BreakBeforeBinaryOperators == R.BreakBeforeBinaryOperators &&
- BreakBeforeBraces == R.BreakBeforeBraces &&
- BreakBeforeConceptDeclarations == R.BreakBeforeConceptDeclarations &&
- BreakBeforeTernaryOperators == R.BreakBeforeTernaryOperators &&
- BreakConstructorInitializers == R.BreakConstructorInitializers &&
- CompactNamespaces == R.CompactNamespaces &&
- BreakAfterJavaFieldAnnotations == R.BreakAfterJavaFieldAnnotations &&
- BreakStringLiterals == R.BreakStringLiterals &&
- ColumnLimit == R.ColumnLimit && CommentPragmas == R.CommentPragmas &&
- BreakInheritanceList == R.BreakInheritanceList &&
- ConstructorInitializerIndentWidth ==
- R.ConstructorInitializerIndentWidth &&
- ContinuationIndentWidth == R.ContinuationIndentWidth &&
- Cpp11BracedListStyle == R.Cpp11BracedListStyle &&
- DeriveLineEnding == R.DeriveLineEnding &&
- DerivePointerAlignment == R.DerivePointerAlignment &&
- DisableFormat == R.DisableFormat &&
- EmptyLineAfterAccessModifier == R.EmptyLineAfterAccessModifier &&
- EmptyLineBeforeAccessModifier == R.EmptyLineBeforeAccessModifier &&
- ExperimentalAutoDetectBinPacking ==
- R.ExperimentalAutoDetectBinPacking &&
- PackConstructorInitializers == R.PackConstructorInitializers &&
- FixNamespaceComments == R.FixNamespaceComments &&
- ForEachMacros == R.ForEachMacros &&
- IncludeStyle.IncludeBlocks == R.IncludeStyle.IncludeBlocks &&
- IncludeStyle.IncludeCategories == R.IncludeStyle.IncludeCategories &&
- IncludeStyle.IncludeIsMainRegex ==
- R.IncludeStyle.IncludeIsMainRegex &&
- IncludeStyle.IncludeIsMainSourceRegex ==
- R.IncludeStyle.IncludeIsMainSourceRegex &&
- IndentAccessModifiers == R.IndentAccessModifiers &&
- IndentCaseLabels == R.IndentCaseLabels &&
- IndentCaseBlocks == R.IndentCaseBlocks &&
- IndentGotoLabels == R.IndentGotoLabels &&
- IndentPPDirectives == R.IndentPPDirectives &&
- IndentExternBlock == R.IndentExternBlock &&
- IndentRequires == R.IndentRequires && IndentWidth == R.IndentWidth &&
- Language == R.Language &&
- IndentWrappedFunctionNames == R.IndentWrappedFunctionNames &&
- JavaImportGroups == R.JavaImportGroups &&
- JavaScriptQuotes == R.JavaScriptQuotes &&
- JavaScriptWrapImports == R.JavaScriptWrapImports &&
- KeepEmptyLinesAtTheStartOfBlocks ==
- R.KeepEmptyLinesAtTheStartOfBlocks &&
- LambdaBodyIndentation == R.LambdaBodyIndentation &&
- MacroBlockBegin == R.MacroBlockBegin &&
- MacroBlockEnd == R.MacroBlockEnd &&
- MaxEmptyLinesToKeep == R.MaxEmptyLinesToKeep &&
- NamespaceIndentation == R.NamespaceIndentation &&
- NamespaceMacros == R.NamespaceMacros &&
- ObjCBinPackProtocolList == R.ObjCBinPackProtocolList &&
- ObjCBlockIndentWidth == R.ObjCBlockIndentWidth &&
- ObjCBreakBeforeNestedBlockParam ==
- R.ObjCBreakBeforeNestedBlockParam &&
- ObjCSpaceAfterProperty == R.ObjCSpaceAfterProperty &&
- ObjCSpaceBeforeProtocolList == R.ObjCSpaceBeforeProtocolList &&
- PenaltyBreakAssignment == R.PenaltyBreakAssignment &&
- PenaltyBreakBeforeFirstCallParameter ==
- R.PenaltyBreakBeforeFirstCallParameter &&
- PenaltyBreakComment == R.PenaltyBreakComment &&
- PenaltyBreakFirstLessLess == R.PenaltyBreakFirstLessLess &&
- PenaltyBreakOpenParenthesis == R.PenaltyBreakOpenParenthesis &&
- PenaltyBreakString == R.PenaltyBreakString &&
- PenaltyExcessCharacter == R.PenaltyExcessCharacter &&
- PenaltyReturnTypeOnItsOwnLine == R.PenaltyReturnTypeOnItsOwnLine &&
- PenaltyBreakTemplateDeclaration ==
- R.PenaltyBreakTemplateDeclaration &&
- PointerAlignment == R.PointerAlignment &&
- QualifierAlignment == R.QualifierAlignment &&
- QualifierOrder == R.QualifierOrder &&
- RawStringFormats == R.RawStringFormats &&
- ReferenceAlignment == R.ReferenceAlignment &&
- RemoveBracesLLVM == R.RemoveBracesLLVM &&
- SeparateDefinitionBlocks == R.SeparateDefinitionBlocks &&
- ShortNamespaceLines == R.ShortNamespaceLines &&
- SortIncludes == R.SortIncludes &&
- SortJavaStaticImport == R.SortJavaStaticImport &&
- SpaceAfterCStyleCast == R.SpaceAfterCStyleCast &&
- SpaceAfterLogicalNot == R.SpaceAfterLogicalNot &&
- SpaceAfterTemplateKeyword == R.SpaceAfterTemplateKeyword &&
- SpaceBeforeAssignmentOperators == R.SpaceBeforeAssignmentOperators &&
- SpaceBeforeCaseColon == R.SpaceBeforeCaseColon &&
- SpaceBeforeCpp11BracedList == R.SpaceBeforeCpp11BracedList &&
- SpaceBeforeCtorInitializerColon ==
- R.SpaceBeforeCtorInitializerColon &&
- SpaceBeforeInheritanceColon == R.SpaceBeforeInheritanceColon &&
- SpaceBeforeParens == R.SpaceBeforeParens &&
- SpaceBeforeParensOptions == R.SpaceBeforeParensOptions &&
- SpaceAroundPointerQualifiers == R.SpaceAroundPointerQualifiers &&
- SpaceBeforeRangeBasedForLoopColon ==
- R.SpaceBeforeRangeBasedForLoopColon &&
- SpaceInEmptyBlock == R.SpaceInEmptyBlock &&
- SpaceInEmptyParentheses == R.SpaceInEmptyParentheses &&
- SpacesBeforeTrailingComments == R.SpacesBeforeTrailingComments &&
- SpacesInAngles == R.SpacesInAngles &&
- SpacesInConditionalStatement == R.SpacesInConditionalStatement &&
- SpacesInContainerLiterals == R.SpacesInContainerLiterals &&
- SpacesInCStyleCastParentheses == R.SpacesInCStyleCastParentheses &&
- SpacesInLineCommentPrefix.Minimum ==
- R.SpacesInLineCommentPrefix.Minimum &&
- SpacesInLineCommentPrefix.Maximum ==
- R.SpacesInLineCommentPrefix.Maximum &&
- SpacesInParentheses == R.SpacesInParentheses &&
- SpacesInSquareBrackets == R.SpacesInSquareBrackets &&
- SpaceBeforeSquareBrackets == R.SpaceBeforeSquareBrackets &&
- BitFieldColonSpacing == R.BitFieldColonSpacing &&
- Standard == R.Standard &&
- StatementAttributeLikeMacros == R.StatementAttributeLikeMacros &&
- StatementMacros == R.StatementMacros && TabWidth == R.TabWidth &&
- UseTab == R.UseTab && UseCRLF == R.UseCRLF &&
- TypenameMacros == R.TypenameMacros;
- }
- llvm::Optional<FormatStyle> GetLanguageStyle(LanguageKind Language) const;
- // Stores per-language styles. A FormatStyle instance inside has an empty
- // StyleSet. A FormatStyle instance returned by the Get method has its
- // StyleSet set to a copy of the originating StyleSet, effectively keeping the
- // internal representation of that StyleSet alive.
- //
- // The memory management and ownership reminds of a birds nest: chicks
- // leaving the nest take photos of the nest with them.
- struct FormatStyleSet {
- typedef std::map<FormatStyle::LanguageKind, FormatStyle> MapType;
- llvm::Optional<FormatStyle> Get(FormatStyle::LanguageKind Language) const;
- // Adds \p Style to this FormatStyleSet. Style must not have an associated
- // FormatStyleSet.
- // Style.Language should be different than LK_None. If this FormatStyleSet
- // already contains an entry for Style.Language, that gets replaced with the
- // passed Style.
- void Add(FormatStyle Style);
- // Clears this FormatStyleSet.
- void Clear();
- private:
- std::shared_ptr<MapType> Styles;
- };
- static FormatStyleSet BuildStyleSetFromConfiguration(
- const FormatStyle &MainStyle,
- const std::vector<FormatStyle> &ConfigurationStyles);
- private:
- FormatStyleSet StyleSet;
- friend std::error_code
- parseConfiguration(llvm::MemoryBufferRef Config, FormatStyle *Style,
- bool AllowUnknownOptions,
- llvm::SourceMgr::DiagHandlerTy DiagHandler,
- void *DiagHandlerCtxt);
- };
- /// Returns a format style complying with the LLVM coding standards:
- /// http://llvm.org/docs/CodingStandards.html.
- FormatStyle getLLVMStyle(
- FormatStyle::LanguageKind Language = FormatStyle::LanguageKind::LK_Cpp);
- /// Returns a format style complying with one of Google's style guides:
- /// http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml.
- /// http://google-styleguide.googlecode.com/svn/trunk/javascriptguide.xml.
- /// https://developers.google.com/protocol-buffers/docs/style.
- FormatStyle getGoogleStyle(FormatStyle::LanguageKind Language);
- /// Returns a format style complying with Chromium's style guide:
- /// http://www.chromium.org/developers/coding-style.
- FormatStyle getChromiumStyle(FormatStyle::LanguageKind Language);
- /// Returns a format style complying with Mozilla's style guide:
- /// https://firefox-source-docs.mozilla.org/code-quality/coding-style/index.html.
- FormatStyle getMozillaStyle();
- /// Returns a format style complying with Webkit's style guide:
- /// http://www.webkit.org/coding/coding-style.html
- FormatStyle getWebKitStyle();
- /// Returns a format style complying with GNU Coding Standards:
- /// http://www.gnu.org/prep/standards/standards.html
- FormatStyle getGNUStyle();
- /// Returns a format style complying with Microsoft style guide:
- /// https://docs.microsoft.com/en-us/visualstudio/ide/editorconfig-code-style-settings-reference?view=vs-2017
- FormatStyle getMicrosoftStyle(FormatStyle::LanguageKind Language);
- /// Returns style indicating formatting should be not applied at all.
- FormatStyle getNoStyle();
- /// Gets a predefined style for the specified language by name.
- ///
- /// Currently supported names: LLVM, Google, Chromium, Mozilla. Names are
- /// compared case-insensitively.
- ///
- /// Returns ``true`` if the Style has been set.
- bool getPredefinedStyle(StringRef Name, FormatStyle::LanguageKind Language,
- FormatStyle *Style);
- /// Parse configuration from YAML-formatted text.
- ///
- /// Style->Language is used to get the base style, if the ``BasedOnStyle``
- /// option is present.
- ///
- /// The FormatStyleSet of Style is reset.
- ///
- /// When ``BasedOnStyle`` is not present, options not present in the YAML
- /// document, are retained in \p Style.
- ///
- /// If AllowUnknownOptions is true, no errors are emitted if unknown
- /// format options are occured.
- ///
- /// If set all diagnostics are emitted through the DiagHandler.
- std::error_code
- parseConfiguration(llvm::MemoryBufferRef Config, FormatStyle *Style,
- bool AllowUnknownOptions = false,
- llvm::SourceMgr::DiagHandlerTy DiagHandler = nullptr,
- void *DiagHandlerCtx = nullptr);
- /// Like above but accepts an unnamed buffer.
- inline std::error_code parseConfiguration(StringRef Config, FormatStyle *Style,
- bool AllowUnknownOptions = false) {
- return parseConfiguration(llvm::MemoryBufferRef(Config, "YAML"), Style,
- AllowUnknownOptions);
- }
- /// Gets configuration in a YAML string.
- std::string configurationAsText(const FormatStyle &Style);
- /// Returns the replacements necessary to sort all ``#include`` blocks
- /// that are affected by ``Ranges``.
- tooling::Replacements sortIncludes(const FormatStyle &Style, StringRef Code,
- ArrayRef<tooling::Range> Ranges,
- StringRef FileName,
- unsigned *Cursor = nullptr);
- /// Returns the replacements corresponding to applying and formatting
- /// \p Replaces on success; otheriwse, return an llvm::Error carrying
- /// llvm::StringError.
- llvm::Expected<tooling::Replacements>
- formatReplacements(StringRef Code, const tooling::Replacements &Replaces,
- const FormatStyle &Style);
- /// Returns the replacements corresponding to applying \p Replaces and
- /// cleaning up the code after that on success; otherwise, return an llvm::Error
- /// carrying llvm::StringError.
- /// This also supports inserting/deleting C++ #include directives:
- /// - If a replacement has offset UINT_MAX, length 0, and a replacement text
- /// that is an #include directive, this will insert the #include into the
- /// correct block in the \p Code.
- /// - If a replacement has offset UINT_MAX, length 1, and a replacement text
- /// that is the name of the header to be removed, the header will be removed
- /// from \p Code if it exists.
- /// The include manipulation is done via `tooling::HeaderInclude`, see its
- /// documentation for more details on how include insertion points are found and
- /// what edits are produced.
- llvm::Expected<tooling::Replacements>
- cleanupAroundReplacements(StringRef Code, const tooling::Replacements &Replaces,
- const FormatStyle &Style);
- /// Represents the status of a formatting attempt.
- struct FormattingAttemptStatus {
- /// A value of ``false`` means that any of the affected ranges were not
- /// formatted due to a non-recoverable syntax error.
- bool FormatComplete = true;
- /// If ``FormatComplete`` is false, ``Line`` records a one-based
- /// original line number at which a syntax error might have occurred. This is
- /// based on a best-effort analysis and could be imprecise.
- unsigned Line = 0;
- };
- /// Reformats the given \p Ranges in \p Code.
- ///
- /// Each range is extended on either end to its next bigger logic unit, i.e.
- /// everything that might influence its formatting or might be influenced by its
- /// formatting.
- ///
- /// Returns the ``Replacements`` necessary to make all \p Ranges comply with
- /// \p Style.
- ///
- /// If ``Status`` is non-null, its value will be populated with the status of
- /// this formatting attempt. See \c FormattingAttemptStatus.
- tooling::Replacements reformat(const FormatStyle &Style, StringRef Code,
- ArrayRef<tooling::Range> Ranges,
- StringRef FileName = "<stdin>",
- FormattingAttemptStatus *Status = nullptr);
- /// Same as above, except if ``IncompleteFormat`` is non-null, its value
- /// will be set to true if any of the affected ranges were not formatted due to
- /// a non-recoverable syntax error.
- tooling::Replacements reformat(const FormatStyle &Style, StringRef Code,
- ArrayRef<tooling::Range> Ranges,
- StringRef FileName, bool *IncompleteFormat);
- /// Clean up any erroneous/redundant code in the given \p Ranges in \p
- /// Code.
- ///
- /// Returns the ``Replacements`` that clean up all \p Ranges in \p Code.
- tooling::Replacements cleanup(const FormatStyle &Style, StringRef Code,
- ArrayRef<tooling::Range> Ranges,
- StringRef FileName = "<stdin>");
- /// Fix namespace end comments in the given \p Ranges in \p Code.
- ///
- /// Returns the ``Replacements`` that fix the namespace comments in all
- /// \p Ranges in \p Code.
- tooling::Replacements fixNamespaceEndComments(const FormatStyle &Style,
- StringRef Code,
- ArrayRef<tooling::Range> Ranges,
- StringRef FileName = "<stdin>");
- /// Inserts or removes empty lines separating definition blocks including
- /// classes, structs, functions, namespaces, and enums in the given \p Ranges in
- /// \p Code.
- ///
- /// Returns the ``Replacements`` that inserts or removes empty lines separating
- /// definition blocks in all \p Ranges in \p Code.
- tooling::Replacements separateDefinitionBlocks(const FormatStyle &Style,
- StringRef Code,
- ArrayRef<tooling::Range> Ranges,
- StringRef FileName = "<stdin>");
- /// Sort consecutive using declarations in the given \p Ranges in
- /// \p Code.
- ///
- /// Returns the ``Replacements`` that sort the using declarations in all
- /// \p Ranges in \p Code.
- tooling::Replacements sortUsingDeclarations(const FormatStyle &Style,
- StringRef Code,
- ArrayRef<tooling::Range> Ranges,
- StringRef FileName = "<stdin>");
- /// Returns the ``LangOpts`` that the formatter expects you to set.
- ///
- /// \param Style determines specific settings for lexing mode.
- LangOptions getFormattingLangOpts(const FormatStyle &Style = getLLVMStyle());
- /// Description to be used for help text for a ``llvm::cl`` option for
- /// specifying format style. The description is closely related to the operation
- /// of ``getStyle()``.
- extern const char *StyleOptionHelpDescription;
- /// The suggested format style to use by default. This allows tools using
- /// `getStyle` to have a consistent default style.
- /// Different builds can modify the value to the preferred styles.
- extern const char *DefaultFormatStyle;
- /// The suggested predefined style to use as the fallback style in `getStyle`.
- /// Different builds can modify the value to the preferred styles.
- extern const char *DefaultFallbackStyle;
- /// Construct a FormatStyle based on ``StyleName``.
- ///
- /// ``StyleName`` can take several forms:
- /// * "{<key>: <value>, ...}" - Set specic style parameters.
- /// * "<style name>" - One of the style names supported by
- /// getPredefinedStyle().
- /// * "file" - Load style configuration from a file called ``.clang-format``
- /// located in one of the parent directories of ``FileName`` or the current
- /// directory if ``FileName`` is empty.
- /// * "file:<format_file_path>" to explicitly specify the configuration file to
- /// use.
- ///
- /// \param[in] StyleName Style name to interpret according to the description
- /// above.
- /// \param[in] FileName Path to start search for .clang-format if ``StyleName``
- /// == "file".
- /// \param[in] FallbackStyle The name of a predefined style used to fallback to
- /// in case \p StyleName is "file" and no file can be found.
- /// \param[in] Code The actual code to be formatted. Used to determine the
- /// language if the filename isn't sufficient.
- /// \param[in] FS The underlying file system, in which the file resides. By
- /// default, the file system is the real file system.
- /// \param[in] AllowUnknownOptions If true, unknown format options only
- /// emit a warning. If false, errors are emitted on unknown format
- /// options.
- ///
- /// \returns FormatStyle as specified by ``StyleName``. If ``StyleName`` is
- /// "file" and no file is found, returns ``FallbackStyle``. If no style could be
- /// determined, returns an Error.
- llvm::Expected<FormatStyle> getStyle(StringRef StyleName, StringRef FileName,
- StringRef FallbackStyle,
- StringRef Code = "",
- llvm::vfs::FileSystem *FS = nullptr,
- bool AllowUnknownOptions = false);
- // Guesses the language from the ``FileName`` and ``Code`` to be formatted.
- // Defaults to FormatStyle::LK_Cpp.
- FormatStyle::LanguageKind guessLanguage(StringRef FileName, StringRef Code);
- // Returns a string representation of ``Language``.
- inline StringRef getLanguageName(FormatStyle::LanguageKind Language) {
- switch (Language) {
- case FormatStyle::LK_Cpp:
- return "C++";
- case FormatStyle::LK_CSharp:
- return "CSharp";
- case FormatStyle::LK_ObjC:
- return "Objective-C";
- case FormatStyle::LK_Java:
- return "Java";
- case FormatStyle::LK_JavaScript:
- return "JavaScript";
- case FormatStyle::LK_Json:
- return "Json";
- case FormatStyle::LK_Proto:
- return "Proto";
- case FormatStyle::LK_TableGen:
- return "TableGen";
- case FormatStyle::LK_TextProto:
- return "TextProto";
- default:
- return "Unknown";
- }
- }
- } // end namespace format
- } // end namespace clang
- namespace std {
- template <>
- struct is_error_code_enum<clang::format::ParseError> : std::true_type {};
- } // namespace std
- #endif // LLVM_CLANG_FORMAT_FORMAT_H
- #ifdef __GNUC__
- #pragma GCC diagnostic pop
- #endif
|