$FreeBSD: doc/zh_TW.Big5/books/developers-handbook/tools/chapter.sgml,v 1.1 2006/06/17 10:22:44 vanilla Exp $

     $FreeBSD$

     Original revision: 1.46

  <title>Programming Tools</title>

  <title>µ{¦¡¶}µo¤u¨ã</title>

  <sect1 id="tools-synopsis"><title>Synopsis</title>

  <sect1 id="tools-synopsis"><title>·§±Ô</title>

    <para>This chapter is an introduction to using some of the

    <para>

      programming tools supplied with FreeBSD, although much of it

      ¥»³¹±N¤¶²Ð¦p¦ó¨Ï¥Î¤@¨Ç FreeBSD ©Ò´£¨Ñªºµ{¦¡¶}µo¤u¨ã(programing tools)¡A

      will be applicable to many other versions of &unix;.  It does

      ¥»³¹©Ò¤¶²Ðªº¤u¨ãµ{¦¡¦b¨ä¥Lª©¥»ªº &unix; ¤W¤]¥i¨Ï¥Î¡A

      <emphasis>not</emphasis> attempt to describe coding in any

      ¦b¦¹ <emphasis>¨Ã¤£·|</emphasis> ¹Á¸Õ´y­z¼gµ{¦¡®Éªº¨C­Ó²Ó¸`¡A

      detail.  Most of the chapter assumes little or no previous

      ¥»³¹¤j³¡¤À½g´T³£¬O°²³]§A¥H«e¨S¦³©Î¥u¦³¤Ö¼Æªº¼gµ{¦¡¸gÅç¡A

      programming knowledge, although it is hoped that most

      ¤£¹L¡AÁÙ¬O§Æ±æ¤j¦h¼Æªºµ{¦¡¶}µo¤H­û³£¯à±q¤¤­«·s±o¨ì¤@¨Ç±Òµo¡C

      programmers will find something of value in it.</para>

    </para>

  <sect1 id="tools-intro"><title>Introduction</title>

  <sect1 id="tools-intro"><title>²¤¶</title>

    <para>FreeBSD offers an excellent development environment.

    <para>

      Compilers for C, C++, and Fortran and an assembler come with the

      FreeBSD ´£¨Ñ¤@­Ó«D±`´Îªº¶}µoÀô¹Ò¡A

      basic system, not to mention a Perl interpreter and classic &unix;

      ¤ñ¦p»¡¹³¬O C¡BC++¡BFortran ©M assembler(²Õ¦X»y¨¥)ªº½sĶ¾¹(compiler),

      tools such as <command>sed</command> and <command>awk</command>.

      ¦b FreeBSD ¤¤³£¤w¸g¥]§t¦b°ò¥»ªº¨t²Î¤¤¤F

      If that is not enough, there are many more compilers and

      §ó§O´£ Perl ©M¨ä¥L¼Ð·Ç &unix; ¤u¨ã¡A¹³¬O<command>sed</command> ¥H¤Î <command>awk</command>¡A

      interpreters in the Ports collection.  FreeBSD is very

      ¦pªG§AÁÙ¬Oı±o¤£°÷¡AFreeBSD¦b Ports collection ¤¤ÁÙ´£¨Ñ¨ä¥Lªº½sĶ¾¹©Mª½Ä¶¾¹(interpreter),

      compatible with standards such as <acronym>&posix;</acronym> and

      FreeBSD ¬Û®e³\¦h¼Ð·Ç¡A¹³¬O <acronym>&posix;</acronym> ©M <acronym>ANSI</acronym> C¡A

      <acronym>ANSI</acronym> C, as well with its own BSD heritage, so

      ·íµMÁÙ¦³¥¦©ÒÄ~©Óªº BSD ¶Ç²Î¡C

      it is possible to write applications that will compile and run

      ©Ò¥H¦b FreeBSD ¤W¼gªºµ{¦¡¤£»Ý­×§ï©Î³»¦hµy·L­×§ï¡A´N¥i¥H¦b³\¦h¥­¥x¤W½sĶ¡B°õ¦æ¡C

      with little or no modification on a wide range of

    </para>

      platforms.</para>

    <para>

    <para>However, all this power can be rather overwhelming at first

      µL½×¦p¦ó¡A´Nºâ§A±q¨Ó¨S¦b &unix; ¥­¥x¤W¼g¹Lµ{¦¡¡A¤]¥i¥H¹ý©³·P¨ü¨ìFreeBSD ¥O¤HµLªk§Ü©Úªº°g¤HÅ]¤O¡C

      if you have never written programs on a &unix; platform before.

      ¥»³¹ªº¥Ø¼Ð´N¬O¨ó§U§A§Ö³t¤W¤â¡A¦Ó¼È®É¤£»Ý²`¤J¤Ó¦h¶i¶¥¥DÃD¡A

      This document aims to help you get up and running, without

      ¨Ã¥BÁ¿¸Ñ¤@¨Ç°ò¦·§©À¡A¥HÅý§A¥i¥HÁA¸Ñ§Ú­Ì¦bÁ¿¨Ç¤°»ò¡C

      getting too deeply into more advanced topics.  The intention is

    </para>

      that this document should give you enough of the basics to be

      able to make some sense of the documentation.</para>

    <para>

      ¥»³¹¤º®e¨Ã¤£­n¨D§A±o¦³µ{¦¡¶}µo¸gÅç¡A©ÎªÌ§A¥u¦³¤@ÂIÂIªº¸gÅç¦Ó¤w¡C

    <para>Most of the document requires little or no knowledge of

      ¤£¹L¡A§Ú­Ì°²³]§A¤w¸g·| &unix; ¨t²Îªº°ò¥»¾Þ§@¡A

      programming, although it does assume a basic competence with

      ¦Ó¥B§ó­«­nªº¬O¡A½Ð«O«ù¼Ö©ó¾Ç²ßªº¤ßºA¡I

      using &unix; and a willingness to learn!</para>

    </para>

    <title>Introduction to Programming</title>

    <title>Programming ·§©À</title>

    <para>A program is a set of instructions that tell the computer to

    <para>

      do various things; sometimes the instruction it has to perform

      ²³æªº»¡¡Aµ{¦¡¥u¬O¤@°ï«ü¥Oªº¶°¦XÅé¡F¦Ó³o¨Ç«ü¥O¬O¥Î¨Ó§i¶D¹q¸£À³¸Ó­n§@¨º¨Ç¨Æ±¡¡C

      depends on what happened when it performed a previous

      ¦³®É­Ô¡A«ü¥Oªº°õ¦æ¨ú¨M©ó«e¤@­Ó«ü¥Oªºµ²ªG¦Ó©w¡C

      instruction.  This section gives an overview of the two main

      ¥»³¹±N·|§i¶D§A¦³ 2 ­Ó¥D­nªº¤èªk¡AÅý§A¥i¥H¹ï¹q¸£¤U¹F³o¨Ç«ü¥Ü(instruction) ©Î <quote>©R¥O(commands)</quote>¡C

      ways in which you can give these instructions, or

      ²Ä¤@­Ó¤èªk´N¬O <firstterm>ª½Ä¶¾¹(interpreter)</firstterm>¡A

      <quote>commands</quote> as they are usually called.  One way

      ¦Ó²Ä¤G­Ó¤èªk¬O <firstterm>½sĶ¾¹(compiler)</firstterm>¡C

      uses an <firstterm>interpreter</firstterm>, the other a

      ¥Ñ©ó¹ï©ó¹q¸£¦Ó¨¥¡A¤HÃþ»y¨¥ªº»y·N¹L©ó¼Ò½k¦Ó¤ÓÃø²z¸Ñ¡A

      <firstterm>compiler</firstterm>.  As human languages are too

      ¦]¦¹©R¥O(commands)´N±`·|¥H¤@ºØ(©Î¦hºØ)µ{¦¡»y¨¥¼g¦¨¡A¥Î¨Ó«ü¥Ü¹q¸£©Ò­n°õ¦æªº¯S©w°Ê§@¬°¦ó¡C

      difficult for a computer to understand in an unambiguous way,

    </para>

      commands are usually written in one or other languages specially

      designed for the purpose.</para>

      <title>Interpreters</title>

      <title>ª½Ä¶¾¹</title>

      <para>With an interpreter, the language comes as an environment,

      <para>

	where you type in commands at a prompt and the environment

        ¨Ï¥Îª½Ä¶¾¹®É¡A©Ò¨Ï¥Îªºµ{¦¡»y¨¥´N¹³Åܦ¨¤@­Ó·|©M§A¤¬°ÊªºÀô¹Ò¡C

	executes them for you.  For more complicated programs, you can

        ·í¦b©R¥O´£¥Ü¦C¤W¥´¤W©R¥O®É¡Aª½Ä¶¾¹·|§Y®É°õ¦æ¸Ó©R¥O¡C

	type the commands into a file and get the interpreter to load

        ¦b¤ñ¸û½ÆÂøªºµ{¦¡¤¤¡A¥i¥H§â©Ò¦³·Q¤U¹Fªº©R¥O²Î²Î¿é¤J¨ì¬YÀɮ׸̭±¥h¡A

	the file and execute the commands in it.  If anything goes

        µM«á©I¥sª½Ä¶¾¹¥hŪ¨ú¸ÓÀɮסA¨Ã¥B°õ¦æ§A¼g¦b³o­ÓÀɮפ¤ªº«ü¥O¡C

	wrong, many interpreters will drop you into a debugger to help

        ¦pªG©Ò¤Uªº«ü¥O¦³¿ù»~²£¥Í¡A¤j¦h¼Æªºª½Ä¶¾¹·|¶i¤J°»¿ù¼Ò¦¡(debugger)¡A

	you track down the problem.</para>

        ¨Ã¥BÅã¥Ü¬ÛÃö¿ù»~°T®§¡A¥H«K¹ïµ{¦¡°£¿ù¡C

    </para>

      <para>The advantage of this is that you can see the results of

	your commands immediately, and mistakes can be corrected

      <para>

	readily.  The biggest disadvantage comes when you want to

	³oºØ¤è¦¡¦n³B¦b©ó¡G¥i¥H¥ß¨è¬Ý¨ì«ü¥Oªº°õ¦æµ²ªG¡A¥H¤Î¿ù»~¤]¥i¨³³t­×¥¿¡C

	share your programs with someone.  They must have the same

	¬Û¹ïªº¡A³Ì¤jªºÃa³B«K¬O·í§A·Q§â§A¼gªºµ{¦¡¤À¨Éµ¹¨ä¥L¤H®É¡A³o¨Ç¤H¥²¶·­n¦³¸ò§A¤@¼Ëªºª½Ä¶¾¹¡C

	interpreter, or you must have some way of giving it to them,

	¦Ó¥B§O§Ñ¤F¡A¥L­Ì¤]­n·|¨Ï¥Îª½Ä¶¾¹ª½Ä¶µ{¦¡¤~¦æ¡C

	and they need to understand how to use it.  Also users may not

	·íµM¨Ï¥ÎªÌ¤]¤£§Æ±æ¤£¤p¤ß«ö¿ùÁä¡A´N¶i¤J°»¿ù¼Ò¦¡¦Ó¤£ª¾©Ò±¹¡C

	appreciate being thrown into a debugger if they press the

	´N°õ¦æ®Ä²v¦Ó¨¥¡Aª½Ä¶¾¹·|¨Ï¥Î¨ì«Ü¦hªº°O¾ÐÅé¡A

	wrong key! From a performance point of view, interpreters can

	¦Ó¥B³oÃþª½Ä¶¦¡µ{¦¡¡A³q±`¨Ã¤£·|¤ñ½sĶ¾¹©Ò½sĶªºµ{¦¡ªº§ó¦³®Ä²v¡C

	use up a lot of memory, and generally do not generate code as

	</para>

	efficiently as compilers.</para>

      <para>

      <para>In my opinion, interpreted languages are the best way to

	µ§ªÌ­Ó¤H»{¬°¡A¦pªG§A¤§«e¨S¦³¾Ç¹L¥ô¦óµ{¦¡»y¨¥¡A³Ì¦n¥ý¾Ç¾Ç²ßª½Ä¶¦¡»y¨¥(interpreted languages)¡A

	start if you have not done any programming before.  This kind

	¹³¬O Lisp¡ASmalltalk¡APerl ©M Basic ³£¬O¡A&unix; ªº shell ¹³¬O <command>sh</command> ©M <command>csh</command>

	of environment is typically found with languages like Lisp,

	¥¦­Ì¥»¨­´N¬Oª½Ä¶¾¹¡A¨Æ¹ê¤W¡A«Ü¦h¤H³£¦b¥¦­Ì¦Û¤v¾÷¾¹¤W¼¶¼g¦U¦¡ªº shell <quote>script</quote>¡A

	Smalltalk, Perl and Basic.  It could also be argued that the

	¨Ó¶¶§Q§¹¦¨¦U¶µ <quote>housekeeping(ºûÅ@)</quote> ¥ô°È¡C

	&unix; shell (<command>sh</command>, <command>csh</command>) is itself an

	&unix; ¨Ï¥Î­õ¾Ç¤§¤@´N¬O´£¨Ñ¤j¶qªº¤p¤u¨ã¡A

	interpreter, and many people do in fact write shell

	¨Ã¨Ï¥Î shell script ¨Ó²Õ¦X¹B¥Î³o¨Ç¤p¤u¨ã¡A¥H«K¤u§@§ó¦³®Ä²v¡C

	<quote>scripts</quote> to help with various

	<quote>housekeeping</quote> tasks on their machine.  Indeed, part

	of the original &unix; philosophy was to provide lots of small

	utility programs that could be linked together in shell

	scripts to perform useful tasks.</para>

      <title>Interpreters available with FreeBSD</title>

      <title>FreeBSD ´£¨Ñªºª½Ä¶¾¹</title>

      <para>Here is a list of interpreters that are available from 

      <para> 

	  the &os; Ports Collection, with a brief discussion of

	¤U­±³oÃ䦳¥÷ &os; Ports Collection ©Ò´£¨Ñªºª½Ä¶¾¹²M³æ¡AÁÙ¦³°Q½×¤@¨Ç¤ñ¸û¨üÅwªïªºª½Ä¶¦¡»y¨¥</para>

	  some of the more popular interpreted languages.</para>

      <para>Instructions on how to get and install applications

	from the Ports Collection can be found in the

	<ulink url="&url.books.handbook;/ports-using.html">

      Ports section</ulink> of the handbook. 

	    <para>Short for Beginner's All-purpose Symbolic

	    <para>BASIC ¬O Beginner's ALL-purpose Symbolic Instruction Code ªºÁY¼g¡C

	      Instruction Code.  Developed in the 1950s for teaching

	      BASIC ©ó 1950 ¦~¥N¶}©lµo®i¡A³Ìªì¶}µo³o®M»y¨¥ªº¥Øªº¬O¬°¤F±Ð¾É·í®Éªº¤j¾Ç¾Ç¥Í¦p¦ó¼gµ{¦¡¡C

	      University students to program and provided with every

	      ¨ì¤F 1980¡A<acronym>BASIC</acronym>¤w¸g¬O«Ü¦h programmer ²Ä¤@­Ó¾Ç²ßªºµ{¦¡»y¨¥¤F¡C

	      self-respecting personal computer in the 1980s,

	      ¦¹¥~¡ABASIC ¤]¬O Visual Basic ªº°ò¦¡C</para>

	      <acronym>BASIC</acronym> has been the first programming

	      language for many programmers.  It is also the foundation

	    <para>FreeBSD Ports Collection ¤]¦³¦¬¿ý¬ÛÃöªº BASIC ª½Ä¶¾¹¡C

	      for Visual Basic.</para>

	      Bywater Basic ª½Ä¶¾¹©ñ¦b <filename role="package">lang/bwbasic</filename>¡C

	      ¦Ó Phil Cockroft's Basic ª½Ä¶¾¹(¦­´Á¤]¥s Rabbit Basic)©ñ¦b <filename role="package">lang/pbasic</filename>¡C

	    <para>The Bywater Basic Interpreter can be found in the

	      Ports Collection as

	      <filename role="package">lang/bwbasic</filename>

	      and the Phil Cockroft's Basic Interpreter

	      (formerly Rabbit Basic) is available as

	      <filename role="package">lang/pbasic</filename>.</para>

	    <para>A language that was developed in the late 1950s as

	    <para>LISP ¬O¦b 1950 ¦~¥N¶}©lµo®iªº¤@­Óª½Ä¶¦¡»y¨¥¡A¦Ó¥B LISP ´N¬O¤@ºØ 

	      an alternative to the <quote>number-crunching</quote>

	      <quote>number-crunching</quote> languages(¨³³t¶i¦æ¤j¶q¹Bºâªºµ{¦¡»y¨¥)¡A¦b·í®Éºâ¬O¤@­Ó´¶¹Mªºµ{¦¡»y¨¥¡C

	      languages that were popular at the time.  Instead of

	      LISP ªºªí¹F¤£¬O°ò©ó¼Æ¦r(numbers)¡A¦Ó¬O°ò©óªí(lists)¡C

	      being based on numbers, Lisp is based on lists; in fact

	      ¦Ó³Ì¯àªí¥Ü¥X LISP ¯S¦âªº¦a¤è´N¦b©ó¡G LISP ¬O <quote>List Processing</quote> ªºÁY¼g¡C

	      the name is short for <quote>List Processing</quote>.

	      ¦b<acronym>¤H¤u´¼¼z(Artificial Intelligence, AI)</acronym>»â°ì¤W LISP ªº¦U¦¡À³¥Î«D±`´¶¹M¡C</para>

	      Very popular in <acronym>AI</acronym> (Artificial Intelligence)

	      circles.</para>

	    <para>LISP ¬O«D±`±j®«¥B½ÆÂøªºµ{¦¡»y¨¥¡A¦ý¬O¯ÊÂI¬Oµ{¦¡½X·|«D±`¤j¦Ó¥BÃø¥H¾Þ§@¡C</para>

	    <para>Lisp is an extremely powerful and sophisticated

	    <para>µ´¤j³¡¤Àªº LISP ª½Ä¶¾¹³£¥i¥H¦b &unix; ¨t²Î¤W¹B§@¡A·íµM &os; ªº Ports Collection ¤]¦³¦¬¿ý¡C

	      language, but can be rather large and unwieldy.</para>

	      GNU Common Lisp ¦¬¿ý¦b <filename role="package">lang/gcl</filename>¡A

	      Bruno Haible ©M Michael Stoll ªº CLISP ¦¬¿ý¦b <filename role="package">lang/clisp</filename>

	    <para>Various implementations of Lisp that can run on &unix;

	      ¡A¦¹¥~ CMUCL(¥]§t¤@­Ó¤w¸g³Ì¨Î¤Æªº½sĶ¾¹)¡A

	      systems are available in the Ports Collection for &os;.

	      ¥H¤Î¨ä¥L²¤Æª©ªº LISP ª½Ä¶¾¹(¤ñ¦p¥H C »y¨¥¼gªº SLisp¡A¥u¥Î´X¦Ê¦æµ{¦¡½X´N¹ê§@¤j¦h¼Æ Common Lisp ªº¥\¯à)

	      GNU Common Lisp can be found as

	      «h¬O¤À§O¦¬¿ý¦b <filename role="package">lang/cmucl</filename> ¥H¤Î 

	      <filename role="package">lang/gcl</filename>.  CLISP

	      <filename role="package">lang/slisp</filename>¡C

	      by Bruno Haible and Michael Stoll is available as

	      </para>

	      <filename role="package">lang/clisp</filename>.

	      For CMUCL, which includes a highly-optimizing compiler too, or

	      simpler Lisp implementations like SLisp, which implements most

	      of the Common Lisp constructs in a few hundred lines of C code,

	      <filename role="package">lang/cmucl</filename> and

	      <filename role="package">lang/slisp</filename> are available

	      respectively.</para>

	    <para>Very popular with system administrators for writing

	    <para>¹ï¨t²ÎºÞ²zªÌ¦Ó¨¥¡A³Ì·R¥Î perl ¨Ó¼¶¼g scripts ¥HºÞ²z¥D¾÷¡A

	      scripts; also often used on World Wide Web servers for

	      ¦P®É¤]¸g±`¥Î¨Ó¼g WWW ¥D¾÷¤Wªº <acronym>CGI</acronym> Script µ{¦¡¡C</para>

	      writing <acronym>CGI</acronym> scripts.</para>

	    <para>Perl ¦b Ports Collection ¤ºªº <filename role="package">lang/perl5</filename>¡C

	    <para>Perl is available in the Ports Collection as 

	      ¦Ó &os; 4.X «h¬O§â Perl ¸Ë¦b <command>/usr/bin/perl</command>¡C</para>

	      <filename role="package">lang/perl5</filename> for all

	      &os; releases, and is installed as <command>/usr/bin/perl</command>

	      in the base system 4.X releases.</para>

	    <para>A dialect of Lisp that is rather more compact and

	    <para>Scheme ¬O LISP ªº¥t¤@¤À¤ä¡AScheme ªº¯SÂI´N¬O¤ñ Common LISP ÁÙ­n²¼ä¦³¤O¡C

	      cleaner than Common Lisp.  Popular in Universities as it

	      ¥Ñ©ó Scheme ²³æ¡A©Ò¥H«Ü¦h¤j¾Ç®³¨Ó·í§@²Ä¤@°óµ{¦¡»y¨¥±Ð¾Ç±Ð§÷¡C

	      is simple enough to teach to undergraduates as a first

	      ¦Ó¥B¹ï©ó¬ã¨s¤H­û¨Ó»¡¤]¥i¥H§Ö³tªº¶}µo¥L­Ì©Ò»Ý­nªºµ{¦¡¡C

	      language, while it has a high enough level of

	      </para>

	      abstraction to be used in research work.</para>

	    <para>Scheme ¦¬¿ý¦b <filename role="package">lang/elk</filename>¡A

	    <para>Scheme is available from the Ports Collection as

	      Elk Scheme ª½Ä¶¾¹(¥Ñ³Â¬Ù²z¤u¾Ç°|©Òµo®iªº Scheme ª½Ä¶¾¹)¦¬¿ý¦b 

	      <filename role="package">lang/elk</filename> for the

	      <filename role="package">lang/mit-scheme</filename>¡A

		Elk Scheme Interpreter.  The MIT Scheme Interpreter

	      SCM Scheme Interpreter ¦¬¿ý¦b <filename role="package">lang/scm</filename>¡C</para>

		can be found in

		<filename role="package">lang/mit-scheme</filename>

		and the SCM Scheme Interpreter in

		<filename role="package">lang/scm</filename>.</para>

	    <para>Icon is a high-level language with extensive

	    <para>Icon ÄÝ°ª¶¥µ{¦¡»y¨¥¡AIcon ¨ã¦³±j¤jªº¦r¦ê(String)©Mµ²ºc(Structure)³B²z¯à¤O¡C

	      facilities for processing strings and structures.

	      &os; Ports Collection ©Ò¦¬¿ýªº Icon ª½Ä¶¾¹ª©¥»«h¬O©ñ¦b 

	      The version of Icon for &os; can be found in the

	      <filename role="package">lang/icon</filename>¡C</para>

	      Ports Collection as

	      <filename role="package">lang/icon</filename>.</para>

	    <para>Logo is a language that is easy to learn, and has

	    <para>Logo ¬OºØ®e©ö¾Ç²ßªºµ{¦¡»y¨¥¡A³Ì±`¦b¤@¨Ç±Ð¾Ç½Òµ{¤¤³Q®³¨Ó·í§@¶}ÀY½d¨Ò¡C

	      been used as an introductory programming language in

	      ¦pªG­nµ¹¤pªB¤Í¶}©l¤Wµ{¦¡»y¨¥½Òªº¸Ü¡ALogo ¬O¬Û·í¤£¿ùªº¿ï¾Ü¡C

	      various courses.  It is an excellent tool to work with

	      ¦]¬°¡A§Y¨Ï¹ï¤pªB¤Í¨Ó»¡¡A­n¥Î Logo ¨Ó¨q¥X½ÆÂø¦hÃä§Î¹Ï§Î¬O¬Û·í»´ÃP®e©öªº¡C</para>

	      when teaching programming in small ages, as it makes the

	      creation of elaborate geometric shapes an easy task even

	    <para>Logo ¦b &os; Ports Collection ªº³Ì·sª©«h¬O©ñ¦b <filename role="package">lang/logo</filename>¡C</para>

	      for very small children.</para>

	    <para>The lastest version of Logo for &os; is available from

	      the Ports Collection in

	      <filename role="package">lang/logo</filename>.</para>

	    <para>Python is an Object-Oriented, interpreted language.

	    <para>Python ¬Oª«¥ó¾É¦Vªºª½Ä¶¦¡»y¨¥¡A

	      Its advocates argue that it is one of the best languages

	      Python ªº¾ÖÅ@ªÌÁ`¬O«ÅºÙ Python ¬O³Ì¦n¤Jªùªºµ{¦¡»y¨¥¡C

	      to start programming with, since it is relatively easy

	      ÁöµM Python ¥i¥H«Ü²³æªº¶}©l¡A¦ý¬O¤£¥Nªí¥¦´N·|¿éµ¹¨ä¥Lª½Ä¶¦¡»y¨¥(¹³¬O Perl ©M Tcl)¡A

	      to start with, but is not limited in comparison to other

	      ¨Æ¹êÃÒ©ú Python ¤]¥i¥H®³¨Ó¶}µo¤j«¬¡B½ÆÂøªºÀ³¥Îµ{¦¡¡C

	      popular interpreted languages that are used for the

	      </para>

	      development of large, complex applications (Perl and

	      Tcl are two other languages that are popular for such tasks).</para>

	    <para>&os; Ports Collection ¦¬¿ý¦b <filename role="package">lang/python</filename>¡C</para>

	    <para>The latest version of Python is available from the

	      Ports Collection in

	      <filename role="package">lang/python</filename>.</para>

	    <para>Ruby is an interpreter, pure object-oriented programming

	    <para>Ruby ¬O¯Âª«¥ó¾É¦Vªºª½Ä¶¦¡»y¨¥¡C

	      language.  It has become widely popular because of its easy

	      Ruby ¥Ø«e«D±`¬y¦æ¡A­ì¦]¦b©ó¥L©öÀ´ªºµ{¦¡»yªkµ²ºc¡A¦b¼¶¼gµ{¦¡®Éªº¼u©Ê¡A

	      to understand syntax, flexibility when writing code, and the

	      ¥H¤Î¤Ñ¥Í¨ã¦³»´©öªºµo®iºûÅ@¤j«¬±M®×ªº¯à¤O¡C</para>

	      ability to easily develop and maintain large, complex

	      programs.</para>

	    <para>Ruby is available from the Ports Collection as

	    <para>&os; Ports Collection ¦¬¿ý¦b <filename role="package">lang/ruby8</filename>¡C</para> 

	      <filename role="package">lang/ruby18</filename>.</para> 

	    <para>Tcl is an embeddable, interpreted language, that has

	    <para>Tcl ¬O¤º´O¦¡ªºª½Ä¶¦¡»y¨¥¡AÅý Tcl ¥i¥H¦p¦¹¼sªx¹B¥Îªº­ì¦]¬O Tcl ªº²¾´Ó©Ê¡C

	      become widely used and became popular mostly because of its portability to many

	      Tcl ¤]¥i¥H§Ö³tµo®i¤@­Ó²³æ¦ý¬O¨ã¦³Âú«¬ªºµ{¦¡©ÎªÌ¨ã¦³§¹¾ã¥\¯àªºµ{¦¡¡C</para>

	      platforms.  It can be used both for quickly writing

	      small, prototype applications, or (when combined with

	    <para>Tcl ³\¦hªºª©¥»³£¥i¦b &os; ¤W¹B§@¡A¦Ó³Ì·sªº Tcl ª©¥»¬° Tcl 8.4¡A

	      Tk, a GUI toolkit) fully-fledged, featureful

	      &os; Ports Collection ¦¬¿ý¦b <filename role="package">lang/tcl84</filename>¡C</para>

	      programs.</para>

	    <para>Various versions of Tcl are available as ports 

	      for &os;.  The latest version, Tcl 8.4, can be found in

	      <filename role="package">lang/tcl84</filename>.</para>

      <title>Compilers</title>

      <title>½sĶ¾¹</title>

      <para>Compilers are rather different.  First of all, you write

	your code in a file (or files) using an editor.  You then run

	the compiler and see if it accepts your program.  If it did

	not compile, grit your teeth and go back to the editor; if it

	did compile and gave you a program, you can run it either at a

	shell command prompt or in a debugger to see if it works

	properly.

	  <para>If you run it in the shell, you may get a core

	  <para>¦pªG¦b´£¥Ü©R¥O¦C¤U°õ¦æ¡A¨º»ò¦³¥i¯à·|²£¥Í core dump¡C</para>

	    dump.</para>

      <para>Obviously, this is not quite as direct as using an

      <para>«Ü©úÅ㪺¡A¨Ï¥Î½sĶ¾¹¨Ã¤£¹³ª½Ä¶¾¹¯ë¥i¥H°¨¤W±o¨ìµ²ªG¡C

	interpreter.  However it allows you to do a lot of things

        ¤£ºÞ¦p¦ó¡A½sĶ¾¹¤¹³\§A§@«Ü¦hª½Ä¶¾¹¤£¥i¯à©ÎªÌ¬O«ÜÃø¹F¨ìªº¨Æ±¡¡C

	which are very difficult or even impossible with an

        ¨Ò¦p¡G¼¶¼g©M§@·~¨t²Î±K¤Á¤¬°Êªºµ{¦¡¡A¬Æ¦Ü¬O§A¦Û¤v¼gªº§@·~¨t²Î¡I

	interpreter, such as writing code which interacts closely with

        ·í§A·Q­n¼g¥X°ª®Ä²vªºµ{¦¡®É¡A½sĶ¾¹«K¬£¤W¥Î³õ¤F¡C

	the operating system—or even writing your own operating

        ½sĶ¾¹¥i¥H¦b½sĶ®É¶¶«K³Ì¨Î¤Æ§Aªºµ{¦¡¡A¦ý¬Oª½Ä¶¾¹«o¤£¦æ¡C

	system! It is also useful if you need to write very efficient

        ¦Ó½sĶ¾¹»Pª½Ä¶¾¹³Ì¤jªº®t§O¦b©ó¡G·í§A·Q§â§A¼g¦nªºµ{¦¡®³¨ì¥t¥~¤@¥x¾÷¾¹¤W¶]®É¡A

	code, as the compiler can take its time and optimize the code,

        §A¥u­n±N½sĶ¾¹½sĶ¥X¨Óªº¥i°õ¦æÀÉ¡A®³¨ì·s¾÷¾¹¤W«K¥i¥H°õ¦æ¡A

	which would not be acceptable in an interpreter.  Moreover,

        ¦Óª½Ä¶¾¹«h¥²¶·­n¨D·s¾÷¾¹¤W¡A¥²¶·­n¦³¸ò¥t¤@¥x¾÷¾¹¤W¬Û¦Pªºª½Ä¶¾¹¡A

	distributing a program written for a compiler is usually more

        ¤~¯à²ÕĶ°õ¦æ§Aªºµ{¦¡¡I

	straightforward than one written for an interpreter—you

	</para>

	can just give them a copy of the executable, assuming they

	have the same operating system as you.</para>

      <para>½sĶ¦¡ªºµ{¦¡»y¨¥¥]§t Pascal¡BC ©M C++¡A

        C ©M C++ ¤£¬O¤@­Ó¿Ë©M¤O¤Q¨¬ªº»y¨¥¡A¦ý¬O«Ü¾A¦X¨ã¦³¸gÅ窺 Programmer¡C

      <para>Compiled languages include Pascal, C and C++.  C and C++

        Pascal ¨ä¹ê¬O¤@­Ó³]­p¥Î¨Ó±Ð¾Ç¥Îªºµ{¦¡»y¨¥¡A¦Ó¥B¤]«Ü¾A¦X¥Î¨Ó¤Jªù¡A

	are rather unforgiving languages, and best suited to more

        &os; ¹w³]¨Ã¨S¦³§â Pascal ¾ã¦X¶i base system ¤¤¡A

	experienced programmers; Pascal, on the other hand, was

        ¦ý¬O GNU Pascal Compiler ©M Free Pascal Compiler ³£¥i¤À§O¦b 

	designed as an educational language, and is quite a good

        <filename role="package">lang/gpc</filename> ©M <filename role="package">lang/fpc</filename> ¤¤§ä¨ì¡C</para>

	language to start with.  FreeBSD does not include Pascal

	support in the base system, but both GNU Pascal Compiler (GPC)

      <para>¦pªG§A¥Î¤£¦Pªºµ{¦¡¨Ó¼g½sĶ¦¡µ{¦¡¡A¨º»ò¤£Â_¦a½s¿è-½sĶ-°õ¦æ-°£¿ùªº³o­Ó´`ÀôªÖ©w·|«Ü·Ð¤H¡A

	and the Free Pascal Compiler

        ¬°¤F§ó²¤Æ¡B¤è«Kµ{¦¡¶}µo¬yµ{¡A«Ü¦h°Ó·~½sĶ¾¹¼t°Ó¶}©lµo®i©Ò¿×ªº <acronym>IDE</acronym>(Integrated Development Environments) ¶}µoÀô¹Ò¡A

	are available in the ports collection as

        FreeBSD ¹w³]¨Ã¨S¦³§â IDE ¾ã¦X¶i base system ¤¤¡A¦ý¬O§A¥i³z¹L <filename role="package">devel/kdevelop</filename> ¦w¸Ë kdevelop 

	<filename role="package">lang/gpc</filename> and

        ©Î¨Ï¥Î <application>Emacs</application> ¨ÓÅéÅç IDE ¶}µoÀô¹Ò¡C

	<filename role="package">lang/fpc</filename>.</para>

        ¦b«á­±ªº <xref linkend="emacs"> ±MÃD±N¤¶²Ð¡A¦p¦ó¥H <application>Emacs</application> ¨Ó§@¬° IDE ¶}µoÀô¹Ò¡C</para>

      <para>As the edit-compile-run-debug cycle is rather tedious when

	using separate programs, many commercial compiler makers have

	produced Integrated Development Environments

	(<acronym>IDE</acronym>s for short).  FreeBSD does not include

	an IDE in the base system, but <filename role="package">devel/kdevelop</filename> is

	available in the ports tree and many use

	<application>Emacs</application> for this purpose.  Using

	<application>Emacs</application> as an IDE is discussed in

	<xref linkend="emacs">.</para>

    <title>Compiling with <command>cc</command></title>

    <title>¥Î <command>cc</command> ¨Ó½sĶµ{¦¡</title>

      <para>¥»³¹½d¨Ò¥u¦³°w¹ï GNU C compiler ©M GNU C++ compiler §@»¡©ú¡A

        ³o¨â­Ó¦b FreeBSD base system ¤¤´N¦³¤F¡A

        ª½±µ¥´ <command>cc</command> ©Î <command>gcc</command> ´N¥i¥H°õ¦æ¡C

        ¦Ü©ó¡A¦p¦ó¥Îª½Ä¶¾¹²£¥Íµ{¦¡ªº»¡©ú¡A³q±`¥i¦bª½Ä¶¾¹ªº¤å¥ó©Î½u¤W¤å¥ó§ä¨ì»¡©ú¡A¦]¦¹¤£¦AÂØ­z¡C</para>

    <para>This section deals only with the GNU compiler for C and C++,

      <para>·í§A¼g§¹§Aªº³Ç§@«á¡A±µ¤U¨Ó«K¬OÅý³o­Óµ{¦¡¥i¥H¦b FreeBSD ¤W°õ¦æ¡A

      since that comes with the base FreeBSD system.  It can be

        ³q±`³o¨Ç­n¤@¨Ç¨BÆJ¤~¯à§¹¦¨¡A¦³¨Ç¨BÆJ«h»Ý­n¤£¦Pµ{¦¡¨Ó§¹¦¨¡C</para>

      invoked by either <command>cc</command> or <command>gcc</command>.  The

      details of producing a program with an interpreter vary

      considerably between interpreters, and are usually well covered

      in the documentation and on-line help for the

      interpreter.</para>

    <para>Once you have written your masterpiece, the next step is to

      convert it into something that will (hopefully!) run on FreeBSD.

      This usually involves several steps, each of which is done by a

      separate program.</para>

	<para>Pre-process your source code to remove comments and do

        <para>¹w¥ý³B²z(Pre-process)§Aªºµ{¦¡½X¡A²¾°£µ{¦¡¤ºªºµù¸Ñ¡A©M¨ä¥L§Þ¥©¡A

	  other tricks like expanding macros in C.</para>

          ¹³¬O expanding(ÂX¤j) C ªº marco¡C</para>

	<para>Check the syntax of your code to see if you have obeyed

        <para>½T»{§Aªºµ{¦¡»yªk¬O§_½T¹ê¿í·Ó C/C++ ªº³W©w¡A¦pªG¨S¦³²Å¦Xªº¸Ü¡A½sĶ¾¹·|¥X²{ĵ§i¡C</para>

	  the rules of the language.  If you have not, it will

	  complain!</para>

	<para>Convert the source code into assembly

        <para>±N­ì©l½XÂন²Õ¦X»y¨¥ &mdash; ¥¦¸ò¾÷¾¹»y¨¥(machine code)«D±`¬Ûªñ¡A¦ý¤´¦b¤HÃþ¥i²z¸Ñªº½d³ò¤º(¾Ú»¡À³¸Ó¬O³o¼Ë)¡C

	  language—this is very close to machine code, but still

	  understandable by humans.  Allegedly.

	    <para>To be strictly accurate, <command>cc</command> converts the

        <para>ÄY®æ»¡°_¨Ó¡A¦b³o­Ó¶¥¬q <command>cc</command> ¨Ã¤£¬O¯uªº§â­ì©lµ{¦¡Âন²Õ¦X»y¨¥¡A

	      source code into its own, machine-independent

          ¦Ó¬OÂର machine-independent ªº <firstterm>p-code</firstterm>¡C</para>

	      <firstterm>p-code</firstterm> instead of assembly language at

	      this stage.</para>

	<para>Convert the assembly language into machine

        <para>§â²Õ¦X»y¨¥Âন¾÷¾¹»y¨¥ &mdash; ¬Oªº¡A³o¸Ì»¡ªº¾÷¾¹»y¨¥´N¬O±`´£¨ìªº bit ©M byte¡A¤]´N¬O 1 ©M 0¡C</para>

	  code—yep, we are talking bits and bytes, ones and

	  zeros here.</para>

	<para>Check that you have used things like functions and

        <para>½T»{µ{¦¡¤¤¥Î¨ìªº¨ç¦¡©I¥s¡B¥þ°ìÅܼƬO§_¥¿½T¡AÁ|¨Ò¨Ó»¡¡G¦p­Y©I¥s¤F¤£¦s¦bªº¨ç¦¡¡A½sĶ¾¹·|Åã¥Üĵ§i¡C</para>

	  global variables in a consistent way.  For example, if you

	  have called a non-existent function, it will

	  complain.</para>

	<para>If you are trying to produce an executable from several

        <para>¦pªGµ{¦¡¬O¥Ñµ{¦¡½XÀɮרӽsĶ¡A½sĶ¾¹·|¾ã¦X°_¨Ó¡C</para>

	  source code files, work out how to fit them all

	  together.</para>

	<para>Work out how to produce something that the system's

        <para>½sĶ¾¹·|­t³d²£¥ÍªF¦è¡AÅý¨t²Î¤Wªº run-time loader ¥i¥H§âµ{¦¡¸ü¤J°O¾ÐÅ餺°õ¦æ¡C</para>

	  run-time loader will be able to load into memory and

	  run.</para>

	<para>Finally, write the executable on the filesystem.</para>

        <para>³Ì«á·|§â½sĶ§¹ªº°õ¦æÀɦs¦bµwºÐ¤W¡C</para>

    <para>The word <firstterm>compiling</firstterm> is often used to refer to

    <para>³q±` <firstterm>½sĶ(compiling)</firstterm> ¬O«ü²Ä 1 ¨ì²Ä 4 ­Ó¨BÆJ¡C

      just steps 1 to 4—the others are referred to as

      &mdash; ¨ä¥L¨BÆJ«hºÙ¬° <firstterm>³sµ²(linking)</firstterm>¡A

      <firstterm>linking</firstterm>.  Sometimes step 1 is referred to as

      ¦³®É­Ô¨BÆJ 1 ¤]¥i¥H¬O«ü <firstterm>¹w¥ý³B²z(pre-processing)</firstterm>¡A

      <firstterm>pre-processing</firstterm> and steps 3-4 as

      ¦Ó¨BÆJ 3 ¨ì¨BÆJ 4 «h¬O <firstterm>²ÕĶ(assembling)</firstterm>¡C</para>

      <firstterm>assembling</firstterm>.</para>

    <para>©¯¹Bªº¬O¡A§A¥i¥H¤£¥Î²z·|¥H¤W²Ó¸`¡A½sĶ¾¹³£·|¦Û°Ê§¹¦¨¡C

    <para>Fortunately, almost all this detail is hidden from you, as

      ¦]¬° <command>cc</command> ¥u¬O¬O­Ó«eºÝµ{¦¡(front end)¡A¥¦·|¨Ì·Ó¥¿½Tªº°Ñ¼Æ¨Ó©I¥s¬ÛÃöµ{¦¡À°§A³B²z¡C

      <command>cc</command> is a front end that manages calling all these

      ¥u»Ý¥´¡G

      programs with the right arguments for you; simply typing</para>

    <para>will cause <filename>foobar.c</filename> to be compiled by all the

    <para>¤W­z«ü¥O·|§â <filename>foobar.c</filename> ¶}©l½sĶ¡A¨Ã§¹¦¨¤W­z°Ê§@¡C

      steps above.  If you have more than one file to compile, just do

      ¦pªG§A¦³³\¦hÀɮ׻ݭn½sĶ¡A¨º½Ð¥´Ãþ¦ü¤U¦C«ü¥O§Y¥i¡G</para>

      something like</para>

    <para>Note that the syntax checking is just that&mdash;checking

    <para>°O¦í»yªk¿ù»~Àˬd´N¬O &mdash; ¯ÂºéÀˬd»yªk¿ù»~»P§_¡A

      the syntax.  It will not check for any logical mistakes you may

      ¦Ó¤£·|À°§AÀË´ú¥ô¦óÅÞ¿è¿ù»~¡A¤ñ¦p¡GµL­­°j°é¡A©Î¬O±Æ§Ç¤è¦¡·Q¥Î binary sort «o§Ë¦¨ bubble sort¡C

      have made, like putting the program into an infinite loop, or

      using a bubble sort when you meant to use a binary

      sort.

	<para>In case you did not know, a binary sort is an efficient

        <para>­è©Ò»¡ªº binary sort ©M bubble sort °ÝÃD¡A

	  way of sorting things into order and a bubble sort

          ¦b¤w±Æ§Ç¦nªº§Ç¦C¤¤¡Abinary sort ·j¯Á®Ä²v·|¤ñ bubble sort ¦n¡C</para>

	  is not.</para>

    <para>There are lots and lots of options for <command>cc</command>, which

    <para><command>cc</command> ¦³«D±`¦hªº¿ï¶µ¡A³£¥i³z¹L½u¤W¤â¥U¨Ó¬d¡C

      are all in the manual page.  Here are a few of the most important

      ¤U­±¥u´£¤@¨Ç¥²­n¥B­«­nªº¿ï¶µ¡A¥H§@¬°¨Ò¤l¡C</para>

      ones, with examples of how to use them.</para>

	<term><option>-o <replaceable>filename</replaceable></option></term>

	<term><option>-o <replaceable>ÀɦW</replaceable></option></term>

	  <para>The output name of the file.  If you do not use this

	  <para><option>-o</option> ½sĶ«áªº°õ¦æÀÉÀɦW¡A¦pªG¨S¦³¨Ï¥Î³o¿ï¶µªº¸Ü¡A

	    option, <command>cc</command> will produce an executable called

       ½sĶ¦nªºµ{¦¡¹w³]ÀɦW±N·|¬O <filename>a.out</filename>

	    <filename>a.out</filename>.

	      <para>The reasons for this are buried in the mists of

	      <para>¦Ü©ó <option>-o</option> ªº­ì¦]¡A«h¬O¤@¹Î¾ú¥v°gÃú¤F¡C</para>

		history.</para>

	    <screen>&prompt.user; <userinput>cc foobar.c</userinput>               <lineannotation>executable is <filename>a.out</filename></lineannotation>

	    <screen>&prompt.user; <userinput>cc foobar.c</userinput>               <lineannotation>°õ¦æÀÉ´N¬O <filename>a.out</filename></lineannotation>

&prompt.user; <userinput>cc -o foobar foobar.c</userinput>     <lineannotation>executable is <filename>foobar</filename></lineannotation>

&prompt.user; <userinput>cc -o foobar foobar.c</userinput>     <lineannotation>°õ¦æÀÉ´N¬O <filename>foobar</filename></lineannotation>

	  <para>Just compile the file, do not link it.  Useful for toy

	  <para>¨Ï¥Î <option>-c</option> ®É¡A¥u·|½sĶ­ì©l½X¡A¦Ó¤£§@³sµ²(linking)¡C

	    programs where you just want to check the syntax, or if

	    ·í¥u·Q½T»{»yªk¬O§_¥¿½T©Î¨Ï¥Î Makefile ¨Ó½sĶµ{¦¡®É¡A³o­Ó¿ï¶µ«D±`¦³¥Î¡C</para>

	    you are using a <filename>Makefile</filename>.</para>

	    <screen>&prompt.user; <userinput>cc -c foobar.c</userinput>

	    <screen>

        &prompt.user; <userinput>cc -c foobar.c</userinput>

	  <para>This will produce an <firstterm>object file</firstterm> (not an

	  <para>³o·|²£¥Í¥s°µ <filename>foobar</filename> ªº <firstterm>object file</firstterm>(«D°õ¦æÀÉ)¡C

	    executable) called <filename>foobar.o</filename>.  This

	    ³oÀÉ¥i¥H»P¨ä¥Lªº object file ³sµ²¦b¤@°_¡A¦Ó¦¨°õ¦æÀÉ¡C</para>

	    can be linked together with other object files into an

	    executable.</para>

	  <para>Create a debug version of the executable.  This makes

	  <para>

	    the compiler put information into the executable about

	    <option>-g</option> ±N·|§â¤@¨Çµ¹ gdb ¥Îªº°£¿ù°T®§¥]¶i¥h°õ¦æÀɸ̭±¡A©Ò¿×ªº°£¿ù°T®§¨Ò¦p¡G

	    which line of which source file corresponds to which

	    µ{¦¡¦b²Ä´X¦æ¥X¿ù¡B¨º­Óµ{¦¡²Ä´X¦æ°µ¤°»ò¨ç¦¡©I¥sµ¥µ¥¡C°£¿ù¸ê°T<emphasis>«D±`</emphasis>¦n¥Î¡C

	    function call.  A debugger can use this information to show

	    ¦ý¯ÊÂI´N¬O¡G¹ï©óµ{¦¡¨Ó»¡¡AÃB¥~ªº°£¿ù°T®§·|Åý½sĶ¥X¨Óªºµ{¦¡¤ñ¸ûªÎ¨Ç¡C

	    the source code as you step through the program, which is

	    <option>-g</option> ªº¾A¥Î®É¾÷¦b©ó¡G·íµ{¦¡ÁÙ¦b¶}µo®É¨Ï¥Î´N¦n¡A

	    <emphasis>very</emphasis> useful; the disadvantage is that

	    ¦Ó·í§A­nÄÀ¥X§Aªº <quote>µo¦æª©¥»(release version)</quote>

	    all this extra information makes the program much bigger.

	    ©ÎªÌ½T»{µ{¦¡¥i¹B§@¥¿±`ªº¸Ü¡A´N¤£¥²¥Î <option>-g</option> ³o¿ï¶µ¤F¡C</para>

	    Normally, you compile with <option>-g</option> while you

	    are developing a program and then compile a <quote>release

	      version</quote> without <option>-g</option> when you are

	    satisfied it works properly.</para>

	  <para>This will produce a debug version of the

	  <para>³o°Ê§@·|²£¥Í¦³§t°£¿ù°T®§ªº°õ¦æÀÉ¡C

	    program.

	      <para>Note, we did not use the <option>-o</option> flag

	      <para>½Ðª`·N¡A¦]¬°¤W¨Ò¨S¥Î <option>-o</option> ¥H«ü©w°õ¦æÀɦWºÙ¡A

		to specify the executable name, so we will get an

	        ©Ò¥H°õ¦æÀÉ·|¬O <filename>a.out</filename> ³oÀÉ¡C

		executable called <filename>a.out</filename>.

	        ¨º»ò¡A­n¦p¦ó²£¥Í <filename>foobar</filename> ªº°õ¦æÀɨ产t°£¿ù°T®§¡A

		Producing a debug version called

	        ³o´N¯d«Ý¬Ý­¾­Ì½m²ß¤@¤UÅo¡C</para>

		<filename>foobar</filename> is left as an exercise for

		the reader!</para>

	  <para>Create an optimized version of the executable.  The

	  <para><option>-O</option> ·|²£¥Í³Ì¨Î¤Æªº°õ¦æÀÉ¡A

	    compiler performs various clever tricks to try to produce

	  ½sĶ¾¹·|¨Ï¥Î¤@¨Ç§Þ¥©¡A¨ÓÅýµ{¦¡¥i¥H¶]ªº¤ñ¥¼¸g³Ì¨Î¤Æªºµ{¦¡ÁÙ§Ö¡A

	    an executable that runs faster than normal.  You can add a

	  §A¥i¥H¦b¤j¼g O «á­±¥[¤W¼Æ¦r¨Ó«ü©ú§A·Q­nªº³Ì¨Î¤Æ¼h¯Å¡C

	    number after the <option>-O</option> to specify a higher

	  ¦ý¬O³Ì¨Î¤ÆÁÙ¬O·|¦³¤@¨Ç¿ù»~¡AÁ|¨Ò¨Ó»¡¦b·í¦b FreeBSD 2.10 release ¤¤¨Ï¥Î <command>cc</command> 

	    level of optimization, but this often exposes bugs in the

	  ¨Ã¥B«ü©w <option>-O2</option> ®É¡A¦b¬Y¨Ç±¡§Î¤U·|²£¥Í¿ù»~ªº°õ¦æÀÉ¡C</para>

	    compiler's optimizer.  For instance, the version of

	    <command>cc</command> that comes with the 2.1.0 release of

	    FreeBSD is known to produce bad code with the

	    <option>-O2</option> option in some circumstances.</para>

	  <para>Optimization is usually only turned on when compiling

	  <para>¥u¦³·í­nÄÀ¥Xµo¦æª©¥»¡B©ÎªÌ¥[³tµ{¦¡®É¡A¤~»Ý­n¨Ï¥Î³Ì¨Î¤Æ¿ï¶µ¡C

	    a release version.</para>

	    </para>

	  <para>This will produce an optimized version of

	  <para>³o·|²£¥Í <filename>foobar</filename> °õ¦æÀɪº³Ì¨Î¤Æª©¥»¡C</para>

	    <filename>foobar</filename>.</para>

    <para>The following three flags will force <command>cc</command>

    <para>

      to check that your code complies to the relevant international

      ¥H¤U¤T­Ó°Ñ¼Æ±N·|±j­¢ <command>cc</command> ½T»{µ{¦¡½X¬O§_²Å¦X¤@¨Ç°ê»Ú¼Ð·Çªº³W½d¡A

      standard, often referred to as the <acronym>ANSI</acronym>

      ¤]´N¬O³q±`»¡ªº <acronym>ANSI</acronym> ¼Ð·Ç¡A

      standard, though strictly speaking it is an

      ¦Ó <acronym>ANSI</acronym> ÄY®æ¨ÓÁ¿ÄÝ <acronym>ISO</acronym> ¼Ð·Ç¡C

      <acronym>ISO</acronym> standard.</para>

      </para>

	  <para>Enable all the warnings which the authors of

	  <para><option>-Wall</option> Åã¥Ü <command>cc</command>  ºûÅ@ªÌ©Ò»{¬°­È±oª`·Nªº©Ò¦³Äµ§i°T®§¡C

	    <command>cc</command> believe are worthwhile.  Despite the

	    ¤£¹L³o¦W¦r¥i¯à·|³y¦¨»~¸Ñ¡A¨Æ¹ê¤W¥¦¨Ã¥¼§¹¥þÅã¥Ü <command>cc</command> ©Ò¯àª`·N¨ìªº¦U¶µÄµ§i°T®§¡C</para>

	    name, it will not enable all the warnings

	    <command>cc</command> is capable of.</para>

	  <para>Turn off most, but not all, of the

	  <para><option>-ansi</option> Ãö³¬ <command>cc</command> ¯S¦³ªº¬Y¨Ç¯S®í«D ANSI C ¼Ð·Ç¥\¯à¡C

	    non-<acronym>ANSI</acronym>&nbsp;C features provided by

	    ¤£¹L³o¦W¦r¥i¯à·|³y¦¨»~¸Ñ¡A¨Æ¹ê¤W¥¦¨Ã¤£«OÃÒ§Aªºµ{¦¡·|§¹¥þ²Å¦X ANSI ¼Ð·Ç¡C</para>

	    <command>cc</command>.  Despite the name, it does not

	    guarantee strictly that your code will comply to the

	    standard.</para>

	  <para>Turn off <emphasis>all</emphasis>

	  <para>¥þ­±Ãö³¬ <command>cc</command> ©Ò¯S¦³ªº«D <acronym>ANSI</acronym>  C ¼Ð·Ç¥\¯à¡C</para>

	    <command>cc</command>'s non-<acronym>ANSI</acronym>&nbsp;C

	    features.</para>

    <para>Without these flags, <command>cc</command> will allow you to

    <para>°£¤F³o¨Ç°Ñ¼Æ¡A<command>cc</command> ÁÙ¤¹³\§A¨Ï¥Î¤@¨ÇÃB¥~ªº°Ñ¼Æ¨ú¥N¼Ð·Ç°Ñ¼Æ¡A¦³¨ÇÃB¥~°Ñ¼Æ«D±`¦³¥Î¡A

      use some of its non-standard extensions to the standard.  Some

      ¦ý¬O¹ê»Ú¤W¨Ã¤£¬O©Ò¦³ªº½sĶ¾¹³£¦³´£¨Ñ³o¨Ç°Ñ¼Æ¡C

      of these are very useful, but will not work with other

      ·Ó¼Ð·Ç¨Ó¼gµ{¦¡ªº³Ì¥D­n¥Øªº´N¬O¡A§Æ±æ§A¼g¥X¨Óªºµ{¦¡¥i¥H¦b©Ò¦³½sĶ¾¹¤W½sĶ¡B°õ¦æµL»~¡A

      compilers—in fact, one of the main aims of the standard is

      ·íµ{¦¡¥i¥H¹F¦¨¤W­z¥Øªº®É¡A´NºÙ¬° <firstterm>portable code(²¾´Ó©Ê¨}¦nªºµ{¦¡½X)</firstterm>¡C</para>

      to allow people to write code that will work with any compiler

      on any system.  This is known as <firstterm>portable

    <para>¤@¯ë¨Ó»¡¡A¦b¼¶¼gµ{¦¡®É´NÀ³­nª`·N¡y²¾´Ó©Ê¡z¡C

	code</firstterm>.</para>

      §_«h¡C·í·Q§âµ{¦¡®³¨ì¥t¥~¤@¥x¾÷¾¹¤W¶]ªº®É­Ô¡A´N¥i¯à±o»Ý­n­«¼gµ{¦¡¡C</para>

    <para>Generally, you should try to make your code as portable as

      possible, as otherwise you may have to completely rewrite the

      program later to get it to work somewhere else—and who

      knows what you may be using in a few years time?</para>

    <para>This will produce an executable <filename>foobar</filename>

    <para>¤W­z«ü¥O·|½T»{ <filename>foobar.c</filename> ¤ºªº»yªk¬O§_²Å¦X¼Ð·Ç¡A

      after checking <filename>foobar.c</filename> for standard

      ¨Ã¥B²£¥Í¦W¬° <filename>foobar</filename> ªº°õ¦æÀÉ¡C</para>

      compliance.</para>

	  <para>Specify a function library to be used at link time.</para>

	  <para>§i¶D gcc ¦b³sµ²(linking)µ{¦¡®É§A»Ý­n¥Î¨ìªº¨ç¦¡®w¦WºÙ¡C</para>

	  <para>The most common example of this is when compiling a

	  <para>³Ì±`¨£ªº±¡ªp´N¬O¡A·í§A¦bµ{¦¡¤¤¨Ï¥Î¤F C ¼Æ¾Ç¨ç¦¡®w¡A

	    program that uses some of the mathematical functions in C.

	    ¸ò¨ä¥L§@·~¥­¥x¤£¤@¼Ëªº¬O¡A³o¨Ç¼Æ¾Ç¨ç¦¡³£¤£¦b¼Ð·Ç¨ç¦¡®w(library)¤¤¡A

	    Unlike most other platforms, these are in a separate

	    ¦]¦¹½sĶ¾¹¨Ã¤£ª¾¹D³o¨ç¦¡®w¦WºÙ¡A§A¥²¶·§i¶D½sĶ¾¹­n¥[¤W¥¦¤~¦æ¡C</para>

	    library from the standard C one and you have to tell the

	    compiler to add it.</para>

	  <para>³o³W«h«Ü²³æ¡A¦pªG¦³­Ó¨ç¦¡®w¥s°µ <filename>lib<replaceable>something</replaceable>/a</filename>¡A

	    ´N¥²¶·¦b½sĶ®É¥[¤W°Ñ¼Æ <option>-l<replaceable>something</replaceable></option> ¤~¦æ¡C

	  <para>The rule is that if the library is called

	    Á|¨Ò¨Ó»¡¡A¼Æ¾Ç¨ç¦¡®w¥s°µ <filename>libm.a</filename>¡A

	    <filename>lib<replaceable>something</replaceable>.a</filename>,

	    ©Ò¥H§A¥²¶·µ¹ <command>cc</command> ªº°Ñ¼Æ´N¬O <option>-lm</option>¡C

	    you give <command>cc</command> the argument

	    ¤@¯ë±¡ªp¤U¡A³q±`·|§â³o°Ñ¼Æ¥²¶·©ñ¦b«ü¥Oªº³Ì«á¡C

	    <option>-l<replaceable>something</replaceable></option>.

	    </para>

	    For example, the math library is

	    <filename>libm.a</filename>, so you give

	    <command>cc</command> the argument <option>-lm</option>.

	    A common <quote>gotcha</quote> with the math library is

	    that it has to be the last library on the command

	    line.</para>

	  <para>This will link the math library functions into

	  <para>¤W­±³o«ü¥O·|Åý gcc ¸ò¼Æ¾Ç¨ç¦¡®w§@³sµ²¡A¥H«K§Aªºµ{¦¡¥i¥H©I¥s¨ç¦¡®w¤º§tªº¼Æ¾Ç¨ç¦¡¡C</para>

	    <filename>foobar</filename>.</para>

	  <para>If you are compiling C++ code, you need to add

	  <para>¦pªG§A¥¿¦b½sĶªºµ{¦¡¬O C++ µ{¦¡½X¡A§AÁÙ¥²¶·ÃB¥~«ü©w <option>-lg++</option> ©ÎªÌ¬O 

	    <option>-lg++</option>, or <option>-lstdc++</option> if

	    <option>-lstdc++</option>¡C

	    you are using FreeBSD 2.2 or later, to the command line

	    ¦pªG§Aªº FreeBSD ¬O 2.2(§t)¥H«áª©¥»¡A

	    argument to link the C++ library functions.

	    §A¥i¥H¥Î«ü¥O <command>c++</command> ¨Ó¨ú¥N <command>cc</command>¡C

	    Alternatively, you can run <command>c++</command> instead

	    ¦b FreeBSD ¤W <command>c++</command> ¤]¥i¥H¥Î <command>g++</command> ¨ú¥N¡C

	    of <command>cc</command>, which does this for you.

	    </para>

	    <command>c++</command> can also be invoked as

	    <command>g++</command> on FreeBSD.</para>