InglesPransesAlemanItalyanoPortugesRusoEspanyol

OnWorks favicon

mips64el-linux-gnuabi64-gfortran-5 - Online sa Cloud

Patakbuhin ang mips64el-linux-gnuabi64-gfortran-5 sa OnWorks na libreng hosting provider sa Ubuntu Online, Fedora Online, Windows online emulator o MAC OS online emulator

Ito ang command na mips64el-linux-gnuabi64-gfortran-5 na maaaring patakbuhin sa OnWorks na libreng hosting provider gamit ang isa sa aming maramihang libreng online na workstation gaya ng Ubuntu Online, Fedora Online, Windows online emulator o MAC OS online emulator

PROGRAMA:

NAME


gfortran - GNU Fortran compiler

SINOPSIS


gfortran [-c|-S|-E]
[-g] [-pg] [-Oantas]
[-Wbalaan...] [-pedantic]
[-Idir...] [-Ldir...]
[-Dmacro[=defn]...] [-Umacro]
[-fopsyon...]
[-mmachine-opsyon...]
[-o outfile] infile...

Ang mga pinakakapaki-pakinabang na opsyon lamang ang nakalista dito; tingnan sa ibaba para sa natitira.

DESCRIPTION


Ang gfortran Sinusuportahan ng command ang lahat ng mga opsyon na sinusuportahan ng gcc utos. Mga pagpipilian lamang
partikular sa GNU Fortran ay nakadokumento dito.

Ang lahat ng mga opsyon sa GCC at GNU Fortran ay tinatanggap pareho ng gfortran at sa pamamagitan ng gcc (pati na rin ang alinman
iba pang mga driver na binuo sa parehong oras, tulad ng g ++), mula noong idagdag ang GNU Fortran sa GCC
Ang pamamahagi ay nagbibigay-daan sa pagtanggap ng mga opsyon sa GNU Fortran ng lahat ng nauugnay na driver.

Sa ilang mga kaso, ang mga opsyon ay may positibo at negatibong anyo; ang negatibong anyo ng -ffoo gusto
be -fno-foo. Ang manwal na ito ay nagdodokumento lamang ng isa sa dalawang form na ito, alinman ang hindi ang
default.

Opsyon


Narito ang isang buod ng lahat ng mga opsyon na partikular sa GNU Fortran, na nakapangkat ayon sa uri.
Ang mga paliwanag ay nasa mga sumusunod na seksyon.

Fortran wika Options
-fall-intrinsics -fbackslash -fcray-pointer -fd-lines-as-code -fd-lines-as-comments
-fdefault-double-8 -fdefault-integer-8 -fdefault-real-8 -fdollar-ok
-nakadikit-haba-linya-n -nakadikit-linya-haba-wala -ffree-form -ffree-line-length-n
-ffree-line-length-wala -fimplicit-wala -finteger-4-integer-8 -fmax-identifier-length
-fmodule-pribado -nakadikit-anyong -fno-range-check -fopenacc -fopenmp -freal-4-real-10
-freal-4-real-16 -freal-4-real-8 -freal-8-real-10 -freal-8-real-16 -freal-8-real-4
-std=std

Nagpoproseso Options
-A-tanong[=sagutin] -Atanong=sagutin -C -CC -Dmacro[=defn] -H -P -Umacro -cpp -DD
-dI -dM -dN -dU -fworking-directory -imultilib dir -iprefix file -iquote -isysroot dir
-isystem dir -nocpp -nostdinc -undef

pagkakamali at babala Options
-Waliasing -Pader -Wampersand -Warray-bounds -Wc-binding-type -Wcharacter-truncation
-Wconversion -Wfunction-elimination -Wimplicit-interface -Wimplicit-procedure
-Witrinsic-anino -Wuse-walang-lamang -Witrinsics-std -Wline-truncation
-Wno-align-commons -Wno-tabs -Wreal-q-constant -Nakakagulat -Wunderflow
-Wunused-parameter -Wrealloc-lhs -Wrealloc-lhs-lahat -Wtarget-habang buhay -fmax-errors=n
-fsyntax-lamang -pedantic -pedantic-errors

Pag-debug Options
-fbacktrace -fdump-fortran-optimized -fdump-fortran-orihinal -fdump-parse-tree
-ffpe-trap=listahan -ffpe-summary=listahan

Directory Options
-Idir -Jdir -fintrinsic-modules-path dir

link Options
-static-libgfortran

Runtime Options
-fconvert=Conversion -fmax-subrecord-length=haba -frecord-marker=haba -fsign-zero

kodigo Henerasyon Options
-faggressive-function-elimination -fblas-matmul-limit=n -fbounds-check
-fcheck-array-temporaries -fcheck=
-fcoarray= -fexternal-blas -ff2c -ffrontend-optimize
-finit-character=n -finit-integer=n -finit-local-zero -finit-logical=
-finit-real= -fmax-array-constructor=n -fmax-stack-var-size=n
-fno-align-commons -fno-awtomatiko -fno-protect-parents -fno-underscoring
-fsecond-underscore -fpack-nagmula -frealloc-lhs -frecursive -frepack-arrays
-fshort-enums -fstack-arrays

Options pagkontrol Fortran dialect
Ang mga sumusunod na opsyon ay kumokontrol sa mga detalye ng Fortran dialect na tinatanggap ng compiler:

-ffree-form
-nakadikit-anyong
Tukuyin ang layout na ginamit ng source file. Ang layout ng libreng form ay ipinakilala sa
Fortran 90. Ang nakapirming form ay tradisyonal na ginagamit sa mas lumang mga programa ng Fortran. Kailan
walang tinukoy na opsyon, ang source form ay tinutukoy ng extension ng file.

-fall-intrinsics
Ang pagpipiliang ito ay nagiging sanhi ng lahat ng mga intrinsic na pamamaraan (kabilang ang mga extension na partikular sa GNU) sa
tanggapin. Ito ay maaaring maging kapaki-pakinabang sa -std=f95 para pilitin ang standard-compliance ngunit makuha
access sa buong hanay ng mga intrinsics na magagamit sa gfortran. Bilang kapalit,
-Witrinsics-std ay hindi papansinin at walang pamamaraang tinukoy ng gumagamit na may parehong pangalan bilang
anumang intrinsic ay tatawagin maliban kung ito ay tahasang idineklara na "EXTERNAL".

-fd-lines-as-code
-fd-lines-as-comments
Paganahin ang espesyal na paggamot para sa mga linyang nagsisimula sa "d" o "D" sa mga fixed form na pinagmulan.
Kung ang -fd-lines-as-code ang pagpipilian ay ibinigay na sila ay itinuturing na parang ang unang hanay
naglalaman ng isang blangko. Kung ang -fd-lines-as-comments ang pagpipilian ay ibinigay, sila ay itinuturing bilang
mga linya ng komento.

-fdollar-ok
Payagan $ bilang isang wastong hindi unang character sa isang pangalan ng simbolo. Mga simbolo na nagsisimula sa $ ay
tinanggihan dahil hindi malinaw kung aling mga panuntunan ang ilalapat sa implicit na pag-type bilang iba
nagpapatupad ang mga vendor ng iba't ibang panuntunan. Gamit $ sa "IMPLICIT" na mga pahayag ay tinanggihan din.

-fbackslash
Baguhin ang interpretasyon ng mga backslash sa mga literal na string mula sa iisang backslash
character sa "C-style" escape character. Ang mga sumusunod na kumbinasyon ay pinalawak
"\a", "\b", "\f", "\n", "\r", "\t", "\v", "\\", at "\0" sa mga ASCII na character
alerto, backspace, form feed, newline, carriage return, horizontal tab, vertical tab,
backslash, at NUL, ayon sa pagkakabanggit. Bukod pa rito, "\x"nn, "\u"nnnn at ikaw"nnnnnnnn
(kung saan ang bawat isa n ay isang hexadecimal digit) ay isinalin sa mga character na Unicode
naaayon sa tinukoy na mga punto ng code. Lahat ng iba pang kumbinasyon ng isang karakter
pinangungunahan ng \ ay hindi pinalawak.

-fmodule-pribado
Itakda ang default na accessibility ng mga module entity sa "PRIVATE". Kaugnay ng paggamit
hindi maa-access ang mga entity maliban kung tahasan silang idineklara bilang "PUBLIC".

-nakadikit-haba-linya-n
Itakda ang column kung saan ang mga character ay hindi papansinin sa mga tipikal na fixed-form na linya sa
source file, at kung saan ang mga puwang ay ipinapalagay (na parang may palaman sa haba na iyon) pagkatapos
ang mga dulo ng maikling fixed-form na mga linya.

Mga sikat na halaga para sa n isama ang 72 (ang pamantayan at ang default), 80 (larawan ng card), at
132 (naaayon sa mga opsyon na "extended-source" sa ilang sikat na compiler). n maaari
ding maging wala, ibig sabihin ay makabuluhan ang buong linya at ang patuloy na karakter
ang mga constant ay hindi kailanman may mga implicit na puwang na nakadugtong sa kanila upang punan ang linya.
-fixed-line-length-0 pareho ang ibig sabihin ng -nakadikit-linya-haba-wala.

-ffree-line-length-n
Itakda ang column kung saan ang mga character ay hindi papansinin sa mga tipikal na free-form na linya sa source
file. Ang default na halaga ay 132. n maaaring hindi wala, ibig sabihin ang buong linya ay
makahulugan. -ffree-line-length-0 pareho ang ibig sabihin ng -ffree-line-length-wala.

-fmax-identifier-length=n
Tukuyin ang maximum na pinapayagang haba ng identifier. Ang mga karaniwang halaga ay 31 (Fortran 95) at
63 (Fortran 2003 at Fortran 2008).

-fimplicit-wala
Tukuyin na walang implicit na pag-type ang pinapayagan, maliban kung na-override ng tahasang "IMPLICIT"
mga pahayag. Ito ang katumbas ng pagdaragdag ng "implicit none" sa simula ng bawat isa
pamamaraan.

-fcray-pointer
I-enable ang Cray pointer extension, na nagbibigay ng C-like pointer functionality.

-fopenacc
Paganahin ang mga extension ng OpenACC. Kabilang dito ang mga direktiba ng OpenACC "!$acc" sa libreng anyo
at "c$acc", *$acc at "!$acc" na mga direktiba sa fixed form, "!$" conditional compilation
mga sentinel sa libreng anyo at "c$", "*$" at "!$" na mga sentinel sa nakapirming anyo, at kapag
ang pag-link ay nagsasaayos para sa OpenACC runtime library na maiugnay.

Tandaan na isa itong pang-eksperimentong feature, hindi kumpleto, at maaaring magbago sa hinaharap
mga bersyon ng GCC. Tingnan mohttps://gcc.gnu.org/wiki/OpenACC> para sa karagdagang impormasyon.

-fopenmp
Paganahin ang mga extension ng OpenMP. Kabilang dito ang OpenMP "!$omp" na mga direktiba sa libreng anyo
at "c$omp", *$omp at "!$omp" na mga direktiba sa fixed form, "!$" conditional compilation
mga sentinel sa libreng anyo at "c$", "*$" at "!$" na mga sentinel sa nakapirming anyo, at kapag
ang pag-link ay nagsasaayos para sa OpenMP runtime library na maiugnay. Ang opsyon -fopenmp
nagpapahiwatig -frecursive.

-fno-range-check
Huwag paganahin ang pagsuri sa hanay sa mga resulta ng pagpapasimple ng mga pare-parehong expression habang
compilation. Halimbawa, ang GNU Fortran ay magbibigay ng error sa oras ng pag-compile kung kailan
pinapasimple ang "a = 1. / 0". Sa opsyong ito, walang ibibigay na error at magiging "a".
itinalaga ang value na "+Infinity". Kung ang isang expression ay nagsusuri sa isang halaga sa labas ng
nauugnay na hanay ng ["-HUGE()":"HUGE()"], pagkatapos ang expression ay papalitan ng "-Inf"
o "+Inf" kung naaangkop. Katulad nito, ang "DATA i/Z'FFFFFFFF'/" ay magreresulta sa isang integer
overflow sa karamihan ng mga system, ngunit may -fno-range-check ang halaga ay "balot sa paligid" at
Ang "i" ay magsisimula sa -1 sa halip.

-fdefault-integer-8
Itakda ang default na integer at mga lohikal na uri sa isang 8 byte na malawak na uri. Ang pagpipiliang ito din
nakakaapekto sa uri ng integer constants tulad ng 42. Unlike -finteger-4-integer-8, ginagawa nito
hindi nagpo-promote ng mga variable na may tahasang uri ng deklarasyon.

-fdefault-real-8
Itakda ang default na totoong uri sa isang 8 byte na malawak na uri. Ang pagpipiliang ito ay nakakaapekto rin sa uri ng
non-double real constants tulad ng 1.0, at nagpo-promote ng default na lapad ng "DOUBLE
PRECISION" hanggang 16 bytes kung maaari, maliban kung ang "-fdefault-double-8" ay ibinigay din. Hindi tulad ng
-freal-4-real-8, hindi ito nagpo-promote ng mga variable na may tahasang uri ng deklarasyon.

-fdefault-double-8
Itakda ang uri ng "DOUBLE PRECISION" sa isang 8 byte na malawak na uri. Walang gawin kung ito na
ang default. Kung -fdefault-real-8 ay ibinigay, "DOUBLE PRECISION" ay sa halip ay magiging
na-promote sa 16 bytes kung maaari, at -fdefault-double-8 maaaring gamitin upang maiwasan ito.
Ang uri ng mga tunay na constant tulad ng "1.d0" ay hindi babaguhin ng -fdefault-real-8 bagaman,
gayon din naman -fdefault-double-8 hindi ito nakakaapekto.

-finteger-4-integer-8
I-promote ang lahat ng "INTEGER(KIND=4)" entity sa isang "INTEGER(KIND=8)" entity. Kung "KIND=8"
ay hindi magagamit, pagkatapos ay isang error ay ibibigay. Ang pagpipiliang ito ay dapat gamitin nang may pag-iingat
at maaaring hindi angkop para sa iyong mga code. Kabilang sa mga lugar na posibleng alalahanin ang mga tawag sa
mga panlabas na pamamaraan, pagkakahanay sa "EQUIVALENCE" at/o "COMMON", mga generic na interface,
BOZ literal na patuloy na conversion, at I/O. Inspeksyon ng intermediate
representasyon ng isinalin na Fortran code, na ginawa ni -fdump-tree-orihinal, Ay
iminungkahi.

-freal-4-real-8
-freal-4-real-10
-freal-4-real-16
-freal-8-real-4
-freal-8-real-10
-freal-8-real-16
I-promote ang lahat ng "REAL(KIND=M)" entity sa "REAL(KIND=N)" entity. Kung ang "TOTOO(KIND=N)" ay
hindi magagamit, pagkatapos ay isang error ang ibibigay. Ang lahat ng iba pang tunay na uri ng uri ay hindi naaapektuhan
sa pamamagitan ng opsyong ito. Ang mga opsyon na ito ay dapat gamitin nang may pag-iingat at maaaring hindi angkop para sa
iyong mga code. Kabilang sa mga lugar na posibleng alalahanin ang mga tawag sa mga panlabas na pamamaraan, pag-align
sa "EQUIVALENCE" at/o "COMMON", mga generic na interface, BOZ literal na patuloy na conversion,
at I/O. Inspeksyon ng intermediate na representasyon ng isinalin na Fortran
code, ginawa ng -fdump-tree-orihinal, ay iminungkahi.

-std=std
Tukuyin ang pamantayan kung saan inaasahang aayon ang programa, na maaaring isa sa
f95, f2003, f2008, gnu, O pamana. Ang default na halaga para sa std is gnu, na tumutukoy
isang superset ng Fortran 95 standard na kinabibilangan ng lahat ng extension na sinusuportahan ng
GNU Fortran, bagaman ang mga babala ay ibibigay para sa mga hindi na ginagamit na extension na hindi inirerekomenda
para gamitin sa bagong code. Ang pamana katumbas ng halaga ngunit walang mga babala para sa
mga hindi na ginagamit na extension, at maaaring maging kapaki-pakinabang para sa mga lumang hindi karaniwang mga programa. Ang f95, f2003
at f2008 ang mga halaga ay tumutukoy sa mahigpit na pagsunod sa Fortran 95, Fortran 2003 at
Fortran 2008 na mga pamantayan, ayon sa pagkakabanggit; ibinibigay ang mga error para sa lahat ng extension na lampas sa
may-katuturang pamantayan ng wika, at ang mga babala ay ibinibigay para sa mga tampok na Fortran 77 na
ay pinahihintulutan ngunit luma na sa mga susunod na pamantayan. -std=f2008ts pinapayagan ang Fortran 2008
pamantayan kasama ang mga pagdaragdag ng Technical Specification (TS) 29113 sa Dagdag pa
Interoperability ng Fortran sa C at TS 18508 sa Karagdagang Parallel Features sa
Fortran.

Paganahin at ipasadya preprocessing
Mga opsyon na nauugnay sa preprocessor. Tingnan ang seksyon Nagpoproseso at kondisyonal pagtitipon para
mas detalyadong impormasyon sa preprocessing sa gfortran.

-cpp
-nocpp
Paganahin ang preprocessing. Ang preprocessor ay awtomatikong na-invoke kung ang file extension
is .fpp, .FPP, .F, .PARA, .FTN, .F90, .F95, .F03 or .F08. Gamitin ang opsyong ito upang manu-mano
paganahin ang preprocessing ng anumang uri ng Fortran file.

Upang huwag paganahin ang paunang pagproseso ng mga file gamit ang alinman sa mga nakalistang extension sa itaas, gamitin ang
negatibong anyo: -nocpp.

Ang preprocessor ay pinapatakbo sa tradisyonal na mode. Anumang mga paghihigpit sa format ng file,
lalo na ang mga limitasyon sa haba ng linya, mag-apply din para sa preprocessed na output, kaya ito
maaaring ipinapayong gamitin ang -ffree-line-length-wala or -nakadikit-linya-haba-wala
mga pagpipilian.

-dM Sa halip na ang normal na output, bumuo ng isang listahan ng '#define' na mga direktiba para sa lahat ng
mga macro na tinukoy sa panahon ng pagpapatupad ng preprocessor, kabilang ang mga paunang natukoy na macro.
Nagbibigay ito sa iyo ng paraan upang malaman kung ano ang paunang natukoy sa iyong bersyon ng
preprocessor. Ipagpalagay na wala kang file foo.f90, ang utos

pindutin ang foo.f90; gfortran -cpp -E -dM foo.f90

ipapakita ang lahat ng paunang natukoy na macro.

-DD katulad -dM maliban sa dalawang aspeto: hindi kasama dito ang mga paunang natukoy na macro, at ito
output ang parehong "#define" na mga direktiba at ang resulta ng preprocessing. Parehong uri ng
output pumunta sa karaniwang output file.

-dN katulad -DD, ngunit naglalabas lamang ng mga macro name, hindi ang kanilang mga pagpapalawak.

-dU katulad dD maliban sa mga macro lamang na pinalawak, o kung saan ang kahulugan ay sinubok
preprocessor direktiba, ay output; ang output ay naantala hanggang sa paggamit o pagsubok ng
ang macro; at ang '#undef' na mga direktiba ay output din para sa mga macro na nasubok ngunit hindi natukoy sa
ang oras.

-dI Output '#include' na mga direktiba bilang karagdagan sa resulta ng preprocessing.

-fworking-directory
Paganahin ang pagbuo ng mga linemarker sa preprocessor na output na hahayaan ang compiler
alamin ang kasalukuyang gumaganang direktoryo sa oras ng preprocessing. Kapag ang pagpipiliang ito ay
pinagana, ang preprocessor ay maglalabas, pagkatapos ng paunang linemarker, ng pangalawang linemarker
kasama ang kasalukuyang gumaganang direktoryo na sinusundan ng dalawang slash. Gagamitin ito ng GCC
direktoryo, kapag ito ay naroroon sa preprocessed input, bilang ang direktoryo na inilabas bilang
ang kasalukuyang gumaganang direktoryo sa ilang mga format ng impormasyon sa pag-debug. Ang pagpipiliang ito ay
implicitly na pinagana kung ang impormasyon sa pag-debug ay pinagana, ngunit maaari itong pigilan sa
ang negadong anyo -fno-working-directory. Kung ang -P ang bandila ay naroroon sa utos
linya, ang opsyong ito ay walang epekto, dahil walang "#line" na mga direktiba ang ilalabas.

-idirafter dir
paghahanap dir para sa isama ang mga file, ngunit gawin ito pagkatapos ng lahat ng mga direktoryo na tinukoy sa -I at
ang mga karaniwang direktoryo ng system ay naubos na. dir ay itinuturing bilang isang sistema
isama ang direktoryo. Kung ang dir ay nagsisimula sa "=", ang "=" ay papalitan ng
sysroot prefix; tingnan mo --sysroot at -isysroot.

-imultilib dir
paggamit dir bilang isang subdirectory ng direktoryo na naglalaman ng mga header ng C++ na tukoy sa target.

-iprefix unlapi
Tukuyin unlapi bilang unlapi para sa kasunod -iwithprefix mga pagpipilian. Kung ang unlapi
kumakatawan sa isang direktoryo, dapat mong isama ang panghuling '/'.

-isysroot dir
Ang pagpipiliang ito ay tulad ng --sysroot opsyon, ngunit nalalapat lamang sa mga file ng header. Tingnan ang
--sysroot opsyon para sa karagdagang impormasyon.

-iquote dir
paghahanap dir para lamang sa mga file ng header na hiniling na may "#include "file""; hindi sila
hinanap ang "#include ", bago ang lahat ng mga direktoryo na tinukoy ni -I at bago ang
karaniwang mga direktoryo ng system. Kung dir nagsisimula sa "=", pagkatapos ay ang "=" ay papalitan ng
ang sysroot prefix; tingnan mo --sysroot at -isysroot.

-isystem dir
paghahanap dir para sa mga file ng header, pagkatapos ng lahat ng mga direktoryo na tinukoy ni -I ngunit bago ang
karaniwang mga direktoryo ng system. Markahan ito bilang isang direktoryo ng system, upang maging pareho ito
espesyal na pagtrato gaya ng inilalapat sa mga karaniwang direktoryo ng system. Kung dir nagsisimula sa
"=", pagkatapos ay ang "=" ay papalitan ng sysroot prefix; tingnan mo --sysroot at -isysroot.

-nostdinc
Huwag maghanap sa mga karaniwang direktoryo ng system para sa mga file ng header. Tanging ang mga direktoryo
tinukoy mo kasama ng -I mga opsyon (at ang direktoryo ng kasalukuyang file, kung
naaangkop) ay hinahanap.

-undef
Huwag paunang tukuyin ang anumang mga macro na partikular sa system o partikular sa GCC. Ang pamantayang paunang natukoy
nananatiling tinukoy ang mga macro.

-Apredicate=sagutin
Gumawa ng paninindigan gamit ang panaguri predicate at sagutin sagutin. Ang form na ito ay
mas gusto sa mas lumang anyo -Isang panaguri(sagot), na sinusuportahan pa rin, dahil ito
ay hindi gumagamit ng mga espesyal na character ng shell.

-A-predicate=sagutin
Kanselahin ang isang assertion na may panaguri predicate at sagutin sagutin.

-C Huwag itapon ang mga komento. Ang lahat ng mga komento ay ipinapasa sa output file, maliban
para sa mga komento sa mga naprosesong direktiba, na tinatanggal kasama ng direktiba.

Dapat kang maging handa para sa mga side effect kapag gumagamit -C; nagiging sanhi ito ng preprocessor sa
ituring ang mga komento bilang mga token sa kanilang sariling karapatan. Halimbawa, lumalabas ang mga komento sa
simula ng kung ano ang magiging isang direktiba na linya ay may epekto ng paggawa ng linyang iyon sa isang
ordinaryong linya ng pinagmulan, dahil ang unang token sa linya ay hindi na '#'.

Babala: ito ay kasalukuyang humahawak sa mga komentong C-Style lamang. Ang preprocessor ay wala pa
kilalanin ang istilong Fortran na mga komento.

-CC Huwag itapon ang mga komento, kabilang ang habang macro expansion. Ito ay tulad ng -C, maliban
na ang mga komentong nakapaloob sa loob ng mga macro ay ipinapasa din sa output file kung saan
ang macro ay pinalawak.

Bilang karagdagan sa mga side-effects ng -C opsyon, ang -CC ang opsyon ay nagiging sanhi ng lahat ng C++-style
mga komento sa loob ng isang macro na iko-convert sa C-style na mga komento. Ito ay upang maiwasan mamaya
paggamit ng macro na iyon mula sa hindi sinasadyang pagkomento sa natitirang linya ng pinagmulan.
Ang -CC Ang opsyon ay karaniwang ginagamit upang suportahan ang mga komento ng lint.

Babala: ito ay kasalukuyang humahawak ng C- at C++-Style na mga komento lamang. Ginagawa ng preprocessor
hindi pa nakikilala ang mga komentong istilo ng Fortran.

-Dpangalan
Paunang tukuyin ang pangalan bilang isang macro, na may kahulugan 1.

-Dpangalan=depinisyon
Ang mga nilalaman ng depinisyon ay tokenized at pinoproseso na parang sila ay lumitaw noong
ikatlong yugto ng pagsasalin sa isang '#define' na direktiba. Sa partikular, ang kahulugan ay
puputulin ng mga naka-embed na newline na character.

Kung gumagamit ka ng preprocessor mula sa isang shell o shell-like program na maaaring kailanganin mo
upang gamitin ang quoting syntax ng shell upang protektahan ang mga character tulad ng mga puwang na may a
kahulugan sa shell syntax.

Kung nais mong tukuyin ang isang macro na tulad ng function sa command line, isulat ang argumento nito
listahan na may nakapalibot na panaklong bago ang katumbas na tanda (kung mayroon). Ang mga panaklong ay
makabuluhan sa karamihan ng mga shell, kaya kakailanganin mong banggitin ang opsyon. Sa sh at csh,
"-D'name(args...)=definition'" gumagana.

-D at -U Pinoproseso ang mga opsyon sa pagkakasunud-sunod na ibinigay sa command line. Lahat
-imacros file at -include ang mga opsyon sa file ay pinoproseso pagkatapos ng lahat ng -D at -U na opsyon.

-H I-print ang pangalan ng bawat header file na ginamit, bilang karagdagan sa iba pang normal na aktibidad. Bawat isa
naka-indent ang pangalan upang ipakita kung gaano ito kalalim sa '#include' stack.

-P Pigilan ang pagbuo ng mga linemarker sa output mula sa preprocessor. Ito ay maaaring
kapaki-pakinabang kapag nagpapatakbo ng preprocessor sa isang bagay na hindi C code, at ipapadala
sa isang programa na maaaring malito ng mga linemarker.

-Upangalan
Kanselahin ang anumang dating kahulugan ng pangalan, alinman sa built in o binigyan ng a -D pagpipilian.

Options sa humiling or sugpuin error at babala
Ang mga error ay mga diagnostic na mensahe na nag-uulat na ang GNU Fortran compiler ay hindi maaaring mag-compile
ang nauugnay na piraso ng source code. Patuloy na ipoproseso ng compiler ang program
isang pagtatangka na mag-ulat ng karagdagang mga error upang makatulong sa pag-debug, ngunit hindi magbubunga ng anumang pinagsama-sama
output.

Ang mga babala ay mga diagnostic na mensahe na nag-uulat ng mga konstruksyon na hindi likas
mali ngunit mapanganib o nagmumungkahi na may posibilidad na magkaroon ng bug sa programa.
Maliban kung -Werror ay tinukoy, hindi nila pinipigilan ang pagsasama-sama ng programa.

Maaari kang humiling ng maraming partikular na babala na nagsisimula sa mga opsyon -W, Halimbawa -Wimplicit
upang humiling ng mga babala sa mga implicit na deklarasyon. Ang bawat isa sa mga partikular na opsyon sa babala din
ay may negatibong anyo na nagsisimula -Wno- upang patayin ang mga babala; Halimbawa, -Wno-implicit.
Ang manwal na ito ay naglilista lamang ng isa sa dalawang form, alinman ang hindi default.

Kinokontrol ng mga opsyong ito ang dami at uri ng mga error at babala na ginawa ng GNU Fortran:

-fmax-errors=n
Nililimitahan ang maximum na bilang ng mga mensahe ng error sa n, kung saan nagpiyansa ang GNU Fortran
sa halip na subukang ipagpatuloy ang pagproseso ng source code. Kung n ay 0, walang
limitasyon sa bilang ng mga error na mensahe na ginawa.

-fsyntax-lamang
Suriin ang code para sa mga error sa syntax, ngunit huwag aktwal na i-compile ito. Ito ay bubuo
module file para sa bawat module na nasa code, ngunit walang ibang output file.

-pedantic
Magbigay ng mga babala para sa paggamit ng mga extension sa Fortran 95. -pedantic nalalapat din sa
C-language constructs kung saan nangyayari ang mga ito sa GNU Fortran source file, gaya ng paggamit ng \e
sa isang character constant sa loob ng isang direktiba tulad ng "#include".

Ang mga wastong programa ng Fortran 95 ay dapat na mag-compile nang maayos mayroon man o wala ang opsyong ito.
Gayunpaman, kung wala ang pagpipiliang ito, ang ilang mga extension ng GNU at tradisyonal na tampok ng Fortran
ay sinusuportahan din. Sa pagpipiliang ito, marami sa kanila ang tinanggihan.

Sinusubukan ng ilang mga gumagamit na gamitin -pedantic upang suriin ang mga programa para sa pagsunod. Malapit na nilang mahanap
na hindi nito ginagawa kung ano ang gusto nila---nakahanap ito ng ilang hindi karaniwang mga kasanayan, ngunit
hindi lahat. Gayunpaman, ang mga pagpapabuti sa GNU Fortran sa lugar na ito ay malugod na tinatanggap.

Dapat itong gamitin kasabay ng -std=f95, -std=f2003 or -std=f2008.

-pedantic-errors
katulad -pedantic, maliban na ang mga error ay ginawa sa halip na mga babala.

-Pader
Pinapagana ang karaniwang ginagamit na mga opsyon sa babala na nauugnay sa paggamit na inirerekomenda naming iwasan
at naniniwala kaming madaling iwasan. Kasama dito sa kasalukuyan -Waliasing,
-Wampersand, -Wconversion, -Nakakagulat, -Wc-binding-type, -Witrinsics-std,
-Wno-tabs, -Witrinsic-anino, -Wline-truncation, -Wtarget-habang buhay, -Wreal-q-constant
at -Wunused.

-Waliasing
Babala tungkol sa posibleng pag-alyas ng mga dummy na argumento. Sa partikular, nagbabala ito kung pareho
Ang aktwal na argumento ay nauugnay sa isang dummy argument na may "INTENT(IN)" at isang dummy
argumento na may "INTENT(OUT)" sa isang tawag na may tahasang interface.

Ang sumusunod na halimbawa ay magti-trigger ng babala.

interface
subroutine bar(a,b)
integer, intent(in):: a
integer, intent(out) :: b
tapusin ang subroutine
dulo ng interface
integer :: a

call bar(a,a)

-Wampersand
Babala tungkol sa nawawalang ampersand sa patuloy na character constant. Ang babala ay ibinigay
sa -Wampersand, -pedantic, -std=f95, -std=f2003 at -std=f2008. Tandaan: Sa hindi
ampersat ibinigay sa isang patuloy na character constant, ipinapalagay ng GNU Fortran ang pagpapatuloy sa
ang unang hindi komento, hindi whitespace na character pagkatapos ng ampersand na nagpasimula ng
pagpapatuloy.

-Warray-pansamantala
Magbabala tungkol sa mga pansamantalang array na nabuo ng compiler. Ang impormasyong nabuo ng
ang babalang ito ay minsan ay kapaki-pakinabang sa pag-optimize, upang maiwasan ang mga ganitong pansamantalang panahon.

-Wc-binding-type
Babala kung ang isang variable ay maaaring hindi C interoperable. Sa partikular, bigyan ng babala kung ang
Ang variable ay idineklara gamit ang isang intrinsic na uri na may default na uri sa halip na gamitin
isang uri ng parameter na tinukoy para sa C interoperability sa intrinsic na "ISO_C_Binding"
modyul. Ang pagpipiliang ito ay ipinahiwatig ng -Pader.

-Wcharacter-truncation
Magbabala kapag puputulin ng pagtatalaga ng character ang nakatalagang string.

-Wline-truncation
Magbabala kapag ang isang linya ng source code ay puputulin. Ang pagpipiliang ito ay ipinahiwatig ng -Pader. Para sa
free-form source code, ang default ay -Werror=line-truncation tulad na truncations
ay iniulat bilang error.

-Wconversion
Magbabala tungkol sa mga implicit na conversion na malamang na magbago sa halaga ng expression
pagkatapos ng conversion. Ipinahiwatig ng -Pader.

-Wconversion-dagdag
Magbabala tungkol sa mga implicit na conversion sa pagitan ng iba't ibang uri at uri. Ginagawa ng pagpipiliang ito
hindi magpahiwatig -Wconversion.

-Wextra
Pinapagana ang ilang mga opsyon sa babala para sa mga paggamit ng mga feature ng wika na maaaring may problema.
Kasama na ito sa kasalukuyan -Wcompare-reals at -Wunused-parameter.

-Wimplicit-interface
Magbabala kung ang isang pamamaraan ay tinatawag na walang tahasang interface. Tandaan na ito ay nagsusuri lamang
na mayroong tahasang interface. Hindi nito sinusuri kung ang ipinahayag na mga interface
pare-pareho sa mga yunit ng programa.

-Wimplicit-procedure
Magbabala kung ang isang pamamaraan ay tinatawag na walang tahasang interface o hindi
idineklara bilang "EXTERNAL".

-Witrinsics-std
Babala kung gfortran nakakahanap ng isang pamamaraan na pinangalanang tulad ng isang intrinsic na hindi magagamit sa
kasalukuyang napiling pamantayan (na may -std) at tinatrato ito bilang "EXTERNAL" na pamamaraan dahil
nitong. -fall-intrinsics ay maaaring gamitin upang hindi kailanman ma-trigger ang gawi na ito at palaging mag-link
sa intrinsic anuman ang napiling pamantayan.

-Wreal-q-constant
Gumawa ng babala kung ang real-literal-constant ay naglalaman ng "q" exponent-letter.

-Nakakagulat
Magbigay ng babala kapag may nakitang mga "kahina-hinalang" code construct. Habang
teknikal na legal ang mga ito ay karaniwang nagpapahiwatig na ang isang pagkakamali ay nagawa.

Ito ay kasalukuyang gumagawa ng babala sa ilalim ng mga sumusunod na sitwasyon:

* Ang isang INTEGER SELECT construct ay may CASE na hindi kailanman matutumbasan bilang mas mababa nito
ang halaga ay mas malaki kaysa sa itaas na halaga nito.

* Ang isang LOGICAL SELECT construct ay may tatlong CASE statement.

* Ang isang TRANSFER ay tumutukoy sa isang pinagmulan na mas maikli kaysa sa destinasyon.

* Ang uri ng resulta ng function ay idineklara nang higit sa isang beses na may parehong uri. Kung
-pedantic o naka-enable ang standard-conforming mode, isa itong error.

* Ang isang "CHARACTER" na variable ay idineklara na may negatibong haba.

-Wtabs
Bilang default, ang mga tab ay tinatanggap bilang whitespace, ngunit ang mga tab ay hindi mga miyembro ng Fortran
Set ng Character. Para sa mga linya ng pagpapatuloy, isang tab na sinusundan ng isang digit sa pagitan ng 1 at 9 ay
suportado. -Wtabs ay magsasanhi ng babala na maibigay kung ang isang tab ay nakatagpo. Tandaan,
-Wtabs ay aktibo para sa -pedantic, -std=f95, -std=f2003, -std=f2008, -std=f2008ts at
-Pader.

-Wunderflow
Gumawa ng babala kapag nakatagpo ng mga numerical constant na expression, na nagbubunga ng isang
UNDERFLOW sa panahon ng compilation. Pinagana bilang default.

-Witrinsic-anino
Magbabala kung ang isang pamamaraan na tinukoy ng gumagamit o pamamaraan ng module ay may parehong pangalan bilang isang
intrinsic; sa kasong ito, isang tahasang interface o "EXTERNAL" o "INTRINSIC"
deklarasyon ay maaaring kailanganin upang makakuha ng mga tawag na malutas sa ibang pagkakataon sa nais
intrinsic/pamamaraan. Ang pagpipiliang ito ay ipinahiwatig ng -Pader.

-Wuse-walang-lamang
Magbabala kung ang isang "GAMIT" na pahayag ay walang "LAMANG" na qualifier at sa gayon ay tahasang ini-import ang lahat
pampublikong entidad ng ginamit na module.

-Wunused-dummy-argument
Magbabala tungkol sa hindi nagamit na mga dummy na argumento. Ang pagpipiliang ito ay ipinahiwatig ng -Pader.

-Wunused-parameter
Labag sa gccang kahulugan ng -Wunused-parameter, gfortranang pagpapatupad nito
Ang opsyon ay hindi nagbabala tungkol sa hindi nagamit na mga dummy na argumento (tingnan -Wunused-dummy-argument), ngunit
tungkol sa mga hindi nagamit na halaga ng "PARAMETER". -Wunused-parameter ay ipinahihiwatig ng -Wextra kung din
-Wunused or -Pader Ginagamit.

-Walign-commons
Sa pamamagitan ng default, gfortran ay nagbabala tungkol sa anumang okasyon ng mga variable na pinalamanan para sa wastong
alignment sa loob ng "COMMON" block. Maaaring i-off ang babalang ito sa pamamagitan ng
-Wno-align-commons. Tingnan din -falign-commons.

-Wfunction-elimination
Magbabala kung ang anumang mga tawag sa mga function ay inalis ng mga pag-optimize na pinagana ng
-ffrontend-optimize pagpipilian.

-Wrealloc-lhs
Magbabala kung kailan maaaring magpasok ng code ang compiler para sa paglalaan o muling paglalaan ng isang
allocatable array variable ng intrinsic type sa intrinsic assignments. Sa mainit na mga loop,
ang tampok na Fortran 2003 relocation ay maaaring mabawasan ang pagganap. Kung ang array ay
nakalaan na sa tamang hugis, isaalang-alang ang paggamit ng whole-array array-spec
(hal. "(:,:,:)") para sa variable sa kaliwang bahagi upang maiwasan ang muling paglalagay
suriin. Tandaan na sa ilang mga kaso ang babala ay ipinapakita, kahit na gagawin ng compiler
i-optimize ang mga pagsusuri sa reallocation. Halimbawa, kapag ang kanang bahagi ay naglalaman ng
ang parehong variable na pinarami ng isang scalar. Tingnan din -frealloc-lhs.

-Wrealloc-lhs-lahat
Magbabala kapag nagpasok ang compiler ng code sa para sa paglalaan o muling paglalaan ng isang
variable na inilalaan; kabilang dito ang mga scalar at derived na uri.

-Wcompare-reals
Magbabala kapag naghahambing ng totoo o kumplikadong mga uri para sa pagkakapantay-pantay o hindi pagkakapantay-pantay. Ang pagpipiliang ito ay
ipinahiwatig ng -Wextra.

-Wtarget-habang buhay
Magbabala kung ang pointer sa isang pointer assignment ay maaaring mas mahaba kaysa sa target nito. Ito
opsyon ay ipinahiwatig ng -Pader.

-Wzerotrip
Magbabala kung ang isang "DO" na loop ay kilala na mag-execute ng zero na beses sa oras ng pag-compile. Ang pagpipiliang ito ay
ipinahiwatig ng -Pader.

-Werror
Ginagawang error ang lahat ng babala.

Ang ilan sa mga ito ay walang epekto kapag nag-compile ng mga program na nakasulat sa Fortran.

Options para pag-debug iyong programa or GNU Fortran
Ang GNU Fortran ay may iba't ibang espesyal na opsyon na ginagamit para sa pag-debug alinman sa iyong programa o
ang GNU Fortran compiler.

-fdump-fortran-orihinal
I-output ang internal parse tree pagkatapos isalin ang source program sa internal
representasyon. Talagang kapaki-pakinabang lamang para sa pag-debug ng GNU Fortran compiler mismo.

-fdump-fortran-optimized
I-output ang parse tree pagkatapos ng front-end na pag-optimize. Lamang talagang kapaki-pakinabang para sa pag-debug
ang GNU Fortran compiler mismo.

-fdump-parse-tree
I-output ang internal parse tree pagkatapos isalin ang source program sa internal
representasyon. Talagang kapaki-pakinabang lamang para sa pag-debug ng GNU Fortran compiler mismo.
Hindi na ginagamit ang opsyong ito; gamitin ang "-fdump-fortran-original" sa halip.

-ffpe-trap=listahan
Tumukoy ng listahan ng mga floating point exception traps na paganahin. Sa karamihan ng mga sistema, kung a
Ang floating point exception ay nangyayari at ang bitag para sa exception na iyon ay pinagana, isang SIGFPE
ang signal ay ipapadala at ang programa ay naa-abort, na gumagawa ng isang pangunahing file na kapaki-pakinabang para sa
pag-debug listahan ay isang (posibleng walang laman) na listahan ng mga sumusunod na pinaghihiwalay ng kuwit
mga pagbubukod: hindi wasto (hindi wastong pagpapatakbo ng floating point, gaya ng "SQRT(-1.0)"), wala
(dibisyon sa zero), apaw (overflow sa isang floating point operation), underflow
(underflow sa isang floating point operation), hindi eksakto (pagkawala ng katumpakan sa panahon ng
operasyon), at denormal (ginawa ang operasyon sa isang denormal na halaga). Ang unang lima
ang mga pagbubukod ay tumutugma sa limang mga pagbubukod ng IEEE 754, samantalang ang huli (denormal)
ay hindi bahagi ng pamantayan ng IEEE 754 ngunit magagamit sa ilang karaniwang mga arkitektura
tulad ng x86.

Ang unang tatlong pagbubukod (hindi wasto, wala, at apaw) kadalasang nagpapahiwatig ng seryoso
mga pagkakamali, at maliban kung ang programa ay may mga probisyon para sa pagharap sa mga pagbubukod na ito,
Ang pagpapagana ng mga bitag para sa tatlong eksepsiyon na ito ay malamang na isang magandang ideya.

Marami, kung hindi man karamihan, ang mga pagpapatakbo ng floating point ay nagkakaroon ng pagkawala ng katumpakan dahil sa pag-ikot,
at samakatuwid ang "ffpe-trap=inexact" ay malamang na hindi kawili-wili sa pagsasanay.

Bilang default, walang mga exception traps ang pinagana.

-ffpe-summary=listahan
Tumukoy ng listahan ng mga floating-point exception, kung saan naka-print ang status ng flag
"ERROR_UNIT" kapag tinatawag ang "STOP" at "ERROR STOP". listahan maaaring maging alinman wala, lahat o isang
comma-separated list ng mga sumusunod na exception: hindi wasto, wala, apaw, underflow,
hindi eksakto at denormal. (Tingnan -ffpe-trap para sa paglalarawan ng mga pagbubukod.)

Bilang default, isang buod para sa lahat ng mga pagbubukod ngunit hindi eksakto ay ipinakita.

-fno-backtrace
Kapag ang isang malubhang runtime error ay nakatagpo o isang nakamamatay na signal ay ibinubuga
(pagkakasala sa segmentasyon, iligal na pagtuturo, error sa bus, pagbubukod sa floating-point, at ang
iba pang mga signal ng POSIX na may aksyon ubod), sinusubukan ng Fortran runtime library
output ng backtrace ng error. Hindi pinapagana ng "-fno-backtrace" ang pagbuo ng backtrace.
Ang pagpipiliang ito ay may impluwensya lamang para sa pagsasama-sama ng pangunahing programa ng Fortran.

Options para direktoryo paghahanap
Naaapektuhan ng mga opsyong ito kung paano naghahanap ang GNU Fortran ng mga file na tinukoy ng "INCLUDE"
direktiba at kung saan ito naghahanap ng mga naunang pinagsama-samang mga module.

Nakakaapekto rin ito sa mga path ng paghahanap na ginagamit ni cpp kapag ginamit upang i-preprocess ang Fortran source.

-Idir
Nakakaapekto ang mga ito sa interpretasyon ng direktiba na "INCLUDE" (pati na rin ng "#include"
direktiba ng cpp preprocessor).

Tandaan din na ang pangkalahatang pag-uugali ng -I at ang "INCLUDE" ay halos kapareho ng sa
-I na may "#include" sa cpp preprocessor, tungkol sa paghahanap header.gcc
mga file at iba pang mga bagay.

Ginagamit din ang landas na ito upang maghanap .mod mga file kapag dating pinagsama-samang mga module ay
kinakailangan ng isang "GAMIT" na pahayag.

-Jdir
Tinutukoy ng opsyong ito kung saan ilalagay .mod mga file para sa pinagsama-samang mga module. Ito ay idinagdag din
sa listahan ng mga direktoryo na hahanapin ng isang "GAMIT" na pahayag.

Ang default ay ang kasalukuyang direktoryo.

-fintrinsic-modules-path dir
Tinutukoy ng opsyong ito ang lokasyon ng mga pre-compiled intrinsic modules, kung hindi
sa default na lokasyon na inaasahan ng compiler.

Impluwensya ang pag-uugnay hakbang
Naglalaro ang mga opsyong ito kapag ini-link ng compiler ang mga object file sa isang executable
output file. Ang mga ito ay walang kahulugan kung ang tagatala ay hindi gumagawa ng isang hakbang na link.

-static-libgfortran
Sa mga sistemang nagbibigay libgfortran bilang isang shared at isang static na library, ang pagpipiliang ito
pinipilit ang paggamit ng static na bersyon. Kung walang nakabahaging bersyon ng libgfortran ay itinayo
kapag ang compiler ay na-configure, ang opsyon na ito ay walang epekto.

Impluwensya runtime pag-uugali
Naaapektuhan ng mga opsyong ito ang pag-uugali ng runtime ng mga program na pinagsama-sama sa GNU Fortran.

-fconvert=Conversion
Tukuyin ang representasyon ng data para sa hindi na-format na mga file. Mga wastong halaga para sa conversion
ay: katutubo, ang default; magpalitan, magpalit sa pagitan ng malaki at maliit na endian; big-endian, Gamitin ang
big-endian na representasyon para sa hindi na-format na mga file; maliit-endian, gumamit ng little-endian
representasyon para sa hindi na-format na mga file.

ito opsyon ay an epekto lamang kailan ginamit in ang pangunahin programa. Ang "CONVERT" specifier
at ang GFORTRAN_CONVERT_UNIT kapaligiran nagbabago pawalang-bisa ang default tinukoy by
-fconvert.

-frecord-marker=haba
Tukuyin ang haba ng mga record marker para sa hindi na-format na mga file. Mga wastong halaga para sa haba
ay 4 at 8. Default ay 4. ito is iba mula nakaraan mga bersyon of gfortran,
na nagtukoy ng default na record marker na haba na 8 sa karamihan ng mga system. Kung gusto mo
magbasa o magsulat ng mga file na tugma sa mga naunang bersyon ng gfortran, Gamitin ang
-frecord-marker=8.

-fmax-subrecord-length=haba
Tukuyin ang maximum na haba para sa isang subrecord. Ang maximum na pinahihintulutang halaga para sa haba ay
2147483639, na siya ring default. Lamang talagang kapaki-pakinabang para sa paggamit ng gfortran
testsuite.

-fsign-zero
Kapag pinagana, isusulat ang mga numero ng floating point na may value na zero na may set ng sign bit
bilang negatibong numero sa naka-format na output at itinuturing bilang negatibo sa "SIGN"
intrinsic. -fno-sign-zero ay hindi nagpi-print ng negatibong tanda ng mga zero na halaga (o mga halaga
ni-round sa zero para sa I/O) at itinuturing ang zero bilang positibong numero sa intrinsic na "SIGN".
para sa pagiging tugma sa Fortran 77. Ang default ay -fsign-zero.

Options para code henerasyon mga convention
Kinokontrol ng mga opsyong independiyenteng makina na ito ang mga kumbensyon ng interface na ginagamit sa code
henerasyon.

Karamihan sa kanila ay may parehong positibo at negatibong anyo; ang negatibong anyo ng -ffoo ay magiging
-fno-foo. Sa talahanayan sa ibaba, isa lamang sa mga form ang nakalista --- ang isa na hindi ang
default. Maaari mong malaman ang iba pang anyo sa pamamagitan ng alinman sa pag-alis hindi- o pagdaragdag nito.

-fno-awtomatiko
Tratuhin ang bawat yunit ng programa (maliban sa mga minarkahan bilang RECURSIVE) na parang ang "SAVE" na pahayag
ay tinukoy para sa bawat lokal na variable at array na isinangguni dito. Hindi nakakaapekto
karaniwang mga bloke. (Ang ilang Fortran compiler ay nagbibigay ng opsyong ito sa ilalim ng pangalan -static or
-iligtas.) Ang default, which is -fautomatic, ay gumagamit ng stack para sa mga lokal na variable na mas maliit
kaysa sa halagang ibinigay ng -fmax-stack-var-size. Gamitin ang opsyon -frecursive gamitin ang no
static na memorya.

-ff2c
Bumuo ng code na idinisenyo upang maging tugma sa code na binuo ni g77 at f2c.

Ang mga calling convention na ginagamit ng g77 (orihinal na ipinatupad sa f2c) ay nangangailangan ng mga function
na ang uri ng pagbabalik ay default na "REAL" upang aktwal na ibalik ang uri ng C na "double", at mga function
na uri ng pagbabalik na "COMPLEX" upang ibalik ang mga halaga sa pamamagitan ng dagdag na argumento sa pagtawag
sequence na tumuturo sa kung saan iimbak ang return value. Sa ilalim ng default na GNU
pagtawag ng mga kombensiyon, ibinabalik lamang ng mga naturang function ang kanilang mga resulta gaya ng gagawin nila sa GNU
Ang C---default na mga function na "REAL" ay nagbabalik ng uri ng C na "float", at ang mga function na "COMPLEX" ay nagbabalik
ang uri ng GNU C na "kumplikado". Bilang karagdagan, ang pagpipiliang ito ay nagpapahiwatig ng -fsecond-underscore
opsyon, maliban kung -fno-second-underscore ay tahasang hinihiling.

Hindi ito nakakaapekto sa pagbuo ng code na nakikipag-ugnayan sa libgfortran
library.

Mag-ingat: Hindi magandang ideya na paghaluin ang Fortran code na pinagsama-sama -ff2c may code
pinagsama-sama sa default -fno-f2c pagtawag sa mga kumbensyon bilang, pagtawag sa "COMPLEX" o
default na "REAL" na mga function sa pagitan ng mga bahagi ng programa na pinagsama-sama sa iba't ibang
masisira ang mga calling convention sa oras ng pagpapatupad.

Mag-ingat: Masisira nito ang code na nagpapasa ng mga intrinsic na function ng uri ng default na "REAL"
o "COMPLEX" bilang mga aktwal na argumento, dahil ginagamit ng mga pagpapatupad ng library ang -fno-f2c
pagtawag sa mga kumbensyon.

-fno-underscoring
Huwag baguhin ang mga pangalan ng mga entity na tinukoy sa Fortran source file sa pamamagitan ng pagdaragdag
salungguhit sa kanila.

may -funderscoring sa bisa, ang GNU Fortran ay nagdaragdag ng isang salungguhit sa mga panlabas na pangalan
na walang salungguhit. Ginagawa ito upang matiyak ang pagiging tugma sa code na ginawa ng marami
UNIX Fortran compiler.

Ingat: Ang default na gawi ng GNU Fortran ay hindi tugma sa f2c at g77, Mangyaring
gamitin ang -ff2c opsyon kung gusto mong maging object file na pinagsama-sama sa GNU Fortran
tugma sa object code na nilikha gamit ang mga tool na ito.

Paggamit ng -fno-underscoring ay hindi inirerekomenda maliban kung nag-eeksperimento ka sa mga isyu
tulad ng pagsasama ng GNU Fortran sa mga umiiral na kapaligiran ng system (vis-a-vis
umiiral na mga aklatan, kasangkapan, at iba pa).

Halimbawa, kasama -funderscoring, at ipagpalagay na ang "j()" at "max_count()" ay
mga panlabas na pag-andar habang ang "my_var" at "lvar" ay mga lokal na variable, isang pahayag tulad ng

I = J() + MAX_COUNT (MY_VAR, LVAR)

ay ipinatupad bilang isang bagay na katulad ng:

i = j_() + max_count__(&my_var__, &lvar);

may -fno-underscoring, ang parehong pahayag ay ipinatupad bilang:

i = j() + max_count(&my_var, &lvar);

Paggamit ng -fno-underscoring nagbibigay-daan sa direktang pagtutukoy ng mga pangalan na tinukoy ng gumagamit habang
pag-debug at kapag nakikipag-interfacing ang GNU Fortran code sa ibang mga wika.

Tandaan na dahil lang magkatugma ang mga pangalan hindi nangangahulugan na ang interface na ipinatupad ng
Ang GNU Fortran para sa isang panlabas na pangalan ay tumutugma sa interface na ipinatupad ng iba
wika para sa parehong pangalan. Iyon ay, pagkuha ng code na ginawa ng GNU Fortran upang maiugnay
code na ginawa ng ilang iba pang compiler gamit ito o anumang iba pang paraan ay maaari lamang a
maliit na bahagi ng pangkalahatang solusyon---pagkuha ng code na nabuo ng parehong compiler sa
sumang-ayon sa mga isyu maliban sa pagbibigay ng pangalan ay maaaring mangailangan ng malaking pagsisikap, at, hindi katulad ng pagbibigay ng pangalan
mga hindi pagkakasundo, karaniwang hindi matukoy ng mga linker ang mga hindi pagkakasundo sa ibang mga lugar na ito.

Gayundin, tandaan na may -fno-underscoring, ipinakilala ang kakulangan ng mga nakadugtong na salungguhit
ang tunay na posibilidad na ang isang panlabas na pangalan na tinukoy ng gumagamit ay salungat sa isang pangalan
sa isang library ng system, na maaaring gumawa ng paghahanap ng mga hindi nalutas na reference na mga bug
mahirap sa ilang mga kaso---maaaring mangyari ang mga ito sa oras ng pagpapatakbo ng programa, at lalabas lamang bilang
buggy na pag-uugali sa oras ng pagtakbo.

Sa hinaharap na mga bersyon ng GNU Fortran inaasahan naming pagbutihin ang pagbibigay ng pangalan at pag-link ng mga isyu upang iyon
Ang pag-debug ay palaging nagsasangkot ng paggamit ng mga pangalan na lumalabas sa pinagmulan, kahit na ang
Ang mga pangalan na nakikita ng linker ay ginugulo upang maiwasan ang hindi sinasadyang pag-uugnay sa pagitan
mga pamamaraan na may mga hindi tugmang interface.

-fsecond-underscore
Bilang default, ang GNU Fortran ay nagdaragdag ng underscore sa mga panlabas na pangalan. Kung ang pagpipiliang ito ay
ang ginamit na GNU Fortran ay nagdaragdag ng dalawang salungguhit sa mga pangalan na may mga salungguhit at isang salungguhit
sa mga panlabas na pangalan na walang salungguhit. Ang GNU Fortran ay nagdaragdag din ng dalawang salungguhit sa
panloob na mga pangalan na may mga salungguhit upang maiwasan ang pagbibigay ng pangalan sa mga banggaan sa mga panlabas na pangalan.

Ang pagpipiliang ito ay walang epekto kung -fno-underscoring ay may bisa. Ito ay ipinahihiwatig ng
-ff2c pagpipilian.

Kung hindi, sa opsyong ito, ang isang panlabas na pangalan gaya ng "MAX_COUNT" ay ipinapatupad bilang a
reference sa link-time na panlabas na simbolo na "max_count__", sa halip na "max_count_".
Ito ay kinakailangan para sa pagiging tugma sa g77 at f2c, at ipinahiwatig sa pamamagitan ng paggamit ng
-ff2c pagpipilian.

-fcoarray=
wala
Huwag paganahin ang coarray na suporta; gamit ang mga coarray na deklarasyon at image-control statement
gagawa ng error sa compile-time. (Default)

solong
Ang single-image mode, ibig sabihin, "num_images()" ay palaging isa.

lib Nakabatay sa library coarray parallelization; isang angkop na GNU Fortran coarray library
kailangang iugnay.

-fcheck=
Paganahin ang pagbuo ng mga run-time na pagsusuri; ang argumento ay dapat na isang comma-delimited list
ng mga sumusunod na keyword.

lahat Paganahin ang lahat ng run-time na pagsubok ng -fcheck.

array-temps
Nagbabala sa oras ng pagtakbo kapag para sa pagpasa ng isang aktwal na argumento ang isang pansamantalang array ay kailangang maging
nabuo. Ang impormasyong nabuo ng babalang ito ay minsan ay kapaki-pakinabang sa
pag-optimize, upang maiwasan ang mga naturang pansamantalang panahon.

Tandaan: Isang beses lang naka-print ang babala sa bawat lokasyon.

hangganan
Paganahin ang pagbuo ng mga run-time na pagsusuri para sa mga array subscript at laban sa ipinahayag
minimum at maximum na mga halaga. Sinusuri din nito ang mga indeks ng array para sa ipinapalagay at ipinagpaliban
hugis array laban sa aktwal na inilalaan na mga hangganan at tinitiyak na ang lahat ng string
ang mga haba ay pantay para sa mga constructor ng array ng character na walang tahasang typepec.

Ang ilang mga tseke ay nangangailangan nito -fcheck=mga hangganan ay nakatakda para sa compilation ng pangunahing
programa.

Tandaan: Sa hinaharap, maaari rin itong magsama ng iba pang paraan ng pagsuri, hal, pagsuri
mga sanggunian sa substring.

do Paganahin ang pagbuo ng mga run-time na pagsusuri para sa di-wastong pagbabago ng loop iteration
mga variable.

mem Paganahin ang pagbuo ng mga run-time na pagsusuri para sa paglalaan ng memorya. Tandaan: Ang pagpipiliang ito
ay hindi nakakaapekto sa mga tahasang paglalaan gamit ang "ALLOCATE" na pahayag, na magiging
palaging sinusuri.

puntero
Paganahin ang pagbuo ng mga run-time na pagsusuri para sa mga pointer at allocatable.

pag-urong
Paganahin ang pagbuo ng mga run-time na pagsusuri para sa recursively tinatawag na subroutines at
mga function na hindi minarkahan bilang recursive. Tingnan din -frecursive. Tandaan: Ito
hindi gumagana ang check para sa mga OpenMP program at hindi pinagana kung ginamit kasama ng
-frecursive at -fopenmp.

-fbounds-check
Hindi na ginagamit ang alyas para sa -fcheck=mga hangganan.

-fcheck-array-temporaries
Hindi na ginagamit ang alyas para sa -fcheck=array-temps.

-fmax-array-constructor=n
Maaaring gamitin ang opsyong ito upang mapataas ang pinakamataas na limitasyon na pinahihintulutan sa mga array constructor.
Ang code sa ibaba ay nangangailangan ng pagpipiliang ito upang palawakin ang array sa oras ng pag-compile.

pagsubok ng programa
implicit wala
integer j
integer, parameter :: n = 100000
integer, parameter :: i(n) = (/ (2*j, j = 1, n) /)
i-print ang '(10(I0,1X))', i
tapusin ang pagsusulit sa programa

Mag-ingat: ito opsyon maaari mamuno sa mahaba sumulat ng libro beses at sobra-sobra malaki bagay
file.

Ang default na halaga para sa n ay 65535.

-fmax-stack-var-size=n
Tinutukoy ng opsyong ito ang laki sa bytes ng pinakamalaking array na ilalagay sa
salansan; kung ang laki ay lumampas sa static na memorya ay ginagamit (maliban sa mga pamamaraan na minarkahan bilang
RECURSIVE). Gamitin ang opsyon -frecursive upang payagan ang mga recursive na pamamaraan na hindi
magkaroon ng RECURSIVE attribute o para sa mga parallel na programa. Gamitin -fno-awtomatiko upang hindi kailanman gamitin
ang salansan.

Ang pagpipiliang ito ay kasalukuyang nakakaapekto lamang sa mga lokal na array na ipinahayag na may pare-parehong mga hangganan, at maaaring
hindi nalalapat sa lahat ng mga variable ng character. Maaaring mapabuti ito ng mga hinaharap na bersyon ng GNU Fortran
pag-uugali.

Ang default na halaga para sa n ay 32768.

-fstack-arrays
Ang pagdaragdag ng opsyong ito ay gagawing mailalagay ng Fortran compiler ang lahat ng mga lokal na array, kahit na ang sa
hindi kilalang laki sa stack memory. Kung ang iyong programa ay gumagamit ng napakalaking lokal na array ito ay
posible na kailangan mong pahabain ang iyong mga limitasyon sa runtime para sa stack memory sa ilan
mga operating system. Ang flag na ito ay pinagana bilang default sa antas ng pag-optimize -Ofast.

-fpack-nagmula
Sinasabi ng opsyong ito sa GNU Fortran na mag-pack ng mga derived type na miyembro nang mas malapit hangga't maaari.
Ang code na pinagsama-sama sa opsyong ito ay malamang na hindi tugma sa code na na-compile nang wala
ang pagpipiliang ito, at maaaring magsagawa ng mas mabagal.

-frepack-arrays
Sa ilang mga pagkakataon, maaaring ipasa ng GNU Fortran ang mga pinagpapalagay na seksyon ng array ng hugis sa pamamagitan ng a
descriptor na naglalarawan sa isang hindi magkadikit na bahagi ng memorya. Ang pagpipiliang ito ay nagdaragdag ng code sa
function na prologue upang i-repack ang data sa isang magkadikit na bloke sa runtime.

Dapat itong magresulta sa mas mabilis na pag-access sa array. Gayunpaman maaari itong ipakilala
makabuluhang overhead sa function na tawag, lalo na kapag ang naipasa na data ay
hindi magkadikit.

-fshort-enums
Ang pagpipiliang ito ay ibinigay para sa interoperability sa C code na pinagsama-sama sa
-fshort-enums opsyon. Gagawin nitong piliin ang GNU Fortran ang pinakamaliit na uri ng "INTEGER" a
ang ibinigay na hanay ng enumerator ay magkakasya, at bigyan ang lahat ng mga enumerator nito ng ganitong uri.

-fexternal-blas
Ang pagpipiliang ito ay gagawa gfortran bumuo ng mga tawag sa mga function ng BLAS para sa ilang matrix
mga operasyon tulad ng "MATMUL", sa halip na gamitin ang aming sariling mga algorithm, kung ang laki ng
Ang mga matrice na kasangkot ay mas malaki kaysa sa ibinigay na limitasyon (tingnan ang -fblas-matmul-limit). Ito ay maaaring
kumikita kung available ang isang naka-optimize na vendor na BLAS library. Ang BLAS library ay
kailangang tukuyin sa oras ng pag-link.

-fblas-matmul-limit=n
Makabuluhan lamang kapag -fexternal-blas ay may bisa. Pagpaparami ng matrix ng mga matrice
na may sukat na mas malaki kaysa sa (o katumbas ng) n isasagawa sa pamamagitan ng mga tawag sa mga function ng BLAS,
habang ang iba ay hahawakan ng gfortran panloob na mga algorithm. Kung ang mga matrice na kasangkot
ay hindi parisukat, ang paghahambing ng laki ay ginagawa gamit ang geometric na mean ng
mga sukat ng argumento at mga resultang matrice.

Ang default na halaga para sa n ay 30.

-frecursive
Payagan ang hindi direktang recursion sa pamamagitan ng pagpilit sa lahat ng lokal na array na ilaan sa stack.
Ang flag na ito ay hindi maaaring gamitin kasama ng -fmax-stack-var-size= or -fno-awtomatiko.

-finit-local-zero
-finit-integer=n
-finit-real=
-finit-logical=
-finit-character=n
Ang -finit-local-zero Ang opsyon ay nagtuturo sa compiler na simulan ang lokal na "INTEGER",
"REAL", at "COMPLEX" na mga variable sa zero, "LOGICAL" na mga variable sa false, at "CHARACTER"
mga variable sa isang string ng null bytes. Ang mas pinong mga pagpipilian sa pagsisimula ay
ibinigay ng -finit-integer=n, -finit-real= (na siya ring
sinisimulan ang tunay at haka-haka na mga bahagi ng lokal na "COMPLEX" na mga variable),
-finit-logical=, at -finit-character=n (kung saan n ay isang character na ASCII
halaga) mga pagpipilian. Hindi nagsisimula ang mga opsyong ito

* mga inilalaan na array

* mga bahagi ng mga variable na nagmula sa uri

* mga variable na lumalabas sa isang "EQUIVALENCE" na pahayag.

(Maaaring alisin ang mga limitasyong ito sa mga paglabas sa hinaharap).

Tandaan na ang -finit-real=nan sinisimulan ng opsyon ang "REAL" at "COMPLEX" na mga variable na may a
tahimik NaN. Para sa isang senyas na paggamit ng NaN -finit-real=snan; tandaan, gayunpaman, na compile-time
maaaring i-convert ng mga pag-optimize ang mga ito sa tahimik na NaN at kailangang paganahin ang pag-trap
(hal. sa pamamagitan ng -ffpe-trap).

Panghuli, tandaan na ang pagpapagana sa alinman sa -tapos-* mga pagpipilian ay patahimikin ang mga babala na
ipapalabas sana ng -Wuninitialized para sa mga apektadong lokal na variable.

-falign-commons
Sa pamamagitan ng default, gfortran nagpapatupad ng wastong pagkakahanay ng lahat ng mga variable sa isang "COMMON" block sa pamamagitan ng
padding ang mga ito kung kinakailangan. Sa ilang mga platform ito ay sapilitan, sa iba ito ay tumataas
pagganap. Kung ang isang "KARANIWANG" block ay hindi idineklara na may pare-parehong uri ng data
kahit saan, ang padding na ito ay maaaring magdulot ng problema, at -fno-align-commons ay maaaring magamit upang
huwag paganahin ang awtomatikong pag-align. Ang parehong anyo ng pagpipiliang ito ay dapat gamitin para sa lahat ng mga file
na nagbabahagi ng isang "COMMON" block. Upang maiwasan ang mga potensyal na isyu sa pag-align sa mga "COMMON" na mga bloke,
inirerekumenda na mag-order ng mga bagay mula sa pinakamalaki hanggang sa pinakamaliit.

-fno-protect-parents
Bilang default, ang mga panaklong sa pagpapahayag ay pinarangalan para sa lahat ng antas ng pag-optimize tulad nito
na ang compiler ay hindi gumagawa ng anumang muling pag-uugnay. Gamit -fno-protect-parents Binibigyang-daan ang
compiler upang muling ayusin ang mga expression na "REAL" at "COMPLEX" upang makagawa ng mas mabilis na code. Tandaan na
para sa pag-optimize ng muling pagkakaugnay -fno-signed-zero at -fno-trap-math kailangang
may bisa. Ang proteksyon ng panaklong ay pinagana bilang default, maliban kung -Ofast is
binigay

-frealloc-lhs
Ang isang mailalaan na kaliwang bahagi ng isang intrinsic na pagtatalaga ay awtomatikong
(muling) inilalaan kung ito ay hindi inilalaan o may ibang hugis. Ang pagpipilian ay
pinagana bilang default maliban kung kailan -std=f95 ay ibinigay. Tingnan din -Wrealloc-lhs.

-faggressive-function-elimination
Ang mga function na may magkaparehong listahan ng argumento ay inaalis sa loob ng mga pahayag, anuman
kung ang mga function na ito ay may markang "PURE" o hindi. Halimbawa, sa

a = f(b,c) + f(b,c)

magkakaroon lamang ng isang tawag sa "f". Gumagana lang ang opsyong ito kung
-ffrontend-optimize ay may bisa.

-ffrontend-optimize
Ang pagpipiliang ito ay gumaganap ng front-end na pag-optimize, batay sa pagmamanipula ng mga bahagi ng Fortran
puno ng parse. Pinagana bilang default ng alinman -O opsyon. Pinagana nito ang mga pag-optimize
Kasama sa opsyon ang pag-aalis ng magkaparehong function na tawag sa loob ng mga expression, pag-alis
mga hindi kinakailangang tawag sa "TRIM" sa mga paghahambing at pagtatalaga at pagpapalit ng TRIM(a) ng
"a(1:LEN_TRIM(a))". Maaari itong alisin sa pagkakapili sa pamamagitan ng pagtukoy -fno-frontend-optimize.

Kapaligiran


Ang gfortran Ang compiler ay kasalukuyang hindi gumagamit ng anumang mga variable ng kapaligiran upang kontrolin
ang operasyon nito sa itaas at higit pa sa mga nakakaapekto sa operasyon ng gcc.

Gumamit ng mips64el-linux-gnuabi64-gfortran-5 online gamit ang mga serbisyo ng onworks.net


Ad


Ad

Pinakabagong Linux at Windows online na mga programa