כניסה - מקוון בענן

תָכְנִית:

שֵׁם

כניסה - משנה את המראה של תוכנית C על ידי הכנסת או מחיקה של רווח לבן.

תַקצִיר

לְשַׁנֵן [אפשרויות] [קבצי קלט]

לְשַׁנֵן [אפשרויות] [קובץ קלט בודד] [קובץ פלט-o]

לְשַׁנֵן --גִרְסָה

תיאור

דף אדם זה נוצר מהקובץ indent.texinfo. זו המהדורה של "ה לְשַׁנֵן
Manual", עבור גרסת הכניסה, עודכן לאחרונה.

אל האני לְשַׁנֵן ניתן להשתמש בתוכנית כדי להפוך את הקוד לקל יותר לקריאה. זה יכול גם להמיר מאחד
סגנון כתיבת C לאחר.

לְשַׁנֵן מבין הרבה על התחביר של C, אבל הוא גם מנסה
להתמודד עם תחביר לא שלם ושגוי.

בגרסה 1.2 ובגירסאות עדכניות יותר, סגנון ההזחה של GNU הוא ברירת המחדל.

אפשרויות

-באד, --שורות-ריקות-אחרי-הצהרות
כפה שורות ריקות לאחר ההצהרות.
לִרְאוֹת BLANK קווים.

-באפ, --שורות-ריקות-אחרי-נהלים
כפה שורות ריקות לאחר גופי ההליך.
לִרְאוֹת BLANK קווים.

-בבב, --ריקות-שורות-לפני-בלוקים-תגובות
כפה שורות ריקות לפני הערות חסימה.
לִרְאוֹת BLANK קווים.

-בבו, --break-before-boolean-operator
העדיפו לשבור תורים ארוכים לפני אופרטורים בוליאניים.
לִרְאוֹת הפסקה ארוך קווים.

-לִפנֵי הַסְפִירָה, --שורות-ריקות-אחרי-פסיקים
כפה שורה חדשה אחרי פסיק בהצהרה.
לִרְאוֹת הצהרות.

-bl, --פלטה-אחרי-אם-קו
שים פלטה על שורה אחרי if, וכו '
לִרְאוֹת הצהרות.

-blf, --פלטה-אחרי-func-def-line
שים פלטה על שורה בעקבות קו הגדרת הפונקציה.
לִרְאוֹת הצהרות.

-בליn, --פלטה-שקעn
פלטה חריפה n רווחים.
לִרְאוֹת הצהרות.

-bls, --פלטה-אחרי-struct-decl-line
שימו פלטה על הקו לאחר מכן מבנה קווי הצהרה.
לִרְאוֹת הצהרות.

-br, --פלטה-על-אם-קו
שים פלטה בשורה אחת עם if, וכו '
לִרְאוֹת הצהרות.

-brf, --פלטה-על-func-def-line
שימו סוגרים על קו הגדרת הפונקציה.
לִרְאוֹת הצהרות.

-ברס, --פלטה-על-struct-decl-line
שימו פלטה מבנה שורת ההכרזה.
לִרְאוֹת הצהרות.

-bs, --ביל-שאנון, --ריק-before-sizeof
שים רווח בין גודל והטיעון שלו.
לִרְאוֹת הצהרות.

-cn, --הערה-כניסהn
שים הערות מימין לקוד בעמודה n.
לִרְאוֹת תגובות.

-cbin, --הזחית-המקרהn
פלטה לאחר תווית מארז N רווחים.
לִרְאוֹת הצהרות.

-CDn, --הצהרה-הערה-עמודהn
שים הערות מימין להצהרות בעמודה n.
לִרְאוֹת תגובות.

-cdb, --comment-delimiters-on-blank-lines
שים תוחמי הערות על שורות ריקות.
לִרְאוֹת תגובות.

-cdw, --להתכרבל-לעשות-תוך כדי
להתכרבל בזמן של do {} בזמן; ולפני '}'.
לִרְאוֹת תגובות.

-לִספִירַת הַנוֹצרִים, --חיבוק-אחר
חיבוק אחר וקודם '}'.
לִרְאוֹת תגובות.

-זֶהn, --המשך-הכנסהn
המשך הכניסה של n רווחים.
לִרְאוֹת הצהרות.

-קליn, --הכנסת מקרהn
כניסת תווית המארז של n רווחים.
לִרְאוֹת הצהרות.

-cpn, --else-endif-עמודהn
שימו הערות מימין ל #else ו #endif הצהרות בעמודה n.
לִרְאוֹת תגובות.

-ס, --רווח-אחרי-יציקה
שים רווח אחרי מפעיל שחקנים.
לִרְאוֹת הצהרות.

-dn, --שורה-הערות-הזחהn
הגדר הזחה של הערות לא מימין לקוד ל n רווחים.
לִרְאוֹת תגובות.

-bfda, --break-function-decl-args
שבור את הקו לפני כל הטיעונים בהכרזה.
לִרְאוֹת הצהרות.

-bfde, --break-function-decl-args-end
שבור את הקו אחרי הטיעון האחרון בהצהרה.
לִרְאוֹת הצהרות.

-DJ, --שמאל-הצדיק-הצהרות
אם נעשה שימוש ב-cd 0 אז הערות לאחר הצהרות נשארות מוצדקות מאחורי ה-
הצהרה.
לִרְאוֹת הצהרות.

-dun, --הכרזה-הזחהn
שים משתנים בעמודה n.
לִרְאוֹת הצהרות.

-fc1, --פורמט-ראשון-עמודה-הערות
עיצוב הערות בעמודה הראשונה.
לִרְאוֹת תגובות.

-fca, --פורמט-כל-הערות
אל תשבית את כל העיצוב של הערות.
לִרְאוֹת תגובות.

-גנו, --סגנון גנו
השתמש בסגנון קידוד GNU. זוהי ברירת המחדל.
לִרְאוֹת משותף סגנונות.

-hnl, --כבוד-שורות חדשות
העדיפו לשבור שורות ארוכות במיקום של קווים חדשים בקלט.
לִרְאוֹת הפסקה ארוך קווים.

-in, --רמת שקעn
הגדר את רמת ההזחה ל n רווחים.
לִרְאוֹת הֲזָחָה.

-הואn, --תווית-indentn
הגדר היסט עבור תוויות לעמודות n.
לִרְאוֹת הֲזָחָה.

-ipn, --פרמטר-כניסהn
הזחה סוגי פרמטרים בהגדרות פונקציות בסגנון ישן על ידי n רווחים.
לִרְאוֹת הֲזָחָה.

-kr, --ק-and-r-style
השתמש בסגנון קידוד Kernighan & Ritchie.
לִרְאוֹת משותף סגנונות.

-ln, --אורך שורהn
הגדר את אורך השורה המרבי עבור שורות ללא הערות ל n.
לִרְאוֹת הפסקה ארוך קווים.

-lcn, --אורך שורת ההערהn
הגדר את אורך השורה המקסימלי עבור עיצוב הערה ל n.
לִרְאוֹת תגובות.

-לינוקס, --- linux-style
השתמש בסגנון קידוד לינוקס.
לִרְאוֹת משותף סגנונות.

-lp, --המשך בסוגריים
המשך שורות בסוגריים.
לִרְאוֹת הֲזָחָה.

-לפי, --להשאיר-preprocessor-space
השאר רווח בין '#' להנחיית קדם-מעבד.
לִרְאוֹת הֲזָחָה.

-נבאד, --אין-שורות-ריקות-אחרי-הצהרות
אין לכפות שורות ריקות לאחר הצהרות.
לִרְאוֹת BLANK קווים.

-nbap, --אין-שורות-ריקות-אחרי-נהלים
אין לכפות שורות ריקות לאחר גופי ההליך.
לִרְאוֹת BLANK קווים.

-נבו, --break-after-boolean-operator
אל תעדיף לשבור תורים ארוכים לפני אופרטורים בוליאניים.
לִרְאוֹת הפסקה ארוך קווים.

-nbc, --אין-שורות-ריקות-אחרי-פסיקים
אין לכפות שורות חדשות אחרי פסיקים בהצהרות.
לִרְאוֹת הצהרות.

-nbfda, --dont-break-function-decl-args
אל תכניס כל ארגומנט בהצהרת פונקציה בשורה נפרדת.
לִרְאוֹת הצהרות.

-ncdb, --אין-הערות-מפרידות-על-שורות ריקות
אין לשים תוחמי הערות על שורות ריקות.
לִרְאוֹת תגובות.

-ncdw, --לא-להתכרבל-לעשות-בזמן
לא להתכרבל } ו בזמן של do {} בזמן;.
לִרְאוֹת הצהרות.

-ממנה, --לא-להתכרבל-אחרת
לא להתכרבל } ו אחר.
לִרְאוֹת הצהרות.

-ncs, --ללא-רווח-אחרי-הטלות
אין לשים רווח אחרי מפעילי השחקנים.
לִרְאוֹת הצהרות.

-ndjn, --אל שמאל-תצדיק-הצהרות
הערות לאחר הצהרות מטופלות כמו הערות לאחר הצהרות אחרות.
לִרְאוֹת הצהרות.

-nfc1, --dont-format-first-column-comments
אין לעצב הערות בעמודה הראשונה כרגיל.
לִרְאוֹת תגובות.

-nfca, --אל תפורמט-הערות
אין לעצב הערות.
לִרְאוֹת תגובות.

-ננל, --התעלם משורות חדשות
אל תעדיף לשבור שורות ארוכות במיקום של קווים חדשים בקלט.
לִרְאוֹת הפסקה ארוך קווים.

-צביטה, --אין-פרמטר-כניסה
הזחה ברוחב אפס עבור פרמטרים.
לִרְאוֹת הֲזָחָה.

-nlp, --אל תעמוד בסוגריים
אין לסדר בין סוגריים.
לִרְאוֹת הצהרות.

-npcs, --אין-רווח-אחרי-פונקציות-קריאה-שמות
אין לשים רווח אחרי הפונקציה בקריאות לפונקציות.
לִרְאוֹת הצהרות.

-nprs, --אין-רווח-אחרי-סוגריים
אין לשים רווח אחרי כל '(' ולפני כל ')'.
לִרְאוֹת הצהרות.

-npsl, --Dont-break-proced-type
שים את סוג ההליך באותה שורה כמו שמו.
לִרְאוֹת הצהרות.

-נסף, --אין-רווח-אחרי-עבור
אל תשים רווח אחרי כל ל.
לִרְאוֹת הצהרות.

-נסאי, --אין-רווח-אחרי-אם
אל תשים רווח אחרי כל if.
לִרְאוֹת הצהרות.

-נסו, --אין-רווח-לאחר-זמן
אל תשים רווח אחרי כל בזמן.
לִרְאוֹת הצהרות.

-nsc, --אל תכוכבי-הערות
אל תשים את התו '*' בצד שמאל של ההערות.
לִרְאוֹת תגובות.

-נסוב, --להשאיר שורות ריקות
אין לבלוע שורות ריקות אופציונליות.
לִרְאוֹת BLANK קווים.

-nss, --dont-space-special-punkt-פסיק
אין לכפות רווח לפני נקודה-פסיק אחרי הצהרות מסוימות. משבית את '-ss'.
לִרְאוֹת הצהרות.

-אגוז, --ללא כרטיסיות
השתמש ברווחים במקום בטאבים.
לִרְאוֹת הֲזָחָה.

-nv, --ללא מילוליות
השבת מצב מילולי.
לִרְאוֹת שונות אפשרויות.

-מקור, --מְקוֹרִי
השתמש בסגנון הקידוד המקורי של ברקלי.
לִרְאוֹת משותף סגנונות.

-npro, --התעלם מפרופיל
אל תקרא קבצי '.indent.pro'.
לִרְאוֹת מזמין לְשַׁנֵן.

-יח', --רווח-אחרי-הליך-שיחות
הכנס רווח בין שם הפרוצדורה הנקראת לבין ה-'('.
לִרְאוֹת הצהרות.

-פאיn, --הורה-indentn
ציין את ההזחה הנוספת לכל סוגריים פתוחים '(' כאשר משפט שבור. ראה
הצהרות.

-pmt, --שמר-מזמן
שמור זמני גישה ושינויים בקבצי הפלט. ראה שונות אפשרויות.

-ppin, ---preprocessor-indentationn
ציין את ההזחה עבור הצהרות מותנות לפני מעבד. ראה הֲזָחָה.

-ראשון, --רווח-אחרי-סוגריים
שים רווח אחרי כל '(' ולפני כל ')'.
לִרְאוֹת הצהרות.

-psl, --procnames-start-lines
שים את סוג ההליך על הקו לפני שמו.
לִרְאוֹת הצהרות.

-סאף, --רווח-אחרי-עבור
שים רווח אחרי כל אחד ל.
לִרְאוֹת הצהרות.

-סאי, --רווח-אחרי-אם
שים רווח אחרי כל אחד if.
לִרְאוֹת הצהרות.

-ראה, --רווח-אחרי-זמן
שים רווח אחרי כל אחד בזמן.
לִרְאוֹת הצהרות.

-sbin, --מבנה-סד-הזחהn
סוגרים חריצים של מבנה, איחוד או מנה N רווחים.
לִרְאוֹת הצהרות.

-sc, --התחלה-שמאלי-של-הערות
שים את התו '*' בצד שמאל של ההערות.
לִרְאוֹת תגובות.

-בֶּן כַּלבָּה, --בליעה-אופציונלית-שורות ריקות
לבלוע שורות ריקות אופציונליות.
לִרְאוֹת BLANK קווים.

-אס, --ספייס-ספייס-נקודה-פסיק
על קו אחד ל ו בזמן הצהרות, כפו ריק לפני נקודה-פסיק.
לִרְאוֹת הצהרות.

-רחוב, --תפוקה סטנדרטית
כתוב לפלט סטנדרטי.
לִרְאוֹת מזמין לְשַׁנֵן.

-T לספר לְשַׁנֵן שם שמות הסוג.
לִרְאוֹת הצהרות.

-טסn, --גודל כרטיסייהn
הגדר את גודל הכרטיסייה ל n רווחים.
לִרְאוֹת הֲזָחָה.

-אוט, --השתמש בכרטיסיות
השתמש בכרטיסיות. זוהי ברירת המחדל.
לִרְאוֹת הֲזָחָה.

-v, --מִלוּלִי
הפעל מצב מילולי.
לִרְאוֹת שונות אפשרויות.

-הפך
פלט את מספר הגרסה של לְשַׁנֵן.
לִרְאוֹת שונות אפשרויות.

מזמין לְשַׁנֵן

החל מגרסה 1.3, הפורמט של לְשַׁנֵן הפקודה היא:

הזחה [אפשרויות] [קבצי קלט]

הזחה [אפשרויות] [קובץ קלט יחיד] [-O קובץ פלט]

פורמט זה שונה מגרסאות קודמות וגרסאות אחרות של לְשַׁנֵן.

בטופס הראשון, מצוין קובץ קלט אחד או יותר. לְשַׁנֵן עושה עותק גיבוי של
כל קובץ, והקובץ המקורי מוחלף בגרסה המוזחה שלו. לִרְאוֹת BACKUP קבצים,
להסבר כיצד מבצעים גיבויים.

בטופס השני, צוין רק קובץ קלט אחד. במקרה זה, או כאשר התקן
נעשה שימוש בקלט, אתה יכול לציין קובץ פלט אחרי האפשרות '-o'.

לגרום לְשַׁנֵן כדי לכתוב לפלט סטנדרטי, השתמש באפשרות '-st'. זה מותר רק
כאשר יש רק קובץ קלט אחד, או כאשר נעשה שימוש בקלט הסטנדרטי.

אם אין שם של קבצי קלט, הקלט הסטנדרטי נקרא לקלט. כמו כן, אם שם קובץ
מצוין בשם '-', ואז הקלט הסטנדרטי נקרא.

כדוגמה, כל אחת מהפקודות הבאות תזין את התוכנית 'slithy_toves.c' ו
כתוב את הטקסט המוזח שלו ל-'slithy_toves.out':

כניסה slithy_toves.c -o slithy_toves.out

indent -st slithy_toves.c > slithy_toves.out

cat slithy_toves.c | indent -o slithy_toves.out

רוב האפשרויות האחרות ל לְשַׁנֵן לשלוט על אופן העיצוב של תוכניות. החל מגרסה 1.2,
לְשַׁנֵן מזהה גם שם ארוך עבור כל שם אפשרות. קידומת של אפשרויות ארוכות ב-
או '--' או '+'. [ '+' מוחלף על ידי '--' כדי לשמור על עקביות עם
תקן POSIX.]
ברוב המסמך הזה משתמשים בשמות הקצרים המסורתיים למען הקיצור.
לִרְאוֹת אוֹפְּצִיָה סיכום, לרשימת אפשרויות, כולל שמות ארוכים וקצרים כאחד.

הנה דוגמה נוספת:

indent -br test/metabolism.c -l85

זה יכניס את התוכנית 'test/metabolism.c' באמצעות האפשרויות '-br' ו-'-l85', כתוב
הפלט בחזרה אל 'test/metabolism.c', וכתוב את התוכן המקורי של
'test/metabolism.c' לקובץ גיבוי בספריה 'test'.

קריאות מקבילות באמצעות שמות אפשרויות ארוכים עבור דוגמה זו יהיו:

indent --braces-on-if-line --line-length185 test/metabolism.c

כניסה +פלטה-על-אם-קו +קו-אורך185 test/metabolism.c

אם אתה מגלה שאתה משתמש לעתים קרובות לְשַׁנֵן עם אותן אפשרויות, אתה יכול לשים את האפשרויות האלה
לתוך קובץ בשם '.indent.pro'. לְשַׁנֵן יחפש קובץ פרופיל בשלושה מקומות.
ראשית הוא יבדוק את משתנה הסביבה INDENT_PROFILE. אם זה קיים הערך שלו הוא
צפוי לתת שם לקובץ שבו יש להשתמש. אם משתנה הסביבה אינו קיים,
הכניסה מחפשת את '.indent.pro' בספרייה הנוכחית
והשתמש בזה אם נמצא. סוף כל סוף לְשַׁנֵן יחפש בספריית הבית שלך את '.indent.pro'
והשתמש בקובץ הזה אם הוא נמצא. התנהגות זו שונה מזו של גרסאות אחרות
of לְשַׁנֵן, אשר טוענים את שני הקבצים אם שניהם קיימים.

הפורמט של '.indent.pro' הוא פשוט רשימה של אפשרויות, בדיוק כפי שהן יופיעו ב-
שורת פקודה, מופרדת על ידי רווח לבן (טאבים, רווחים ושורות חדשות). אפשרויות ב
'.indent.pro' עשוי להיות מוקף בהערות C או C++, ובמקרה זה מתעלמים מהן.

מתגי שורת הפקודה מטופלים לאחר מעבד '.indent.pro'. אפשרויות שצוינו מאוחר יותר
לעקוף ארגומנטים שצוינו קודם לכן, למעט חריג אחד: אפשרויות שצוינו במפורש
תמיד תעקוף אפשרויות רקע (ראה משותף סגנונות). אפשר למנוע לְשַׁנֵן החל מ-
קריאת קובץ '.indent.pro' על ידי ציון האפשרות '-npro'.

BACKUP קבצים

החל מגרסה 1.3, GNU לְשַׁנֵן מייצר קבצי גיבוי בסגנון גנו, בדיוק כמו ש-GNU Emacs עושה.
זה אומר שגם פשוט or ממוספר ניתן ליצור גיבוי של שמות קבצים.

שמות קבצי גיבוי פשוטים נוצרים על ידי הוספת סיומת לשם הקובץ המקורי.
ברירת המחדל של סיומת זו היא המחרוזת '~' (tilde) בת תו אחד. לפיכך, הגיבוי
הקובץ עבור 'python.c' יהיה 'python.c~'.

במקום ברירת המחדל, תוכל לציין כל מחרוזת כסיומת על ידי הגדרת הסביבה
משתנה SIMPLE_BACKUP_SUFFIX לסיומת המועדפת עליך.

גרסאות גיבוי ממוספרות של קובץ 'momeraths.c' נראות כמו 'momeraths.c.~23~', כאשר 23 הוא
הגרסה של הגיבוי הספציפי הזה. בעת ביצוע גיבוי ממוספר של הקובץ
'src/momeraths.c', קובץ הגיבוי יקבל את השם 'src/momeraths.c.~V~', איפה V אחד
גדול מהגרסה הגבוהה ביותר הקיימת כעת בספרייה 'src'. ה
משתנה הסביבה VERSION_WIDTH שולט במספר הספרות, באמצעות ריפוד אפס שמאלי
כשצריך. לדוגמה, הגדרת משתנה זה ל-"2" תוביל לקובץ הגיבוי
מכונה 'momeraths.c.~04~'.

סוג קובץ הגיבוי שנעשה נשלט על ידי הערך של משתנה הסביבה
VERSION_CONTROL. אם זו המחרוזת 'פשוטה', אז יבוצעו גיבויים פשוטים בלבד. אם
הערך שלו הוא המחרוזת 'ממוספרת', ואז יבוצעו גיבויים ממוספרים. אם ערכו הוא
'קיים ממוספר', אז יבוצעו גיבויים ממוספרים אם יש כְּבָר להתקיים ממוספר
גיבויים לקובץ המוזז; אחרת, נעשה גיבוי פשוט. אם
VERSION_CONTROL לא מוגדר, אם כך לְשַׁנֵן מניח את ההתנהגות של 'מספר-קיים'.

גרסאות אחרות של לְשַׁנֵן השתמש בסיומת '.BAK' במתן שמות לקבצי גיבוי. התנהגות זו יכולה
לחקות על ידי הגדרה SIMPLE_BACKUP_SUFFIX אל '.BAK'.

שימו לב גם שגרסאות אחרות של לְשַׁנֵן בצע גיבויים בספרייה הנוכחית, במקום
בספרייה של קובץ המקור בתור GNU לְשַׁנֵן עכשיו עושה.

משותף סגנונות

ישנם מספר סגנונות נפוצים של קוד C, כולל סגנון GNU, Kernighan &
סגנון ריצ'י, וסגנון ברקלי המקורי. ניתן לבחור סגנון עם סינגל
רקע option, אשר מציינת קבוצת ערכים עבור כל האפשרויות האחרות. למרות זאת,
אפשרויות שצוינו במפורש תמיד עוקפות אפשרויות המשתמעות מאופציית רקע.

נכון לגרסה 1.2, סגנון ברירת המחדל של GNU לְשַׁנֵן הוא סגנון GNU. לפיכך, זה לא
נדרש זמן רב יותר כדי לציין את האפשרות '-gnu' כדי להשיג את הפורמט הזה, למרות שעושים זאת
לא יגרום לשגיאה. הגדרות האפשרויות המתאימות לסגנון GNU הן:

-nbad -bap -nbc -bbo -bl -bli2 -bls -ncdb -nce -cp1 -cs -di2
-ndj -nfc1 -nfca -hnl -i2 -ip5 -lp -pcs -nprs -psl -saf -sai
-מסור -nsc -nsob

סגנון הקידוד של GNU הוא זה המועדף על ידי פרויקט GNU. זה הסגנון שהגנו
מצב C של Emacs מעודד ואשר משמש בחלקי C של GNU Emacs. (אֲנָשִׁים
המעוניינים בכתיבת תוכניות עבור פרויקט גנו צריכים לקבל עותק של "קידוד גנו
סטנדרטים", המכסה גם בעיות סמנטיות וניידות כמו שימוש בזיכרון, ה
גודל של מספרים שלמים וכו')

סגנון Kernighan & Ritchie משמש בכל ספרם הידוע "The C Programming
שפה". היא מופעלת עם אפשרות '-kr'. סגנון Kernighan & Ritchie
מתאים לסט האפשרויות הבא:

-nbad -bap -bbo -nbc -br -brs -c33 -cd33 -ncdb -ce -ci4 -cli0
-cp33 -cs -d0 -di1 -nfc1 -nfca -hnl -i4 -ip0 -l75 -lp -npcs
-nprs -npsl -saf -sai -saw -nsc -nsob -nss

סגנון Kernighan & Ritchie לא שם הערות מימין לקוד באותה עמודה ב
כל הזמנים (גם הוא לא משתמש רק ברווח אחד מימין לקוד), אז לסגנון הזה
לְשַׁנֵן בחר באופן שרירותי בעמודה 33.

הסגנון של ברקלי המקורי לְשַׁנֵן ניתן להשיג על ידי ציון '-orig' (או על ידי
ציון '--original', תוך שימוש בשם האופציה הארוך). סגנון זה שווה ערך ל-
ההגדרות הבאות:

-nbad -nbap -bbo -bc -br -brs -c33 -cd33 -cdb -ce -ci4 -cli0
-cp33 -di16 -fc1 -fca -hnl -i4 -ip4 -l75 -lp -npcs -nprs -psl
-saf -sai -saw -sc -nsob -nss -ts8

סגנון לינוקס משמש בקוד ליבת לינוקס ובמנהלי התקנים. בדרך כלל יש לעקוב אחר הקוד
סגנון הקידוד של לינוקס שיתקבל. סגנון זה שווה ערך לסגנון הבא
הגדרות:

-nbad -bap -nbc -bbo -hnl -br -brs -c33 -cd33 -ncdb -ce -ci4
-cli0 -d0 -di1 -nfc1 -i8 -ip0 -l80 -lp -npcs -nprs -npsl -sai
-saf -saw -ncs -nsc -sob -nfca -cp33 -ss -ts8 -il1

BLANK קווים

סגנונות תכנות שונים משתמשים בשורות ריקות במקומות שונים. לְשַׁנֵן יש מספר של
אפשרויות להוספה או מחיקה של שורות ריקות במקומות ספציפיים.

האפשרות '-רע' גורמת לְשַׁנֵן לכפות שורה ריקה אחרי כל גוש הצהרות.
האפשרות '-nbad' גורמת לְשַׁנֵן לא לכפות שורות ריקות כאלה.

האפשרות '-bap' מאלצת שורה ריקה לאחר כל גוף הליך. האפשרות '-nbap'
לא מכריח שורה ריקה כזו.

האפשרות '-bbb' מאלצת שורה ריקה לפני כל הערה בתיבה (ראה תגובות.) ה
אפשרות '-nbbb' לא כופה שורות ריקות כאלה.

אפשרות ה-'-sob' גורמת לְשַׁנֵן לבלוע שורות ריקות אופציונליות (כלומר, כל אופציונלי
שורות ריקות הקיימות בקלט יוסרו מהפלט). אם ה'-nsob' הוא
שצוין, כל השורות הריקות הקיימות בקובץ הקלט יועתקו לקובץ הפלט.

--שורות-ריקות-אחרי-הצהרות

האפשרות '-bad' מאלצת שורה ריקה לאחר כל גוש הצהרות. ה-'-nbad'
אפשרות לא מוסיפה שורות ריקות כאלה.

למשל, בהתחשב בקלט
char *foo;
char *בר;
/* זה מפריד בין בלוקים של הצהרות. */
int baz;

לְשַׁנֵן -באד ייצור

char *foo;
char *בר;

/* זה מפריד בין בלוקים של הצהרות. */
int baz;

ו לְשַׁנֵן -נבאד ייצור

char *foo;
char *בר;
/* זה מפריד בין בלוקים של הצהרות. */
int baz;

--שורות-ריקות-אחרי-נהלים

האפשרות '-bap' מאלצת שורה ריקה לאחר כל גוף הליך.

למשל, בהתחשב בקלט

int
פו ()
{
puts("היי");
}
/* סרגל ההליכים אפילו פחות מעניין. */
char *
בר ()
{
puts("שלום");
}

לְשַׁנֵן -באפ ייצור

int
פו ()
{
מכניס ("היי");
}

/* סרגל ההליכים אפילו פחות מעניין. */
char *
בר ()
{
מכניס ("שלום");
}

ו לְשַׁנֵן -nbap ייצור

int
פו ()
{
מכניס ("היי");
}
/* סרגל ההליכים אפילו פחות מעניין. */
char *
בר ()
{
מכניס ("שלום");
}

לא תתווסף שורה ריקה לאחר ההליך Foo.

תגובות

לְשַׁנֵן פורמט הערות C וגם C++. הערות C מתחילות ב-'/*', מסתיימות ב-
'*/' ועשויים להכיל תווים בשורה חדשה. הערות C++ מתחילות במפריד '//' ו
להסתיים בקו החדש.

לְשַׁנֵן מטפל בהערות בצורה שונה בהתאם להקשר שלהן. לְשַׁנֵן ניסיונות
להבחין בין הערות הבאות הצהרות, הערות הבאות הצהרות,
הערות בעקבות הנחיות קדם-מעבד, והערות שלא מקדימות אותן בקוד של
כל סוג, כלומר, הם מתחילים את הטקסט של השורה (אם כי לא בהכרח בעמודה 1).

לְשַׁנֵן עוד מבחין בין הערות שנמצאו מחוץ להליכים ומצטברים,
ואלה שנמצאו בתוכם. בפרט, הערות המתחילות שורה שנמצאת בתוך a
ההליך יוזחה לעמודה שבה הקוד מוכנס כעת. ה
חריגה לכך היא הערה שמתחילה בעמודה השמאלית ביותר; הערה כזו היא פלט
בעמוד ההוא.

לְשַׁנֵן ניסיונות לעזוב התאגרף הערות ללא שינוי. הרעיון הכללי של הערה כזו הוא
שהוא מוקף במלבן או ''קופסה'' של כוכבים או מקפים כדי לייחד אותו חזותית.
ליתר דיוק, הערות מקופסאות מוגדרות ככאלו שבהן עוקבים אחרי ה-'/*' הראשוני
מיד על ידי התווים '*', '=', '_' או '-', או אלה שבהם ההתחלה
מפריד הערות ('/*') נמצא על שורה בפני עצמה, והשורה הבאה מתחילה ב-'*'
באותה עמודה כמו הכוכב של תוחם הפתיחה.

דוגמאות להערות בקופסה הן:

/********************
* תגובה בקופסה!! *
***********************/

/*
* ריח מסוג אחר,
* להערה מסוג אחר.
*/

לְשַׁנֵן מנסה להשאיר הערות בקופסה בדיוק כפי שהן נמצאות בקובץ המקור.
לפיכך הזחה של ההערה אינה משתנה, ואורכה אינו נבדק בכל
דֶרֶך. השינוי היחיד שנעשה הוא שניתן להמיר תו טאב מוטבע ל-
מספר מקומות מתאים.

אם תצוין האפשרות '-bbb', לפני כל ההערות הקופסאות הללו יופיע ריק
שורה, אלא אם קודם להערה כזו.

תגובות שאינן תגובות בתיבה עשויות להיות מעוצבות, מה שאומר שהשורה היא
שבור כדי להתאים בשוליים ימניים ומלא משמאל ברווח לבן. שורות חדשות בודדות הן
שוות ערך לרווח, אבל שורות ריקות (שתי שורות חדשות או יותר ברציפות) נחשבות ל-a
מעבר לפסקה. עיצוב של הערות שמתחילות לאחר הפעלת העמודה הראשונה
עם האפשרות '-fca'. כדי לעצב את אלה שמתחילים בעמודה הראשונה, ציין '-fc1'. כגון
העיצוב מושבת כברירת מחדל.

השוליים הימניים לעיצוב כברירת מחדל הם 78, אך ניתן לשנות את האפשרות '-lc'.
אם השוליים שצוינו אינם מאפשרים להדפיס את ההערה, השוליים יהיו
הוארך אוטומטית למשך ההערה. השוליים לא מכבדים אם
ההערה אינה בפורמט.

אם ההערה מתחילה שורה (כלומר, אין טקסט תוכנית משמאל לה), היא תהיה
הוזחה לעמודה שבה היא נמצאה, אלא אם כן ההערה נמצאת בתוך גוש קוד. ב
במקרה זה, הערה כזו תהיה מיושרת עם הקוד המוזח של אותו בלוק (אלא אם כן
התגובה התחילה בעמודה הראשונה). יישור זה עשוי להיות מושפע מהאפשרות '-d',
אשר מפרט סכום שבו הערות כאלה מועברות ל- עזבו, או ללא שקע.
לדוגמה, '-d2' מציב הערות שני רווחים משמאל לקוד. כברירת מחדל, הערות
מיושרים עם קוד, אלא אם הם מתחילים בעמודה הראשונה, ובמקרה זה הם נשארים
שם כברירת מחדל --- כדי ליישר אותם עם הקוד, ציין '-fc1'.

הערות מימין לקוד יופיעו כברירת מחדל בעמודה 33. ייתכן שהדבר ישתנה
עם אחת משלוש אפשרויות. '-c' יציין את העמודה עבור הערות בעקבות קוד,
'-cd' מציין את העמודה להערות בעקבות הצהרות, ו-'-cp' מציין את
עמודה להערות בעקבות הנחיות קדם-מעבד #else ו #endif. '-dj' ביחד
עם '-cd0' ניתן להשתמש כדי לדכא יישור הערות לימין ההצהרות,
מה שגורם להערה לעקוב אחר טאבסטאפ אחד מסוף ההצהרה. בדרך כלל '-cd0'
גורם ל-'-c' להפוך לאפקטיבי.

אם הקוד משמאל להערה חורג מעמודת ההתחלה, עמודת ההערה
יורחב לעמודת ה-tabstop הבאה אחרי סוף הקוד, או במקרה של
הנחיות קדם-מעבד, לרווח אחד אחרי סוף ההנחיה. הארכה זו נמשכת
רק עבור הפלט של ההערה הספציפית הזו.

האפשרות '-cdb' מציבה את תווי ההערות על שורות ריקות. לפיכך, שורה אחת
תגובה לייק /* לאהוב לחבק */ ניתן להפוך ל:

/*
חיבוק אוהב
*/

ניתן להציב כוכבים בתחילת הערות מרובות שורות עם האפשרות '-sc'. לכן,
ניתן להפוך את ההערה בשורה אחת למעלה (עם '-cdb -sc') ל:

/*
* חיבוק אוהב
*/

הצהרות

האפשרות '-br' או '-bl' מציינת כיצד לעצב סוגרים.

האפשרות '-br' פורמטת סוגריים של הצהרות כך:

if (x > 0) {
איקס--;
}

האפשרות '-bl' מעצבת אותם כך:

אם (x > 0)
{
איקס--;
}

אם אתה משתמש באפשרות '-bl', ייתכן שתרצה גם לציין את האפשרות '-bli'. אפשרות זו
מציין את מספר הרווחים שבאמצעותם יוזחו הסוגרים. '-bli2', ברירת המחדל, נותן
התוצאה המוצגת למעלה. '-bli0' מביא לתוצאות הבאות:

אם (x > 0)
{
איקס--;
}

אם אתה משתמש באפשרות '-br', כנראה שתרצה להשתמש גם באפשרות '-ce'. זֶה
גורם אחר במבנה אם-אז-אחר להתרפק על הקודמת מיד
'}'. לדוגמה, עם '-br -ce' אתה מקבל את הדברים הבאים:

if (x > 0) {
איקס--;
אחר} {
fprintf (stderr, "...משהו לא בסדר?\n");
}

עם '-br -nce' הקוד הזה יופיע בתור

if (x > 0) {
איקס--;
}
אחר {
fprintf (stderr, "...משהו לא בסדר?\n");
}

זה גורם ל בזמן בלולאת עשה תוך כדי להתרפק על ה-'}' שלפניו.
לדוגמה, עם '-cdw' אתה מקבל את הדברים הבאים:

עשה {
איקס--;
} בעוד (x);

עם '-ncdw' הקוד הזה יופיע בתור

עשה {
איקס--;
}
בעוד (x);

האפשרות '-cli' מציינת את מספר הרווחים שאליהם יש להכניס את תוויות המקרים
זכות המכיל להחליף הצהרה.

ברירת המחדל נותנת קוד כמו:

מתג (i)
{
מקרה 0:
לשבור;
מקרה 1:
{
++i;
}
ברירת מחדל:
לשבור;
}

שימוש ב-'-cli2' שיהפוך ל:

מתג (i)
{
מקרה 0:
לשבור;
מקרה 1:
{
++i;
}
ברירת מחדל:
לשבור;
}

ניתן לשלוט בהזחה של הסוגרים מתחת למשפט מקרה באמצעות ה-'-cbin"
אוֹפְּצִיָה. לדוגמה, שימוש ב-'-cli2 -cbi0' מביא ל:

מתג (i)
{
מקרה 0:
לשבור;
מקרה 1:
{
++i;
}
ברירת מחדל:
לשבור;
}

אם נקודה-פסיק נמצא באותו קו כמו a ל or בזמן הצהרה, האפשרות '-ss' תהיה
לגרום לרווח להיות ממוקם לפני נקודה-פסיק. זה מדגיש את הנקודה-פסיק, מה שהופך אותו
ברור כי הגוף של ל or בזמן הצהרה היא אמירה ריקה. '-nss' משבית
תכונה זו.

האפשרות '-pcs' גורמת למקם רווח בין שם ההליך
נקרא וה-'(' (לדוגמה, מעמיד ("היי");. האפשרות '-npcs' תיתן
puts("היי");).

אם מצוינת האפשרות '-cs', לְשַׁנֵן מציב רווח בין מפעיל שחקנים לבין
חפץ לליהוק. ה-'-ncs' מבטיח שאין רווח בין מפעיל ה-cast לבין
האובייקט. זכור את זה לְשַׁנֵן יודע רק על סוגי הנתונים הסטנדרטיים של C ולכן לא יכול
לזהות טיפוסים המוגדרים על ידי המשתמש בהטלות. לכן (הטיפוס שלי) דבר לא מתייחסים אליו כאל צוות שחקנים.

האפשרות '-bs' מבטיחה שיש רווח בין מילת המפתח גודל ו שלה
טַעֲנָה. בגרסאות מסוימות, זה ידוע בתור האפשרות 'Bill_Shannon'.

האפשרות '-saf' מאלצת רווח בין א ל והסוגריים הבאים. זה
ברירת המחדל.

האפשרות '-sai' מאלצת רווח בין א if והסוגריים הבאים. זה
ברירת המחדל.

אפשרות ה-'-saw' מאלצת רווח בין א בזמן והסוגריים הבאים. זה
ברירת המחדל.

האפשרות '-prs' גורמת להפרדה של כל הסוגריים ברווח מכל מה שיש
ביניהם. לדוגמה, שימוש ב-'-prs' תוצאות בקוד כמו:

while ( ( e_code - s_code ) < ( dec_ind - 1 ) )
{
set_buf_break ( bb_dec_ind );
*e_code++ = ' ';
}

הצהרות

כברירת מחדל לְשַׁנֵן יסדר מזהים, בעמודה המצוינת על ידי האפשרות '-di'.
לדוגמה, '-di16' גורם לדברים להיראות כך:

int foo;
char *בר;

ניתן להשתמש בערך קטן (כגון אחד או שניים) עבור האפשרות '-di' כדי לגרום ל-
מזהים שיוצבו במיקום הזמין הראשון; לדוגמה:

int foo;
char *בר;

הערך שניתן לאפשרות '-di' עדיין ישפיע על משתנים שמוגדרים בנפרד
שורות מהסוגים שלהם, למשל '-di2' יובילו ל:

int
פו

אם מצוינת האפשרות '-bc', שורה חדשה נאלצת לאחר כל פסיק בהצהרה.
לדוגמה,

תוך א,
b,
c;

עם האפשרות '-nbc' זה ייראה

int a, b, c;

האפשרות '-bfda' גורמת לכפיית שורה חדשה לאחר הפסיק המפריד בין הטיעונים
של הצהרת פונקציה. הארגומנטים יופיעו ברמת כניסה אחת עמוק יותר מ
הצהרת הפונקציה. זה מועיל במיוחד עבור פונקציות עם ארגומנט ארוך
רשימות. האפשרות '-bfde' גורמת לאלץ שורה חדשה לפני סוגר הסגירה של
הצהרת פונקציה. עבור שתי האפשרויות ההגדרה 'n' היא ברירת המחדל: -nbdfa ו-nbdfe.

לדוגמה,

void foo (int arg1, char arg2, int *arg3, long arg4, char arg5);
עם האפשרות '-bfda' זה ייראה

void foo (
int arg1,
char arg2,
int *arg3,
ארוך arg4,
char arg5);

עם, בנוסף, האפשרות '-bfde' כך זה ייראה

void foo (
int arg1,
char arg2,
int *arg3,
ארוך arg4,
char arg5
);

האפשרות '-psl' גורמת להצבת סוג ההליך המוגדר על הקו
לפני שם ההליך. סגנון זה נדרש עבור etags תוכנית לעבוד
נכון, כמו גם חלק מה מצב c פונקציות של Emacs.

עליך להשתמש באפשרות '-T' כדי לדעת לְשַׁנֵן השם של כל שמות הטיפוס בתוכנית שלך
המוגדרים על ידי typedef. ניתן לציין '-T' יותר מפעם אחת, ואת כל השמות
המפורטים משמשים. לדוגמה, אם התוכנית שלך מכילה

typedef לא חתום ארוך CODE_ADDR;
typedef enum {אדום, כחול, ירוק} COLOR;

תשתמש באפשרויות '-T CODE_ADDR -T COLOR'.

האפשרות '-brs' או '-bls' מציינת כיצד לעצב סוגרים בסוגריים בהצהרות struct. ה
האפשרות '-brs' פורמטת סוגרים כמו זה:

struct foo {
int x;
};

האפשרות '-bls' מעצבת אותם כך:

struct foo
{
int x;
};

בדומה לאפשרויות המבנה '-brs' ו-'-bls',
אפשרויות הפלטה של ​​הפונקציות '-brf' או '-blf' מציינות כיצד לעצב את הסוגרים בפונקציה
הגדרות. האפשרות '-brf' מעצבת סוגריים מסוג זה:

int one(void) {
1 לחזור;
};

האפשרות '-blf' מעצבת אותם כך:

int one (void)
{
1 לחזור;
};

הֲזָחָה

בעיה אחת בעיצוב הקוד היא עד כמה יש להכניס כל שורה משמאל
שולים. כאשר תחילתה של אמירה כגון if or ל הוא נתקל, ה
רמת ההזחה מוגברת בערך שצוין על ידי האפשרות '-i'. לדוגמה,
השתמש ב-'-i8' כדי לציין הזחה של שמונה תווים עבור כל רמה. כאשר אמירה היא
שבור על פני שני קווים, השורה השניה מסומנת על ידי מספר רווחים נוספים
שצוין על ידי האפשרות '-ci'. ברירת המחדל של '-ci' היא 0. עם זאת, אם האפשרות '-lp' היא
שצוין, ולקו יש סוגריים שמאלי שאינו סגור על הקו הזה, אם כן
קווי המשך יהיו בשורה כדי להתחיל במיקום התו ממש אחרי השמאלי
מַאֲמָר מוּסְגָר. עיבוד זה חל גם על '[' וחל על '{' כאשר הוא מתרחש ב
רשימות אתחול. לדוגמה, קטע קוד המשך עשוי להיראות כך עם
'-nlp -ci3' בתוקף:

p1 = first_procedur (שני_הליך (p2, p3),
third_procedur (p4, p5));

עם '-lp' למעשה, הקוד נראה קצת יותר ברור:

p1 = first_procedur (שני_הליך (p2, p3),
third_procedur (p4, p5));

כאשר הצהרה מחולקת בין שני זוגות אב או יותר (...), כל זוג נוסף
גורם להזחה נוספת ברמת ההזחה:

אם ((((i < 2 &&
k > 0) || p == 0) &&
q == 1) ||
n = 0)

האפשרות '-ipN' ניתן להשתמש כדי להגדיר את ההיסט הנוסף לכל אב. לדוגמה, '-ip0'
יעצב את האמור לעיל כ:

אם ((((i < 2 &&
k > 0) || p == 0) &&
q == 1) ||
n = 0)

לְשַׁנֵן מניח שכרטיסיות ממוקמות במרווחי זמן קבועים של קלט ופלט כאחד
זרמי תווים. מרווחים אלה הם כברירת מחדל ברוחב של 8 עמודות, אך (נכון לגרסה 1.2)
ניתן לשנות על ידי האפשרות '-ts'. לטאבים מתייחסים כמספר המקביל של רווחים.

ההזחה של הצהרות סוגים בהגדרות פונקציות בסגנון ישן נשלטת על ידי
הפרמטר '-ip'. זהו פרמטר מספרי המציין כמה רווחים להכנס
הצהרות סוג. לדוגמה, ברירת המחדל '-ip5' גורמת להגדרות להיראות כך:

char *
יצירת_עולם (x, y, קנה מידה)
int x;
int y;
סולם צף;
{
. . .
}

עבור תאימות עם גרסאות אחרות של הכניסה, ניתנת האפשרות '-nip', כלומר
שווה ערך ל-'-ip0'.

ANSI C מאפשר למקם רווח לבן בשורות הפקודה הקדם-מעבד בין התו
'#' ושם הפקודה. כברירת מחדל, לְשַׁנֵן מסיר את הרווח הזה, אך מציין את
אפשרות '-lps' מכוונת לְשַׁנֵן כדי להשאיר את המרחב הזה ללא שינוי. האפשרות '-ppi' עוקפת
'-nlps' ו-'-lps'.

ניתן להשתמש באפשרות זו כדי לבקש שיהיו הצהרות מותנות מראש לעיבוד
הוזחה על ידי למספר נתון של רווחים, למשל עם האפשרות '-ppi 3'

#אם X
#אם Y
#define Z 1
#else
#define Z 0
#endif
#endif
הופך להיות
#אם X
# אם Y
# תגדיר Z 1
# אחר
# תגדיר Z 0
# אנדיף
#endif

אפשרות זו מגדירה את ההיסט שבו תוצב תווית (למעט תוויות מארזים). אם
הוא מוגדר לאפס או למספר חיובי, זה מציין עד כמה רחוק מהשוליים השמאליים
להכניס תווית. אם הוא מוגדר למספר שלילי, זה מציין כמה רחוק אחורה מה-
רמת הכניסה הנוכחית כדי למקם את התווית. הגדרת ברירת המחדל היא -2 התואמת את
התנהגות של גרסאות קודמות של הכניסה. שימו לב שפרמטר זה אינו משפיע על
הצבת תוויות מארז; ראה את הפרמטר '-cli' עבור זה. למשל עם האופציה
'-איל 1'

קבוצה
פוּנקצִיָה()
{
if (do_stuff1() == ERROR)
goto cleanup1;

if (do_stuff2() == ERROR)
goto cleanup2;

להחזיר SUCCESS;

ניקוי 2:
do_cleanup2();

ניקוי 1:
do_cleanup1();

החזר שגיאה;
}
הופך להיות
קבוצה
פוּנקצִיָה()
{
if (do_stuff1() == ERROR)
goto cleanup1;

if (do_stuff2() == ERROR)
goto cleanup2;

להחזיר SUCCESS;

ניקוי 2:
do_cleanup2();

ניקוי 1:
do_cleanup1();

החזר שגיאה;
}

הפסקה ארוך קווים

עם האפשרות '-ln', או '--אורך שורהn', אפשר לציין את האורך המקסימלי
של שורת קוד C, לא כולל הערות אפשריות שאחריו.

כאשר הקווים נעשים ארוכים יותר מאורך השורה שצוין, GNU לְשַׁנֵן מנסה לשבור את
קו במקום הגיוני. זה חדש נכון לגרסה 2.1 עם זאת ולא אינטליגנטי במיוחד
או גמיש עדיין.

נכון לעכשיו ישנן שתי אפשרויות המאפשרות לאחת להפריע לאלגוריתם
קובע היכן לפרוץ קו.

האפשרות '-bbo' גורמת ל-GNU לְשַׁנֵן להעדיף לשבור תורים ארוכים לפני הבוליאן
מפעילי && ו ||. האפשרות '-nbbo' גורמת ל-GNU לְשַׁנֵן אין את ההעדפה הזו. ל
לדוגמה, אפשרות ברירת המחדל '-bbo' (יחד עם '--line-length60' ו-'--ignore-
newlines') גורם לקוד להיראות כך:

אם (מסכה
&& ((מסכה[0] == '\0')
|| (מסכה[1] == '\0'
&& ((מסכה[0] == '0') || (מסכה[0] == '*')))))

שימוש באפשרות '-nbbo' יגרום לזה להיראות כך:

אם (מסכה &&
((mask[0] == '\0') ||
(מסכה[1] == '\0' &&
((מסכה[0] == '0') || (מסיכה[0] == '*')))))

ברירת המחדל '-hnl', לעומת זאת, מכבדת שורות חדשות בקובץ הקלט על ידי מתן השורות הגבוהות ביותר
עדיפות אפשרית לשבור קווים ב. לדוגמה, כאשר קובץ הקלט נראה כך:

אם (מסכה
&& ((מסכה[0] == '\0')
|| (מסכה[1] == '\0' && ((מסיכה[0] == '0') || (מסיכה[0] == '*'))))))

לאחר מכן השתמש באפשרות '-hnl', או '--honour-newlines', יחד עם הקודם
שהוזכרו '-nbbo' ו-'--line-length60', יגרמו לכך שהפלט לא יהיה מה שניתן ב-
הדוגמה האחרונה אך במקום זאת יעדיף לשבור במקומות שבהם היה הקוד
שבור בקובץ הקלט:

אם (מסכה
&& ((מסכה[0] == '\0')
|| (מסכה[1] == '\0' &&
((מסכה[0] == '0') || (מסיכה[0] == '*')))))

הרעיון מאחורי אפשרות זו הוא ששורות ארוכות מדי, אבל כבר מפורקות,
גנו לא יגע לְשַׁנֵן. צריך להריץ קוד ממש מבולגן לְשַׁנֵן at
עם זאת, לפחות פעם אחת באמצעות האפשרות '--ignore-newlines'.

השבתה עיצוב

עיצוב של קוד C עשוי להיות מושבת עבור חלקים של תוכנית על ידי הטבעה מיוחדת
לִשְׁלוֹט הערות בתוכנית. כדי לבטל את העיצוב עבור חלק בתוכנית, מקם
הערת הבקרה מנטרלת /* *הכנסת קצה* */ על קו בפני עצמו רגע לפני כן
סָעִיף. טקסט תוכנית שנסרק לאחר הערת בקרה זו מופלט בדיוק כקלט
ללא שינויים עד שההערה המאפשרת המתאימה תיסרק על קו על ידי
עצמו. הערת הבקרה להשבית היא /* *INDENT-ON* */, וכל טקסט בעקבות ה-
ההערה על השורה גם היא פלט ללא פורמט. העיצוב מתחיל שוב עם הקלט
שורה אחרי הערת הבקרה המאפשרת.

לייתר דיוק, לְשַׁנֵן אינו מנסה לאמת את המפריד הסוגר (*/) עבור אלה C
הערות, וכל רווח לבן על הקו שקוף לחלוטין.

הערות הבקרה הללו מתפקדות גם בפורמטים C++ שלהן, כלומר // *הכנסת קצה* ו //
*INDENT-ON*.

יש לציין כי המצב הפנימי של לְשַׁנֵן נשאר ללא שינוי במהלך
החלק הלא מעוצב. כך, למשל, כיבוי העיצוב באמצע א
פונקציה והמשך לאחר סיום הפונקציה עלול להוביל לתוצאות מוזרות. זה
לכן נבון להיות מודולרי במידת מה בבחירת קוד שיישאר ללא פורמט.

כהערה היסטורית, כמה גרסאות קודמות של לְשַׁנֵן הופיעו הודעות שגיאה מתחילות
עם *לְשַׁנֵן**. גרסאות אלה של לְשַׁנֵן נכתבו כדי להתעלם מכל שורות טקסט קלט
שהתחיל בהודעות שגיאה כאלה. הסרתי את תכונת העריות הזו מגנו
לְשַׁנֵן.

שונות אפשרויות

כדי לגלות איזו גרסה של לְשַׁנֵן יש לך, השתמש בפקודה לְשַׁנֵן -הפך. זה יהיה
דווח על מספר הגרסה של לְשַׁנֵן, מבלי לבצע שום עיבוד רגיל.

ניתן להשתמש באפשרות '-v' כדי להפעיל מצב מילולי. במצב מילולי, לְשַׁנֵן דיווחים
כאשר הוא מפצל שורה אחת של קלט לעוד שתי שורות פלט נוספות, ונותן גודל מסוים
סטטיסטיקה בסיום.

האפשרות '-pmt' גורמת לְשַׁנֵן כדי לשמור על זמני הגישה והשינוי ב-
קבצי פלט. לשימוש באפשרות זו יש את היתרון שהפעלת הכניסה על כל המקור ו
קבצי כותרות בפרויקט לא יגרמו לעשות לבנות מחדש את כל המטרות. אפשרות זו היא בלבד
זמין במערכות הפעלה עם POSIX זמן קצר(2) פונקציה.

השתמש בהזחה מקוונת באמצעות שירותי onworks.net