URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [rtos/] [ecos-2.0/] [doc/] [html/] [cdl-guide/] [language.values.html] - Diff between revs 28 and 174

Go to most recent revision | Only display areas with differences | Details | Blame | View Log

Rev 28	Rev 174
`<!-- Copyright (C) 2003 Red Hat, Inc. -->`	`<!-- Copyright (C) 2003 Red Hat, Inc. -->`
`<!-- This material may be distributed only subject to the terms -->`	`<!-- This material may be distributed only subject to the terms -->`
`<!-- and conditions set forth in the Open Publication License, v1.0 -->`	`<!-- and conditions set forth in the Open Publication License, v1.0 -->`
`<!-- or later (the latest version is presently available at -->`	`<!-- or later (the latest version is presently available at -->`
`<!-- http://www.opencontent.org/openpub/). -->`	`<!-- http://www.opencontent.org/openpub/). -->`
`<!-- Distribution of the work or derivative of the work in any -->`	`<!-- Distribution of the work or derivative of the work in any -->`
`<!-- standard (paper) book form is prohibited unless prior -->`	`<!-- standard (paper) book form is prohibited unless prior -->`
`<!-- permission is obtained from the copyright holder. -->`	`<!-- permission is obtained from the copyright holder. -->`
`<HTML`	`<HTML`
`><HEAD`	`><HEAD`
`><TITLE`	`><TITLE`
`>Values and Expressions</TITLE`	`>Values and Expressions</TITLE`
`><meta name="MSSmartTagsPreventParsing" content="TRUE">`	`><meta name="MSSmartTagsPreventParsing" content="TRUE">`
`<META`	`<META`
`NAME="GENERATOR"`	`NAME="GENERATOR"`
`CONTENT="Modular DocBook HTML Stylesheet Version 1.76b+`	`CONTENT="Modular DocBook HTML Stylesheet Version 1.76b+`
`"><LINK`	`"><LINK`
`REL="HOME"`	`REL="HOME"`
`TITLE="The eCos Component Writer's Guide"`	`TITLE="The eCos Component Writer's Guide"`
`HREF="cdl-guide.html"><LINK`	`HREF="cdl-guide.html"><LINK`
`REL="UP"`	`REL="UP"`
`TITLE="The CDL Language"`	`TITLE="The CDL Language"`
`HREF="language.html"><LINK`	`HREF="language.html"><LINK`
`REL="PREVIOUS"`	`REL="PREVIOUS"`
`TITLE="An Introduction to Tcl"`	`TITLE="An Introduction to Tcl"`
`HREF="language.tcl.html"><LINK`	`HREF="language.tcl.html"><LINK`
`REL="NEXT"`	`REL="NEXT"`
`TITLE="Interfaces"`	`TITLE="Interfaces"`
`HREF="language.interface.html"></HEAD`	`HREF="language.interface.html"></HEAD`
`><BODY`	`><BODY`
`CLASS="SECT1"`	`CLASS="SECT1"`
`BGCOLOR="#FFFFFF"`	`BGCOLOR="#FFFFFF"`
`TEXT="#000000"`	`TEXT="#000000"`
`LINK="#0000FF"`	`LINK="#0000FF"`
`VLINK="#840084"`	`VLINK="#840084"`
`ALINK="#0000FF"`	`ALINK="#0000FF"`
`><DIV`	`><DIV`
`CLASS="NAVHEADER"`	`CLASS="NAVHEADER"`
`><TABLE`	`><TABLE`
`SUMMARY="Header navigation table"`	`SUMMARY="Header navigation table"`
`WIDTH="100%"`	`WIDTH="100%"`
`BORDER="0"`	`BORDER="0"`
`CELLPADDING="0"`	`CELLPADDING="0"`
`CELLSPACING="0"`	`CELLSPACING="0"`
`><TR`	`><TR`
`><TH`	`><TH`
`COLSPAN="3"`	`COLSPAN="3"`
`ALIGN="center"`	`ALIGN="center"`
`>The <SPAN`	`>The <SPAN`
`CLASS="APPLICATION"`	`CLASS="APPLICATION"`
`>eCos</SPAN`	`>eCos</SPAN`
`> Component Writer's Guide</TH`	`> Component Writer's Guide</TH`
`></TR`	`></TR`
`><TR`	`><TR`
`><TD`	`><TD`
`WIDTH="10%"`	`WIDTH="10%"`
`ALIGN="left"`	`ALIGN="left"`
`VALIGN="bottom"`	`VALIGN="bottom"`
`><A`	`><A`
`HREF="language.tcl.html"`	`HREF="language.tcl.html"`
`ACCESSKEY="P"`	`ACCESSKEY="P"`
`>Prev</A`	`>Prev</A`
`></TD`	`></TD`
`><TD`	`><TD`
`WIDTH="80%"`	`WIDTH="80%"`
`ALIGN="center"`	`ALIGN="center"`
`VALIGN="bottom"`	`VALIGN="bottom"`
`>Chapter 3. The CDL Language</TD`	`>Chapter 3. The CDL Language</TD`
`><TD`	`><TD`
`WIDTH="10%"`	`WIDTH="10%"`
`ALIGN="right"`	`ALIGN="right"`
`VALIGN="bottom"`	`VALIGN="bottom"`
`><A`	`><A`
`HREF="language.interface.html"`	`HREF="language.interface.html"`
`ACCESSKEY="N"`	`ACCESSKEY="N"`
`>Next</A`	`>Next</A`
`></TD`	`></TD`
`></TR`	`></TR`
`></TABLE`	`></TABLE`
`><HR`	`><HR`
`ALIGN="LEFT"`	`ALIGN="LEFT"`
`WIDTH="100%"></DIV`	`WIDTH="100%"></DIV`
`><DIV`	`><DIV`
`CLASS="SECT1"`	`CLASS="SECT1"`
`><H1`	`><H1`
`CLASS="SECT1"`	`CLASS="SECT1"`
`><A`	`><A`
`NAME="LANGUAGE.VALUES">Values and Expressions</H1`	`NAME="LANGUAGE.VALUES">Values and Expressions</H1`
`><P`	`><P`
`>It is fairly reasonable to expect that enabling or disabling a`	`>It is fairly reasonable to expect that enabling or disabling a`
`configuration option such as`	`configuration option such as`
`<TT`	`<TT`
`CLASS="VARNAME"`	`CLASS="VARNAME"`
`>CYGVAR_KERNEL_THREADS_DATA</TT`	`>CYGVAR_KERNEL_THREADS_DATA</TT`
`> in some way affects its`	`> in some way affects its`
`<SPAN`	`<SPAN`
`CLASS="emphasis"`	`CLASS="emphasis"`
`><I`	`><I`
`CLASS="EMPHASIS"`	`CLASS="EMPHASIS"`
`>value</I`	`>value</I`
`></SPAN`	`></SPAN`
`>. This will have an effect on any`	`>. This will have an effect on any`
`expressions that reference this option such as`	`expressions that reference this option such as`
`<TT`	`<TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>requires CYGVAR_KERNEL_THREADS_DATA</TT`	`>requires CYGVAR_KERNEL_THREADS_DATA</TT`
`>. It will`	`>. It will`
`also affect the consequences of that option: how it affects the build`	`also affect the consequences of that option: how it affects the build`
`process and what happens to any constraints that`	`process and what happens to any constraints that`
`<TT`	`<TT`
`CLASS="VARNAME"`	`CLASS="VARNAME"`
`>CYGVAR_KERNEL_THREADS_DATA</TT`	`>CYGVAR_KERNEL_THREADS_DATA</TT`
`> may impose (as opposed`	`> may impose (as opposed`
`to constraints on this option imposed by others).</P`	`to constraints on this option imposed by others).</P`
`><P`	`><P`
`>In a language like C the handling of variables is relatively`	`>In a language like C the handling of variables is relatively`
`straightforward. If a variable <TT`	`straightforward. If a variable <TT`
`CLASS="VARNAME"`	`CLASS="VARNAME"`
`>x</TT`	`>x</TT`
`> gets referenced in`	`> gets referenced in`
`an expression such as <TT`	`an expression such as <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>if (x != 0)</TT`	`>if (x != 0)</TT`
`>,`	`>,`
`and that variable is not defined anywhere, then the code will fail to`	`and that variable is not defined anywhere, then the code will fail to`
`build, typically with an unresolved error at link-time. Also in C`	`build, typically with an unresolved error at link-time. Also in C`
`a variable <TT`	`a variable <TT`
`CLASS="VARNAME"`	`CLASS="VARNAME"`
`>x</TT`	`>x</TT`
`> does not live in any hierarchy, so its`	`> does not live in any hierarchy, so its`
`value for the purposes of expression evaluation is not affected by`	`value for the purposes of expression evaluation is not affected by`
`anything else. C variables also have a clear type such as`	`anything else. C variables also have a clear type such as`
`<TT`	`<TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>int</TT`	`>int</TT`
`> or <TT`	`> or <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>long double</TT`	`>long double</TT`
`>. </P`	`>. </P`
`><P`	`><P`
`>In <SPAN`	`>In <SPAN`
`CLASS="APPLICATION"`	`CLASS="APPLICATION"`
`>CDL</SPAN`	`>CDL</SPAN`
`> things are not so straightforward.</P`	`> things are not so straightforward.</P`
`><DIV`	`><DIV`
`CLASS="SECT2"`	`CLASS="SECT2"`
`><H2`	`><H2`
`CLASS="SECT2"`	`CLASS="SECT2"`
`><A`	`><A`
`NAME="LANGUAGE.VALUES.VALUE">Option Values</H2`	`NAME="LANGUAGE.VALUES.VALUE">Option Values</H2`
`><P`	`><P`
`>There are four factors which go into an option's value:</P`	`>There are four factors which go into an option's value:</P`
`><P`	`><P`
`></P`	`></P`
`><OL`	`><OL`
`TYPE="1"`	`TYPE="1"`
`><LI`	`><LI`
`><P`	`><P`
`>An option may or may not be loaded.</P`	`>An option may or may not be loaded.</P`
`></LI`	`></LI`
`><LI`	`><LI`
`><P`	`><P`
`>If the option is loaded, it may or may not be active.</P`	`>If the option is loaded, it may or may not be active.</P`
`></LI`	`></LI`
`><LI`	`><LI`
`><P`	`><P`
`>Even if the option is active, it may or may not be enabled.</P`	`>Even if the option is active, it may or may not be enabled.</P`
`></LI`	`></LI`
`><LI`	`><LI`
`><P`	`><P`
`>If the option is loaded, active and enabled then it will have some`	`>If the option is loaded, active and enabled then it will have some`
`associated data which constitutes its value.</P`	`associated data which constitutes its value.</P`
`></LI`	`></LI`
`></OL`	`></OL`
`><DIV`	`><DIV`
`CLASS="SECT3"`	`CLASS="SECT3"`
`><H3`	`><H3`
`CLASS="SECT3"`	`CLASS="SECT3"`
`><A`	`><A`
`NAME="LANGUAGE.VALUES.VALUE.LOADED">Is the Option Loaded?</H3`	`NAME="LANGUAGE.VALUES.VALUE.LOADED">Is the Option Loaded?</H3`
`><P`	`><P`
`>At any one time a configuration will contain only a subset of all`	`>At any one time a configuration will contain only a subset of all`
`possible packages. In fact it is impossible to combine certain`	`possible packages. In fact it is impossible to combine certain`
`packages in a single configuration. For example architectural HAL`	`packages in a single configuration. For example architectural HAL`
`packages should contain a set of options defining endianness, the`	`packages should contain a set of options defining endianness, the`
`sizes of basic data types and so on (many of which will of course be`	`sizes of basic data types and so on (many of which will of course be`
`constant for any given architecture). Any attempt to load two`	`constant for any given architecture). Any attempt to load two`
`architectural HAL packages into a configuration will fail because of`	`architectural HAL packages into a configuration will fail because of`
`the resulting name clash. Since <SPAN`	`the resulting name clash. Since <SPAN`
`CLASS="APPLICATION"`	`CLASS="APPLICATION"`
`>CDL</SPAN`	`>CDL</SPAN`
`> expressions can reference`	`> expressions can reference`
`options in other packages, and often need to do so, it is essential to`	`options in other packages, and often need to do so, it is essential to`
`define the resulting behavior.</P`	`define the resulting behavior.</P`
`><P`	`><P`
`>One complication is that the component framework does not know about`	`>One complication is that the component framework does not know about`
`every single option in every single package. Obviously it cannot know`	`every single option in every single package. Obviously it cannot know`
`about packages from arbitrary third parties which have not been`	`about packages from arbitrary third parties which have not been`
`installed. Even for packages which have been installed, the current`	`installed. Even for packages which have been installed, the current`
`repository database does not hold details of every option, only of the`	`repository database does not hold details of every option, only of the`
`packages themselves. If a <SPAN`	`packages themselves. If a <SPAN`
`CLASS="APPLICATION"`	`CLASS="APPLICATION"`
`>CDL</SPAN`	`>CDL</SPAN`
`> expression contains a reference to`	`> expression contains a reference to`
`some option <TT`	`some option <TT`
`CLASS="VARNAME"`	`CLASS="VARNAME"`
`>CYGSEM_KERNEL_SCHED_TIMESLICE</TT`	`>CYGSEM_KERNEL_SCHED_TIMESLICE</TT`
`> then the`	`> then the`
`component framework will only know about this option if the kernel`	`component framework will only know about this option if the kernel`
`package is actually loaded into the current configuration. If the`	`package is actually loaded into the current configuration. If the`
`package is not loaded then theoretically the framework might guess`	`package is not loaded then theoretically the framework might guess`
`that the option is somehow related to the kernel by examining the`	`that the option is somehow related to the kernel by examining the`
`option name but this would not be robust: the option could easily be`	`option name but this would not be robust: the option could easily be`
`part of some other package that violates the naming convention.</P`	`part of some other package that violates the naming convention.</P`
`><P`	`><P`
`>Assume that the user is building a minimal configuration which does`	`>Assume that the user is building a minimal configuration which does`
`not contain the kernel package, but does have other packages which`	`not contain the kernel package, but does have other packages which`
`contain the following constraints:</P`	`contain the following constraints:</P`
`><TABLE`	`><TABLE`
`BORDER="5"`	`BORDER="5"`
`BGCOLOR="#E0E0F0"`	`BGCOLOR="#E0E0F0"`
`WIDTH="70%"`	`WIDTH="70%"`
`><TR`	`><TR`
`><TD`	`><TD`
`><PRE`	`><PRE`
`CLASS="PROGRAMLISTING"`	`CLASS="PROGRAMLISTING"`
`> requires CYGPKG_KERNEL`	`> requires CYGPKG_KERNEL`
`requires CYGPKG_KERNEL_THREADS_DATA`	`requires CYGPKG_KERNEL_THREADS_DATA`
`requires !CYGSEM_KERNEL_SCHED_TIMESLICE</PRE`	`requires !CYGSEM_KERNEL_SCHED_TIMESLICE</PRE`
`></TD`	`></TD`
`></TR`	`></TR`
`></TABLE`	`></TABLE`
`><P`	`><P`
`>Clearly the first constraint is not satisfied because the kernel is`	`>Clearly the first constraint is not satisfied because the kernel is`
`not loaded. The second constraint is also not satisfied. The third`	`not loaded. The second constraint is also not satisfied. The third`
`constraint is trivially satisfied: if there is no kernel then the`	`constraint is trivially satisfied: if there is no kernel then the`
`kernel's timeslicing support cannot possibly be enabled. </P`	`kernel's timeslicing support cannot possibly be enabled. </P`
`><P`	`><P`
`>Any options which are not in the current configuration are handled as`	`>Any options which are not in the current configuration are handled as`
`follows: </P`	`follows: </P`
`><P`	`><P`
`></P`	`></P`
`><OL`	`><OL`
`TYPE="1"`	`TYPE="1"`
`><LI`	`><LI`
`><P`	`><P`
`>Any references to that option will evaluate to <TT`	`>Any references to that option will evaluate to <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>0</TT`	`>0</TT`
`>,`	`>,`
`so <TT`	`so <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>requires !CYGSEM_KERNEL_SCHED_TIMESLICE</TT`	`>requires !CYGSEM_KERNEL_SCHED_TIMESLICE</TT`
`> will`	`> will`
`be satisfied but`	`be satisfied but`
`<TT`	`<TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>requires CYGSEM_KERNEL_THREADS_DATA</TT`	`>requires CYGSEM_KERNEL_THREADS_DATA</TT`
`> will not`	`> will not`
`be satisfied.</P`	`be satisfied.</P`
`></LI`	`></LI`
`><LI`	`><LI`
`><P`	`><P`
`>An option that is not loaded has no consequences on the build process.`	`>An option that is not loaded has no consequences on the build process.`
`It cannot directly result in any <TT`	`It cannot directly result in any <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>#define's</TT`	`>#define's</TT`
`> in a`	`> in a`
`configuration header file, nor in any files being compiled. This is`	`configuration header file, nor in any files being compiled. This is`
`only reasonable: if the option is not loaded then the component`	`only reasonable: if the option is not loaded then the component`
`framework has no way of knowing about any <SPAN`	`framework has no way of knowing about any <SPAN`
`CLASS="PROPERTY"`	`CLASS="PROPERTY"`
`>compile</SPAN`	`>compile</SPAN`
`> or similar`	`> or similar`
`properties. An option that is not loaded can have indirect`	`properties. An option that is not loaded can have indirect`
`consequences by being referenced in <SPAN`	`consequences by being referenced in <SPAN`
`CLASS="APPLICATION"`	`CLASS="APPLICATION"`
`>CDL</SPAN`	`>CDL</SPAN`
`> expressions.</P`	`> expressions.</P`
`></LI`	`></LI`
`><LI`	`><LI`
`><P`	`><P`
`>An option that is not loaded cannot impose any constraints on the rest`	`>An option that is not loaded cannot impose any constraints on the rest`
`of the configuration. Again this is the only reasonable behavior: if`	`of the configuration. Again this is the only reasonable behavior: if`
`the option is not loaded then any associated <SPAN`	`the option is not loaded then any associated <SPAN`
`CLASS="PROPERTY"`	`CLASS="PROPERTY"`
`>requires</SPAN`	`>requires</SPAN`
`> or`	`> or`
`<SPAN`	`<SPAN`
`CLASS="PROPERTY"`	`CLASS="PROPERTY"`
`>legal_values</SPAN`	`>legal_values</SPAN`
`> properties will not be known.</P`	`> properties will not be known.</P`
`></LI`	`></LI`
`></OL`	`></OL`
`></DIV`	`></DIV`
`><DIV`	`><DIV`
`CLASS="SECT3"`	`CLASS="SECT3"`
`><H3`	`><H3`
`CLASS="SECT3"`	`CLASS="SECT3"`
`><A`	`><A`
`NAME="LANGUAGE.VALUES.VALUE.ACTIVE">Is the Option Active</H3`	`NAME="LANGUAGE.VALUES.VALUE.ACTIVE">Is the Option Active</H3`
`><P`	`><P`
`>The next issue to consider is whether or not a particular option is`	`>The next issue to consider is whether or not a particular option is`
`active. Configuration options are organized in a hierarchy of`	`active. Configuration options are organized in a hierarchy of`
`components and sub-components. For example the C library package`	`components and sub-components. For example the C library package`
`contains a component <TT`	`contains a component <TT`
`CLASS="VARNAME"`	`CLASS="VARNAME"`
`>CYGPKG_LIBC_STDIO</TT`	`>CYGPKG_LIBC_STDIO</TT`
`> containing`	`> containing`
`all the options related to standard I/O. If a user disables the`	`all the options related to standard I/O. If a user disables the`
`component as a whole then all the options below it become inactive: it`	`component as a whole then all the options below it become inactive: it`
`makes no sense to disable all stdio functionality and then manipulate`	`makes no sense to disable all stdio functionality and then manipulate`
`the buffer sizes.</P`	`the buffer sizes.</P`
`><P`	`><P`
`>Inactive is not quite the same as disabled, although the effects are`	`>Inactive is not quite the same as disabled, although the effects are`
`similar. The value of an inactive option is preserved. If the user`	`similar. The value of an inactive option is preserved. If the user`
`modifies a buffer size option, then disables the whole stdio`	`modifies a buffer size option, then disables the whole stdio`
`component, the buffer size value remains in case the stdio component`	`component, the buffer size value remains in case the stdio component`
`is re-enabled later on. Some tools such as the graphical configuration`	`is re-enabled later on. Some tools such as the graphical configuration`
`tool will treat inactive options specially, for example such options`	`tool will treat inactive options specially, for example such options`
`may be grayed out.</P`	`may be grayed out.</P`
`><P`	`><P`
`>The active or inactive state of an option may affect other packages.`	`>The active or inactive state of an option may affect other packages.`
`For example a package may use the <TT`	`For example a package may use the <TT`
`CLASS="FUNCTION"`	`CLASS="FUNCTION"`
`>sprintf</TT`	`>sprintf</TT`
`>`	`>`
`function and require support for floating point conversions, a`	`function and require support for floating point conversions, a`
`constraint that is not satisfied if the relevant option is inactive.`	`constraint that is not satisfied if the relevant option is inactive.`
`It is necessary to define exactly what it means for an option to be`	`It is necessary to define exactly what it means for an option to be`
`inactive:</P`	`inactive:</P`
`><P`	`><P`
`></P`	`></P`
`><OL`	`><OL`
`TYPE="1"`	`TYPE="1"`
`><LI`	`><LI`
`><P`	`><P`
`>An option is inactive if its parent is either inactive or disabled.`	`>An option is inactive if its parent is either inactive or disabled.`
`For example if <TT`	`For example if <TT`
`CLASS="VARNAME"`	`CLASS="VARNAME"`
`>CYGPKG_LIBC_STDIO</TT`	`>CYGPKG_LIBC_STDIO</TT`
`> is disabled then`	`> is disabled then`
`all the options and sub-components become inactive; since`	`all the options and sub-components become inactive; since`
`<TT`	`<TT`
`CLASS="VARNAME"`	`CLASS="VARNAME"`
`>CYGPKG_LIBC_STDIO_FLOATING_POINT</TT`	`>CYGPKG_LIBC_STDIO_FLOATING_POINT</TT`
`> is now inactive,`	`> is now inactive,`
`<TT`	`<TT`
`CLASS="VARNAME"`	`CLASS="VARNAME"`
`>CYGSEM_LIBC_STDIO_PRINTF_FLOATING_POINT</TT`	`>CYGSEM_LIBC_STDIO_PRINTF_FLOATING_POINT</TT`
`> is inactive`	`> is inactive`
`as well.</P`	`as well.</P`
`></LI`	`></LI`
`><LI`	`><LI`
`><P`	`><P`
`>Options may also be inactive as a result of an <SPAN`	`>Options may also be inactive as a result of an <SPAN`
`CLASS="PROPERTY"`	`CLASS="PROPERTY"`
`>active_if</SPAN`	`>active_if</SPAN`
`> property.`	`> property.`
`This is useful if a particular option is only relevant if two or more`	`This is useful if a particular option is only relevant if two or more`
`disjoint sets of conditions need to be satisfied, since the`	`disjoint sets of conditions need to be satisfied, since the`
`hierarchical structure can only cope with at most one such set.</P`	`hierarchical structure can only cope with at most one such set.</P`
`></LI`	`></LI`
`><LI`	`><LI`
`><P`	`><P`
`>If an option is inactive then any references to that option in <SPAN`	`>If an option is inactive then any references to that option in <SPAN`
`CLASS="APPLICATION"`	`CLASS="APPLICATION"`
`>CDL</SPAN`	`>CDL</SPAN`
`>`	`>`
`expressions will evaluate to <TT`	`expressions will evaluate to <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>0</TT`	`>0</TT`
`>. Hence a constraint`	`>. Hence a constraint`
`of the form`	`of the form`
`<TT`	`<TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>requires CYGSEM_LIBC_STDIO_PRINTF_FLOATING_POINT</TT`	`>requires CYGSEM_LIBC_STDIO_PRINTF_FLOATING_POINT</TT`
`>`	`>`
`is not satisfied if the entire stdio component is disabled.</P`	`is not satisfied if the entire stdio component is disabled.</P`
`></LI`	`></LI`
`><LI`	`><LI`
`><P`	`><P`
`>An option that is inactive has no consequences on the build process.`	`>An option that is inactive has no consequences on the build process.`
`No <TT`	`No <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>#define</TT`	`>#define</TT`
`> will be generated. Any <SPAN`	`> will be generated. Any <SPAN`
`CLASS="PROPERTY"`	`CLASS="PROPERTY"`
`>compile</SPAN`	`>compile</SPAN`
`> or`	`> or`
`similar properties will be ignored.</P`	`similar properties will be ignored.</P`
`></LI`	`></LI`
`><LI`	`><LI`
`><P`	`><P`
`>An option that is inactive cannot impose any constraints on the rest`	`>An option that is inactive cannot impose any constraints on the rest`
`of the configuration. For example`	`of the configuration. For example`
`<TT`	`<TT`
`CLASS="VARNAME"`	`CLASS="VARNAME"`
`>CYGSEM_LIBC_STDIO_PRINTF_FLOATING_POINT</TT`	`>CYGSEM_LIBC_STDIO_PRINTF_FLOATING_POINT</TT`
`> has a`	`> has a`
`dependency <TT`	`dependency <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>requires CYGPKG_LIBM</TT`	`>requires CYGPKG_LIBM</TT`
`>, but if all of`	`>, but if all of`
`the stdio functionality is disabled then this constraint is ignored`	`the stdio functionality is disabled then this constraint is ignored`
`(although of course there may be other packages which have a`	`(although of course there may be other packages which have a`
`dependency on <TT`	`dependency on <TT`
`CLASS="VARNAME"`	`CLASS="VARNAME"`
`>CYGPKG_LIBM</TT`	`>CYGPKG_LIBM</TT`
`>.</P`	`>.</P`
`></LI`	`></LI`
`></OL`	`></OL`
`></DIV`	`></DIV`
`><DIV`	`><DIV`
`CLASS="SECT3"`	`CLASS="SECT3"`
`><H3`	`><H3`
`CLASS="SECT3"`	`CLASS="SECT3"`
`><A`	`><A`
`NAME="LANGUAGE.VALUES.VALUE.ENABLED">Is the Option Enabled? What is the Data?</H3`	`NAME="LANGUAGE.VALUES.VALUE.ENABLED">Is the Option Enabled? What is the Data?</H3`
`><P`	`><P`
`>The majority of configuration options are boolean in nature, so the`	`>The majority of configuration options are boolean in nature, so the`
`user can either enable or disable some functionality. Some options are`	`user can either enable or disable some functionality. Some options are`
`different. For example <TT`	`different. For example <TT`
`CLASS="VARNAME"`	`CLASS="VARNAME"`
`>CYGNUM_LIBC_STDIO_BUFSIZE</TT`	`>CYGNUM_LIBC_STDIO_BUFSIZE</TT`
`> is`	`> is`
`a number, and <TT`	`a number, and <TT`
`CLASS="VARNAME"`	`CLASS="VARNAME"`
`>CYGDAT_LIBC_STDIO_DEFAULT_CONSOLE</TT`	`>CYGDAT_LIBC_STDIO_DEFAULT_CONSOLE</TT`
`> is`	`> is`
`a string corresponding to a device name. A few options like`	`a string corresponding to a device name. A few options like`
`<TT`	`<TT`
`CLASS="VARNAME"`	`CLASS="VARNAME"`
`>CYGDAT_UITRON_TASK_EXTERNS</TT`	`>CYGDAT_UITRON_TASK_EXTERNS</TT`
`> can get very`	`> can get very`
`complicated. <SPAN`	`complicated. <SPAN`
`CLASS="APPLICATION"`	`CLASS="APPLICATION"`
`>CDL</SPAN`	`>CDL</SPAN`
`> has to cope with this variety, and define the exact`	`> has to cope with this variety, and define the exact`
`behavior of the system in terms of constraints and build-time`	`behavior of the system in terms of constraints and build-time`
`consequences. </P`	`consequences. </P`
`><P`	`><P`
`>In <SPAN`	`>In <SPAN`
`CLASS="APPLICATION"`	`CLASS="APPLICATION"`
`>CDL</SPAN`	`>CDL</SPAN`
`> the value of an option consists of two parts. There is a`	`> the value of an option consists of two parts. There is a`
`boolean part, controlling whether or not the option is enabled. There`	`boolean part, controlling whether or not the option is enabled. There`
`is also a data part, providing additional information. For most`	`is also a data part, providing additional information. For most`
`options one of these parts is fixed, as controlled by the option's`	`options one of these parts is fixed, as controlled by the option's`
`<SPAN`	`<SPAN`
`CLASS="PROPERTY"`	`CLASS="PROPERTY"`
`>flavor</SPAN`	`>flavor</SPAN`
`> property:</P`	`> property:</P`
`><DIV`	`><DIV`
`CLASS="INFORMALTABLE"`	`CLASS="INFORMALTABLE"`
`><A`	`><A`
`NAME="AEN1413"><P`	`NAME="AEN1413"><P`
`></P`	`></P`
`><TABLE`	`><TABLE`
`BORDER="1"`	`BORDER="1"`
`CLASS="CALSTABLE"`	`CLASS="CALSTABLE"`
`><THEAD`	`><THEAD`
`><TR`	`><TR`
`><TH`	`><TH`
`ALIGN="LEFT"`	`ALIGN="LEFT"`
`VALIGN="TOP"`	`VALIGN="TOP"`
`>Flavor</TH`	`>Flavor</TH`
`><TH`	`><TH`
`ALIGN="LEFT"`	`ALIGN="LEFT"`
`VALIGN="TOP"`	`VALIGN="TOP"`
`>Enabled</TH`	`>Enabled</TH`
`><TH`	`><TH`
`ALIGN="LEFT"`	`ALIGN="LEFT"`
`VALIGN="TOP"`	`VALIGN="TOP"`
`>Data</TH`	`>Data</TH`
`></TR`	`></TR`
`></THEAD`	`></THEAD`
`><TBODY`	`><TBODY`
`><TR`	`><TR`
`><TD`	`><TD`
`ALIGN="LEFT"`	`ALIGN="LEFT"`
`VALIGN="TOP"`	`VALIGN="TOP"`
`><TT`	`><TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>none</TT`	`>none</TT`
`></TD`	`></TD`
`><TD`	`><TD`
`ALIGN="LEFT"`	`ALIGN="LEFT"`
`VALIGN="TOP"`	`VALIGN="TOP"`
`>Always enabled</TD`	`>Always enabled</TD`
`><TD`	`><TD`
`ALIGN="LEFT"`	`ALIGN="LEFT"`
`VALIGN="TOP"`	`VALIGN="TOP"`
`><TT`	`><TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>1</TT`	`>1</TT`
`>, not modifiable</TD`	`>, not modifiable</TD`
`></TR`	`></TR`
`><TR`	`><TR`
`><TD`	`><TD`
`ALIGN="LEFT"`	`ALIGN="LEFT"`
`VALIGN="TOP"`	`VALIGN="TOP"`
`><TT`	`><TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>bool</TT`	`>bool</TT`
`></TD`	`></TD`
`><TD`	`><TD`
`ALIGN="LEFT"`	`ALIGN="LEFT"`
`VALIGN="TOP"`	`VALIGN="TOP"`
`>User-modifiable</TD`	`>User-modifiable</TD`
`><TD`	`><TD`
`ALIGN="LEFT"`	`ALIGN="LEFT"`
`VALIGN="TOP"`	`VALIGN="TOP"`
`><TT`	`><TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>1</TT`	`>1</TT`
`>, not modifiable</TD`	`>, not modifiable</TD`
`></TR`	`></TR`
`><TR`	`><TR`
`><TD`	`><TD`
`ALIGN="LEFT"`	`ALIGN="LEFT"`
`VALIGN="TOP"`	`VALIGN="TOP"`
`><TT`	`><TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>data</TT`	`>data</TT`
`></TD`	`></TD`
`><TD`	`><TD`
`ALIGN="LEFT"`	`ALIGN="LEFT"`
`VALIGN="TOP"`	`VALIGN="TOP"`
`>Always enabled</TD`	`>Always enabled</TD`
`><TD`	`><TD`
`ALIGN="LEFT"`	`ALIGN="LEFT"`
`VALIGN="TOP"`	`VALIGN="TOP"`
`>User-modifiable</TD`	`>User-modifiable</TD`
`></TR`	`></TR`
`><TR`	`><TR`
`><TD`	`><TD`
`ALIGN="LEFT"`	`ALIGN="LEFT"`
`VALIGN="TOP"`	`VALIGN="TOP"`
`><TT`	`><TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>booldata</TT`	`>booldata</TT`
`></TD`	`></TD`
`><TD`	`><TD`
`ALIGN="LEFT"`	`ALIGN="LEFT"`
`VALIGN="TOP"`	`VALIGN="TOP"`
`>User-modifiable</TD`	`>User-modifiable</TD`
`><TD`	`><TD`
`ALIGN="LEFT"`	`ALIGN="LEFT"`
`VALIGN="TOP"`	`VALIGN="TOP"`
`>User-modifiable</TD`	`>User-modifiable</TD`
`></TR`	`></TR`
`></TBODY`	`></TBODY`
`></TABLE`	`></TABLE`
`><P`	`><P`
`></P`	`></P`
`></DIV`	`></DIV`
`><P`	`><P`
`>The effects of the boolean and data parts are as follows:</P`	`>The effects of the boolean and data parts are as follows:</P`
`><P`	`><P`
`></P`	`></P`
`><OL`	`><OL`
`TYPE="1"`	`TYPE="1"`
`><LI`	`><LI`
`><P`	`><P`
`>If an option is disabled, in other words if the boolean part is false,`	`>If an option is disabled, in other words if the boolean part is false,`
`then any references to that option in <SPAN`	`then any references to that option in <SPAN`
`CLASS="APPLICATION"`	`CLASS="APPLICATION"`
`>CDL</SPAN`	`>CDL</SPAN`
`> expressions will evaluate`	`> expressions will evaluate`
`to <TT`	`to <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>0</TT`	`>0</TT`
`>. This is the same behavior as for inactive`	`>. This is the same behavior as for inactive`
`options. The data part is not relevant. The <TT`	`options. The data part is not relevant. The <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>none</TT`	`>none</TT`
`>`	`>`
`and <TT`	`and <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>data</TT`	`>data</TT`
`> flavors specify that the option is always`	`> flavors specify that the option is always`
`enabled, in which case this rule is not applicable.</P`	`enabled, in which case this rule is not applicable.</P`
`></LI`	`></LI`
`><LI`	`><LI`
`><P`	`><P`
`>If an option is enabled then any references to that option in <SPAN`	`>If an option is enabled then any references to that option in <SPAN`
`CLASS="APPLICATION"`	`CLASS="APPLICATION"`
`>CDL</SPAN`	`>CDL</SPAN`
`>`	`>`
`expressions will evaluate to the option's data part. For two of the`	`expressions will evaluate to the option's data part. For two of the`
`flavors, <TT`	`flavors, <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>none</TT`	`>none</TT`
`> and <TT`	`> and <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>bool</TT`	`>bool</TT`
`>, this`	`>, this`
`data part is fixed to the constant <TT`	`data part is fixed to the constant <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>1</TT`	`>1</TT`
`> which`	`> which`
`generally has the expected result.</P`	`generally has the expected result.</P`
`></LI`	`></LI`
`><LI`	`><LI`
`><P`	`><P`
`>If a component or package is disabled then all sub-components and`	`>If a component or package is disabled then all sub-components and`
`options immediately below it in the hierarchy are inactive. By a`	`options immediately below it in the hierarchy are inactive. By a`
`process of recursion this will affect all the nodes in the subtree.</P`	`process of recursion this will affect all the nodes in the subtree.</P`
`></LI`	`></LI`
`><LI`	`><LI`
`><P`	`><P`
`>If an option is disabled then it can impose no constraints on the rest`	`>If an option is disabled then it can impose no constraints on the rest`
`of the configuration, in particular <SPAN`	`of the configuration, in particular <SPAN`
`CLASS="PROPERTY"`	`CLASS="PROPERTY"`
`>requires</SPAN`	`>requires</SPAN`
`> and <SPAN`	`> and <SPAN`
`CLASS="PROPERTY"`	`CLASS="PROPERTY"`
`>legal_values</SPAN`	`>legal_values</SPAN`
`>`	`>`
`properties will be ignored. If an option is enabled then its`	`properties will be ignored. If an option is enabled then its`
`constraints should be satisfied, or the component framework will`	`constraints should be satisfied, or the component framework will`
`report various conflicts. Note that the <SPAN`	`report various conflicts. Note that the <SPAN`
`CLASS="PROPERTY"`	`CLASS="PROPERTY"`
`>legal_values</SPAN`	`>legal_values</SPAN`
`> constraint only`	`> constraint only`
`applies to the data part of the option's value, so it is only useful`	`applies to the data part of the option's value, so it is only useful`
`with the <TT`	`with the <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>data</TT`	`>data</TT`
`> and <TT`	`> and <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>booldata</TT`	`>booldata</TT`
`>`	`>`
`flavors. Options with the <TT`	`flavors. Options with the <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>none</TT`	`>none</TT`
`> and`	`> and`
`<TT`	`<TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>data</TT`	`>data</TT`
`> flavors are always enabled so their`	`> flavors are always enabled so their`
`constraints always have to be satisfied (assuming the option is`	`constraints always have to be satisfied (assuming the option is`
`active). </P`	`active). </P`
`></LI`	`></LI`
`><LI`	`><LI`
`><P`	`><P`
`>If an option is disabled then it has no direct consequences at`	`>If an option is disabled then it has no direct consequences at`
`build-time: no <TT`	`build-time: no <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>#define</TT`	`>#define</TT`
`> will be generated, no files`	`> will be generated, no files`
`will get compiled, and so on. If an option is active and enabled then`	`will get compiled, and so on. If an option is active and enabled then`
`all the consequences take effect. The option name and data part are`	`all the consequences take effect. The option name and data part are`
`used to generate the <TT`	`used to generate the <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>#define</TT`	`>#define</TT`
`> in the appropriate`	`> in the appropriate`
`configuration header file, subject to various properties such as`	`configuration header file, subject to various properties such as`
`<SPAN`	`<SPAN`
`CLASS="PROPERTY"`	`CLASS="PROPERTY"`
`>no_define</SPAN`	`>no_define</SPAN`
`>, but the data part has no other effects on the build`	`>, but the data part has no other effects on the build`
`system. </P`	`system. </P`
`></LI`	`></LI`
`></OL`	`></OL`
`><P`	`><P`
`>By default all options and components have the <TT`	`>By default all options and components have the <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>bool</TT`	`>bool</TT`
`>`	`>`
`flavor: most options are boolean in nature, so making this the default`	`flavor: most options are boolean in nature, so making this the default`
`allows for slightly more compact <SPAN`	`allows for slightly more compact <SPAN`
`CLASS="APPLICATION"`	`CLASS="APPLICATION"`
`>CDL</SPAN`	`>CDL</SPAN`
`> scripts. Packages have the`	`> scripts. Packages have the`
`<TT`	`<TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>booldata</TT`	`>booldata</TT`
`> flavor, where the data part always`	`> flavor, where the data part always`
`corresponds to the version of the package that is loaded into the`	`corresponds to the version of the package that is loaded into the`
`configuration: changing this value corresponds to unloading the old`	`configuration: changing this value corresponds to unloading the old`
`version and loading in a different one.</P`	`version and loading in a different one.</P`
`><DIV`	`><DIV`
`CLASS="NOTE"`	`CLASS="NOTE"`
`><BLOCKQUOTE`	`><BLOCKQUOTE`
`CLASS="NOTE"`	`CLASS="NOTE"`
`><P`	`><P`
`><B`	`><B`
`><SPAN`	`><SPAN`
`CLASS="APPLICATION"`	`CLASS="APPLICATION"`
`>CDL</SPAN`	`>CDL</SPAN`
`> Flavors: </B`	`> Flavors: </B`
`>The concept of <SPAN`	`>The concept of <SPAN`
`CLASS="APPLICATION"`	`CLASS="APPLICATION"`
`>CDL</SPAN`	`>CDL</SPAN`
`> flavors tends to result in various discussions`	`> flavors tends to result in various discussions`
`about why it is unnecessarily complicated, and would it not have been`	`about why it is unnecessarily complicated, and would it not have been`
`easier to do … However there are very good reasons why CDL`	`easier to do … However there are very good reasons why CDL`
`works the way it does.</P`	`works the way it does.</P`
`><P`	`><P`
`>The first common suggestion is that there is no need to have separate`	`>The first common suggestion is that there is no need to have separate`
`flavors <TT`	`flavors <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>bool</TT`	`>bool</TT`
`>, <TT`	`>, <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>data</TT`	`>data</TT`
`>, and so on. A`	`>, and so on. A`
`boolean option could just be handled as a data option with legal`	`boolean option could just be handled as a data option with legal`
`values <TT`	`values <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>0</TT`	`>0</TT`
`> and <TT`	`> and <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>1</TT`	`>1</TT`
`>. The counter`	`>. The counter`
`arguments are as follows:</P`	`arguments are as follows:</P`
`><P`	`><P`
`></P`	`></P`
`><OL`	`><OL`
`TYPE="1"`	`TYPE="1"`
`><LI`	`><LI`
`><P`	`><P`
`>It would actually make <SPAN`	`>It would actually make <SPAN`
`CLASS="APPLICATION"`	`CLASS="APPLICATION"`
`>CDL</SPAN`	`>CDL</SPAN`
`> scripts more verbose. By default all`	`> scripts more verbose. By default all`
`options and components have the <TT`	`options and components have the <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>bool</TT`	`>bool</TT`
`> flavor, since`	`> flavor, since`
`most options are boolean in nature. Without a <TT`	`most options are boolean in nature. Without a <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>bool</TT`	`>bool</TT`
`>`	`>`
`flavor it would be necessary to indicate explicitly what the legal`	`flavor it would be necessary to indicate explicitly what the legal`
`values are somehow, e.g. with a <SPAN`	`values are somehow, e.g. with a <SPAN`
`CLASS="PROPERTY"`	`CLASS="PROPERTY"`
`>legal_values</SPAN`	`>legal_values</SPAN`
`> property.</P`	`> property.</P`
`></LI`	`></LI`
`><LI`	`><LI`
`><P`	`><P`
`>The boolean part of an option's value has a very different effect from`	`>The boolean part of an option's value has a very different effect from`
`the data part. If an option is disabled then it has no consequences at`	`the data part. If an option is disabled then it has no consequences at`
`build time, and can impose no constraints. A <TT`	`build time, and can impose no constraints. A <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>data</TT`	`>data</TT`
`>`	`>`
`option always has consequences and can impose constraints. To get the`	`option always has consequences and can impose constraints. To get the`
`desired effect it would be necessary to add <SPAN`	`desired effect it would be necessary to add <SPAN`
`CLASS="APPLICATION"`	`CLASS="APPLICATION"`
`>CDL</SPAN`	`>CDL</SPAN`
`> data indicating that`	`> data indicating that`
`a value of <TT`	`a value of <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>0</TT`	`>0</TT`
`> should be treated specially. Arguably`	`> should be treated specially. Arguably`
`this could be made built-in default behavior, although that would`	`this could be made built-in default behavior, although that would`
`complicate options where <TT`	`complicate options where <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>0</TT`	`>0</TT`
`> is a perfectly legal`	`> is a perfectly legal`
`number, for example`	`number, for example`
`<TT`	`<TT`
`CLASS="VARNAME"`	`CLASS="VARNAME"`
`>CYGNUM_LIBC_TIME_STD_DEFAULT_OFFSET</TT`	`>CYGNUM_LIBC_TIME_STD_DEFAULT_OFFSET</TT`
`>. </P`	`>. </P`
`></LI`	`></LI`
`><LI`	`><LI`
`><P`	`><P`
`>There would no replacement for a <TT`	`>There would no replacement for a <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>booldata</TT`	`>booldata</TT`
`> option`	`> option`
`for which <TT`	`for which <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>0</TT`	`>0</TT`
`> is a valid value. Again some additional`	`> is a valid value. Again some additional`
`<SPAN`	`<SPAN`
`CLASS="APPLICATION"`	`CLASS="APPLICATION"`
`>CDL</SPAN`	`>CDL</SPAN`
`> syntax would be needed to express such a concept.</P`	`> syntax would be needed to express such a concept.</P`
`></LI`	`></LI`
`></OL`	`></OL`
`><P`	`><P`
`>Although initially it may seem confusing that an option's value has`	`>Although initially it may seem confusing that an option's value has`
`both a boolean and a data part, it is an accurate reflection of how`	`both a boolean and a data part, it is an accurate reflection of how`
`configuration options actually work. The various alternatives would`	`configuration options actually work. The various alternatives would`
`all make it harder to write <SPAN`	`all make it harder to write <SPAN`
`CLASS="APPLICATION"`	`CLASS="APPLICATION"`
`>CDL</SPAN`	`>CDL</SPAN`
`> scripts.</P`	`> scripts.</P`
`><P`	`><P`
`>The next common suggestion is that the data part of a value should be`	`>The next common suggestion is that the data part of a value should be`
`typed in much the same way as C or C++ data types. For example it`	`typed in much the same way as C or C++ data types. For example it`
`should be possible to describe`	`should be possible to describe`
`<TT`	`<TT`
`CLASS="VARNAME"`	`CLASS="VARNAME"`
`>CYGNUM_LIBC_STDIO_BUFSIZE</TT`	`>CYGNUM_LIBC_STDIO_BUFSIZE</TT`
`> as an integer value,`	`> as an integer value,`
`rather than imposing <SPAN`	`rather than imposing <SPAN`
`CLASS="PROPERTY"`	`CLASS="PROPERTY"`
`>legal_values</SPAN`	`>legal_values</SPAN`
`> constraints. Again there are very`	`> constraints. Again there are very`
`good reasons why this approach was not taken:</P`	`good reasons why this approach was not taken:</P`
`><P`	`><P`
`></P`	`></P`
`><OL`	`><OL`
`TYPE="1"`	`TYPE="1"`
`><LI`	`><LI`
`><P`	`><P`
`>The possible legal values for an integer are rarely correct for a`	`>The possible legal values for an integer are rarely correct for a`
`<SPAN`	`<SPAN`
`CLASS="APPLICATION"`	`CLASS="APPLICATION"`
`>CDL</SPAN`	`>CDL</SPAN`
`> option. A constraint such as`	`> option. A constraint such as`
`<TT`	`<TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>1 to 0x7fffffff</TT`	`>1 to 0x7fffffff</TT`
`> is a bit more accurate,`	`> is a bit more accurate,`
`although if this option indicates a buffer size it is still not`	`although if this option indicates a buffer size it is still not`
`particularly good — very few targets will have enough`	`particularly good — very few targets will have enough`
`memory for such a buffer. Forcing <SPAN`	`memory for such a buffer. Forcing <SPAN`
`CLASS="APPLICATION"`	`CLASS="APPLICATION"`
`>CDL</SPAN`	`>CDL</SPAN`
`> writers to list the`	`> writers to list the`
`<SPAN`	`<SPAN`
`CLASS="PROPERTY"`	`CLASS="PROPERTY"`
`>legal_values</SPAN`	`>legal_values</SPAN`
`> constraints explicitly should make them think a bit`	`> constraints explicitly should make them think a bit`
`more about what values are actually sensible. For example`	`more about what values are actually sensible. For example`
`<TT`	`<TT`
`CLASS="VARNAME"`	`CLASS="VARNAME"`
`>CYGNUM_LIBC_TIME_DST_DEFAULT_OFFSET</TT`	`>CYGNUM_LIBC_TIME_DST_DEFAULT_OFFSET</TT`
`> has legal`	`> has legal`
`values in the range <TT`	`values in the range <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>-90000 to 90000</TT`	`>-90000 to 90000</TT`
`>,`	`>,`
`which helps the user to set a sensible value.</P`	`which helps the user to set a sensible value.</P`
`></LI`	`></LI`
`><LI`	`><LI`
`><P`	`><P`
`>Not all options correspond to simple data types such as integers.`	`>Not all options correspond to simple data types such as integers.`
`<TT`	`<TT`
`CLASS="VARNAME"`	`CLASS="VARNAME"`
`>CYGDAT_LIBC_STDIO_DEFAULT_CONSOLE</TT`	`>CYGDAT_LIBC_STDIO_DEFAULT_CONSOLE</TT`
`> is a C string,`	`> is a C string,`
`and would have to be expressed using something like`	`and would have to be expressed using something like`
`<TT`	`<TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>char []</TT`	`>char []</TT`
`>. This introduces plenty of`	`>. This introduces plenty of`
`opportunities for confusion, especially since square brackets may get`	`opportunities for confusion, especially since square brackets may get`
`processed by the <SPAN`	`processed by the <SPAN`
`CLASS="APPLICATION"`	`CLASS="APPLICATION"`
`>Tcl</SPAN`	`>Tcl</SPAN`
`> interpreter for command substitution.</P`	`> interpreter for command substitution.</P`
`></LI`	`></LI`
`><LI`	`><LI`
`><P`	`><P`
`>Some configuration options can get very complicated indeed, for`	`>Some configuration options can get very complicated indeed, for`
`example the default value of`	`example the default value of`
`<TT`	`<TT`
`CLASS="VARNAME"`	`CLASS="VARNAME"`
`>CYGDAT_UITRON_TASK_INITIALIZERS</TT`	`>CYGDAT_UITRON_TASK_INITIALIZERS</TT`
`> is:</P`	`> is:</P`
`><TABLE`	`><TABLE`
`BORDER="5"`	`BORDER="5"`
`BGCOLOR="#E0E0F0"`	`BGCOLOR="#E0E0F0"`
`WIDTH="70%"`	`WIDTH="70%"`
`><TR`	`><TR`
`><TD`	`><TD`
`><PRE`	`><PRE`
`CLASS="PROGRAMLISTING"`	`CLASS="PROGRAMLISTING"`
`>CYG_UIT_TASK( "t1", 1, task1, &stack1, CYGNUM_UITRON_STACK_SIZE ), \`	`>CYG_UIT_TASK( "t1", 1, task1, &stack1, CYGNUM_UITRON_STACK_SIZE ), \`
`CYG_UIT_TASK( "t2", 2, task2, &stack2, CYGNUM_UITRON_STACK_SIZE ), \`	`CYG_UIT_TASK( "t2", 2, task2, &stack2, CYGNUM_UITRON_STACK_SIZE ), \`
`CYG_UIT_TASK( "t3", 3, task3, &stack3, CYGNUM_UITRON_STACK_SIZE ), \`	`CYG_UIT_TASK( "t3", 3, task3, &stack3, CYGNUM_UITRON_STACK_SIZE ), \`
`CYG_UIT_TASK( "t4", 4, task4, &stack4, CYGNUM_UITRON_STACK_SIZE )</PRE`	`CYG_UIT_TASK( "t4", 4, task4, &stack4, CYGNUM_UITRON_STACK_SIZE )</PRE`
`></TD`	`></TD`
`></TR`	`></TR`
`></TABLE`	`></TABLE`
`><P`	`><P`
`>This would require <SPAN`	`>This would require <SPAN`
`CLASS="APPLICATION"`	`CLASS="APPLICATION"`
`>CDL</SPAN`	`>CDL</SPAN`
`> knowing about C macros, structures, arrays,`	`> knowing about C macros, structures, arrays,`
`static initializers, and so on. Adding such detailed knowledge about`	`static initializers, and so on. Adding such detailed knowledge about`
`the C language to the component framework is inappropriate.</P`	`the C language to the component framework is inappropriate.</P`
`></LI`	`></LI`
`><LI`	`><LI`
`><P`	`><P`
`><SPAN`	`><SPAN`
`CLASS="APPLICATION"`	`CLASS="APPLICATION"`
`>CDL</SPAN`	`>CDL</SPAN`
`> needs to be usable with languages other than C. At present this`	`> needs to be usable with languages other than C. At present this`
`includes C++, in future it may include languages such as Java. Each`	`includes C++, in future it may include languages such as Java. Each`
`language adds new data types and related complications, for example`	`language adds new data types and related complications, for example`
`C++ classes and inheritance. Making <SPAN`	`C++ classes and inheritance. Making <SPAN`
`CLASS="APPLICATION"`	`CLASS="APPLICATION"`
`>CDL</SPAN`	`>CDL</SPAN`
`> support a union of all data`	`> support a union of all data`
`types in all possible languages is not sensible.</P`	`types in all possible languages is not sensible.</P`
`></LI`	`></LI`
`></OL`	`></OL`
`><P`	`><P`
`>The <SPAN`	`>The <SPAN`
`CLASS="APPLICATION"`	`CLASS="APPLICATION"`
`>CDL</SPAN`	`>CDL</SPAN`
`> approach of treating all data as a sequence of characters,`	`> approach of treating all data as a sequence of characters,`
`possibly constrained by a <SPAN`	`possibly constrained by a <SPAN`
`CLASS="PROPERTY"`	`CLASS="PROPERTY"`
`>legal_values</SPAN`	`>legal_values</SPAN`
`> property or other means, has`	`> property or other means, has`
`the great advantage of simplicity. It also fits in with the <SPAN`	`the great advantage of simplicity. It also fits in with the <SPAN`
`CLASS="APPLICATION"`	`CLASS="APPLICATION"`
`>Tcl</SPAN`	`>Tcl</SPAN`
`>`	`>`
`language that underlies <SPAN`	`language that underlies <SPAN`
`CLASS="APPLICATION"`	`CLASS="APPLICATION"`
`>CDL</SPAN`	`>CDL</SPAN`
`>.</P`	`>.</P`
`></BLOCKQUOTE`	`></BLOCKQUOTE`
`></DIV`	`></DIV`
`></DIV`	`></DIV`
`><DIV`	`><DIV`
`CLASS="SECT3"`	`CLASS="SECT3"`
`><H3`	`><H3`
`CLASS="SECT3"`	`CLASS="SECT3"`
`><A`	`><A`
`NAME="LANGUAGE.VALUES.VALUE.EXAMPLES">Some Examples</H3`	`NAME="LANGUAGE.VALUES.VALUE.EXAMPLES">Some Examples</H3`
`><P`	`><P`
`>The following excerpt from the C library's <SPAN`	`>The following excerpt from the C library's <SPAN`
`CLASS="APPLICATION"`	`CLASS="APPLICATION"`
`>CDL</SPAN`	`>CDL</SPAN`
`> scripts can be used`	`> scripts can be used`
`to illustrate how values and flavors work in practice:</P`	`to illustrate how values and flavors work in practice:</P`
`><TABLE`	`><TABLE`
`BORDER="5"`	`BORDER="5"`
`BGCOLOR="#E0E0F0"`	`BGCOLOR="#E0E0F0"`
`WIDTH="70%"`	`WIDTH="70%"`
`><TR`	`><TR`
`><TD`	`><TD`
`><PRE`	`><PRE`
`CLASS="PROGRAMLISTING"`	`CLASS="PROGRAMLISTING"`
`>cdl_component CYGPKG_LIBC_RAND {`	`>cdl_component CYGPKG_LIBC_RAND {`
`flavor none`	`flavor none`
`compile stdlib/rand.cxx`	`compile stdlib/rand.cxx`

`cdl_option CYGSEM_LIBC_PER_THREAD_RAND {`	`cdl_option CYGSEM_LIBC_PER_THREAD_RAND {`
`requires CYGVAR_KERNEL_THREADS_DATA`	`requires CYGVAR_KERNEL_THREADS_DATA`
`default_value 0`	`default_value 0`
`}`	`}`

`cdl_option CYGNUM_LIBC_RAND_SEED {`	`cdl_option CYGNUM_LIBC_RAND_SEED {`
`flavor data`	`flavor data`
`legal_values 0 to 0x7fffffff`	`legal_values 0 to 0x7fffffff`
`default_value 1`	`default_value 1`
`}`	`}`

`cdl_option CYGNUM_LIBC_RAND_TRACE_LEVEL {`	`cdl_option CYGNUM_LIBC_RAND_TRACE_LEVEL {`
`flavor data`	`flavor data`
`legal_values 0 to 1`	`legal_values 0 to 1`
`default_value 0`	`default_value 0`
`}`	`}`
`}</PRE`	`}</PRE`
`></TD`	`></TD`
`></TR`	`></TR`
`></TABLE`	`></TABLE`
`><P`	`><P`
`>If the application does not require any C library functionality then`	`>If the application does not require any C library functionality then`
`it is possible to have a configuration where the C library is not`	`it is possible to have a configuration where the C library is not`
`loaded. This can be achieved by starting with the minimal template, or`	`loaded. This can be achieved by starting with the minimal template, or`
`by starting with another template such as the default one and then`	`by starting with another template such as the default one and then`
`explicitly unloading the C library package. If this package is not`	`explicitly unloading the C library package. If this package is not`
`loaded then any references to the <TT`	`loaded then any references to the <TT`
`CLASS="VARNAME"`	`CLASS="VARNAME"`
`>CYGPKG_LIBC_RAND</TT`	`>CYGPKG_LIBC_RAND</TT`
`>`	`>`
`component or any of its options will have a value of`	`component or any of its options will have a value of`
`<TT`	`<TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>0</TT`	`>0</TT`
`> for the purposes of expression evaluation. No`	`> for the purposes of expression evaluation. No`
`<TT`	`<TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>#define's</TT`	`>#define's</TT`
`> will be generated for the component or`	`> will be generated for the component or`
`any of its options, and the file <TT`	`any of its options, and the file <TT`
`CLASS="FILENAME"`	`CLASS="FILENAME"`
`>stdlib/rand.cxx</TT`	`>stdlib/rand.cxx</TT`
`>`	`>`
`will not get compiled. There is nothing special about the C library`	`will not get compiled. There is nothing special about the C library`
`here, exactly the same would apply for say a device driver that does`	`here, exactly the same would apply for say a device driver that does`
`not correspond to any of the devices on the target hardware.</P`	`not correspond to any of the devices on the target hardware.</P`
`><P`	`><P`
`>Assuming the C library is loaded, the next thing to consider is`	`>Assuming the C library is loaded, the next thing to consider is`
`whether or not the component and its options are active. The component`	`whether or not the component and its options are active. The component`
`is layered immediately below the C library package itself, so if the`	`is layered immediately below the C library package itself, so if the`
`package is loaded then it is safe to assume that the package is also`	`package is loaded then it is safe to assume that the package is also`
`enabled. Therefore the parent of <TT`	`enabled. Therefore the parent of <TT`
`CLASS="VARNAME"`	`CLASS="VARNAME"`
`>CYGPKG_LIBC_RAND</TT`	`>CYGPKG_LIBC_RAND</TT`
`>`	`>`
`is active and enabled, and in the absence of any <SPAN`	`is active and enabled, and in the absence of any <SPAN`
`CLASS="PROPERTY"`	`CLASS="PROPERTY"`
`>active_if</SPAN`	`>active_if</SPAN`
`>`	`>`
`properties <TT`	`properties <TT`
`CLASS="VARNAME"`	`CLASS="VARNAME"`
`>CYGPKG_LIBC_RAND</TT`	`>CYGPKG_LIBC_RAND</TT`
`> will be active as well.</P`	`> will be active as well.</P`
`><P`	`><P`
`>The component <TT`	`>The component <TT`
`CLASS="VARNAME"`	`CLASS="VARNAME"`
`>CYGPKG_LIBC_RAND</TT`	`>CYGPKG_LIBC_RAND</TT`
`> has the flavor`	`> has the flavor`
`<TT`	`<TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>none</TT`	`>none</TT`
`>. This means the component cannot be disabled.`	`>. This means the component cannot be disabled.`
`Therefore all the options in this component have an active and enabled`	`Therefore all the options in this component have an active and enabled`
`parent, and in the absence of any <SPAN`	`parent, and in the absence of any <SPAN`
`CLASS="PROPERTY"`	`CLASS="PROPERTY"`
`>active_if</SPAN`	`>active_if</SPAN`
`> properties they are all`	`> properties they are all`
`active as well.</P`	`active as well.</P`
`><P`	`><P`
`>The component's flavor <TT`	`>The component's flavor <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>none</TT`	`>none</TT`
`> serves to group`	`> serves to group`
`together all of the configuration options related to random number`	`together all of the configuration options related to random number`
`generation. This is particularly useful in the context of the`	`generation. This is particularly useful in the context of the`
`graphical configuration tool, but it also helps when it comes to`	`graphical configuration tool, but it also helps when it comes to`
`naming the options: all of the options begin with`	`naming the options: all of the options begin with`
`<TT`	`<TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>CYGxxx_LIBC_RAND</TT`	`>CYGxxx_LIBC_RAND</TT`
`>, giving a clear hint about both`	`>, giving a clear hint about both`
`the package and the component within that package. The flavor means`	`the package and the component within that package. The flavor means`
`that the component is always enabled and has the value`	`that the component is always enabled and has the value`
`<TT`	`<TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>1</TT`	`>1</TT`
`> for the purposes of expression evaluation. There`	`> for the purposes of expression evaluation. There`
`will always be a single <TT`	`will always be a single <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>#define</TT`	`>#define</TT`
`> of the form:</P`	`> of the form:</P`
`><TABLE`	`><TABLE`
`BORDER="5"`	`BORDER="5"`
`BGCOLOR="#E0E0F0"`	`BGCOLOR="#E0E0F0"`
`WIDTH="70%"`	`WIDTH="70%"`
`><TR`	`><TR`
`><TD`	`><TD`
`><PRE`	`><PRE`
`CLASS="PROGRAMLISTING"`	`CLASS="PROGRAMLISTING"`
`>#define CYGPKG_LIBC_RAND 1</PRE`	`>#define CYGPKG_LIBC_RAND 1</PRE`
`></TD`	`></TD`
`></TR`	`></TR`
`></TABLE`	`></TABLE`
`><P`	`><P`
`>In addition the file <TT`	`>In addition the file <TT`
`CLASS="FILENAME"`	`CLASS="FILENAME"`
`>stdlib/rand.cxx</TT`	`>stdlib/rand.cxx</TT`
`> will always`	`> will always`
`get built. If the component had the default <TT`	`get built. If the component had the default <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>bool</TT`	`>bool</TT`
`>`	`>`
`flavor then users would be able to disable the whole component,`	`flavor then users would be able to disable the whole component,`
`and one less file would need to be built. However random number`	`and one less file would need to be built. However random number`
`generation is relatively simple, so the impact on eCos build times are`	`generation is relatively simple, so the impact on eCos build times are`
`small. Furthermore by default the code has no dependencies on other`	`small. Furthermore by default the code has no dependencies on other`
`parts of the system, so compiling the code has no unexpected side`	`parts of the system, so compiling the code has no unexpected side`
`effects. Even if it was possible to disable the component, the`	`effects. Even if it was possible to disable the component, the`
`sensible default for most applications would still leave it enabled.`	`sensible default for most applications would still leave it enabled.`
`The net result is that the flavor <TT`	`The net result is that the flavor <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>none</TT`	`>none</TT`
`> is probably`	`> is probably`
`the most sensible one for this component. For other components the`	`the most sensible one for this component. For other components the`
`default <TT`	`default <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>bool</TT`	`>bool</TT`
`> flavor or one of the other flavors`	`> flavor or one of the other flavors`
`might be more appropriate.</P`	`might be more appropriate.</P`
`><P`	`><P`
`>Next consider option <TT`	`>Next consider option <TT`
`CLASS="VARNAME"`	`CLASS="VARNAME"`
`>CYGSEM_LIBC_PER_THREAD_RAND</TT`	`>CYGSEM_LIBC_PER_THREAD_RAND</TT`
`>`	`>`
`which can be used to get a per-thread random number seed, possibly`	`which can be used to get a per-thread random number seed, possibly`
`useful if the application needs a consistent sequence of random`	`useful if the application needs a consistent sequence of random`
`numbers. In the absence of a <SPAN`	`numbers. In the absence of a <SPAN`
`CLASS="PROPERTY"`	`CLASS="PROPERTY"`
`>flavor</SPAN`	`>flavor</SPAN`
`> property this option will be`	`> property this option will be`
`boolean, and the <SPAN`	`boolean, and the <SPAN`
`CLASS="PROPERTY"`	`CLASS="PROPERTY"`
`>default_value</SPAN`	`>default_value</SPAN`
`> property means that it is disabled by`	`> property means that it is disabled by`
`default — reasonable since few applications need this`	`default — reasonable since few applications need this`
`particular functionality, and it does impose a constraint on the rest`	`particular functionality, and it does impose a constraint on the rest`
`of the system. If the option is left disabled then no`	`of the system. If the option is left disabled then no`
`<TT`	`<TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>#define</TT`	`>#define</TT`
`> will be generated, and if there were any`	`> will be generated, and if there were any`
`<SPAN`	`<SPAN`
`CLASS="PROPERTY"`	`CLASS="PROPERTY"`
`>compile</SPAN`	`>compile</SPAN`
`> or similar properties these would not take effect. If the`	`> or similar properties these would not take effect. If the`
`option is enabled then a <TT`	`option is enabled then a <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>#define</TT`	`>#define</TT`
`> will be generated,`	`> will be generated,`
`using the option's data part which is fixed at <TT`	`using the option's data part which is fixed at <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>1</TT`	`>1</TT`
`>:</P`	`>:</P`
`><TABLE`	`><TABLE`
`BORDER="5"`	`BORDER="5"`
`BGCOLOR="#E0E0F0"`	`BGCOLOR="#E0E0F0"`
`WIDTH="70%"`	`WIDTH="70%"`
`><TR`	`><TR`
`><TD`	`><TD`
`><PRE`	`><PRE`
`CLASS="PROGRAMLISTING"`	`CLASS="PROGRAMLISTING"`
`>#define CYGSEM_LIBC_PER_THREAD_RAND 1</PRE`	`>#define CYGSEM_LIBC_PER_THREAD_RAND 1</PRE`
`></TD`	`></TD`
`></TR`	`></TR`
`></TABLE`	`></TABLE`
`><P`	`><P`
`>The <TT`	`>The <TT`
`CLASS="VARNAME"`	`CLASS="VARNAME"`
`>CYGSEM_LIBC_PER_THREAD_RAND</TT`	`>CYGSEM_LIBC_PER_THREAD_RAND</TT`
`> option has a`	`> option has a`
`<SPAN`	`<SPAN`
`CLASS="PROPERTY"`	`CLASS="PROPERTY"`
`>requires</SPAN`	`>requires</SPAN`
`> constraint on`	`> constraint on`
`<TT`	`<TT`
`CLASS="VARNAME"`	`CLASS="VARNAME"`
`>CYGVAR_KERNEL_THREADS_DATA</TT`	`>CYGVAR_KERNEL_THREADS_DATA</TT`
`>. If the C library option`	`>. If the C library option`
`is enabled then the constraint should be satisfied, or else the`	`is enabled then the constraint should be satisfied, or else the`
`configuration contains a conflict. If the configuration does not`	`configuration contains a conflict. If the configuration does not`
`include the kernel package then`	`include the kernel package then`
`<TT`	`<TT`
`CLASS="VARNAME"`	`CLASS="VARNAME"`
`>CYGVAR_KERNEL_THREADS_DATA</TT`	`>CYGVAR_KERNEL_THREADS_DATA</TT`
`> will evaluate to`	`> will evaluate to`
`<TT`	`<TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>0</TT`	`>0</TT`
`> and the constraint is not satisfied. Similarly if`	`> and the constraint is not satisfied. Similarly if`
`the option is inactive or disabled the constraint will not be`	`the option is inactive or disabled the constraint will not be`
`satisfied.</P`	`satisfied.</P`
`><P`	`><P`
`><TT`	`><TT`
`CLASS="VARNAME"`	`CLASS="VARNAME"`
`>CYGNUM_LIBC_RAND_SEED</TT`	`>CYGNUM_LIBC_RAND_SEED</TT`
`> and`	`> and`
`<TT`	`<TT`
`CLASS="VARNAME"`	`CLASS="VARNAME"`
`>CYGNUM_LIBC_RAND_TRACE_LEVEL</TT`	`>CYGNUM_LIBC_RAND_TRACE_LEVEL</TT`
`> both have the`	`> both have the`
`<TT`	`<TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>data</TT`	`>data</TT`
`> flavor, so they are always enabled and the`	`> flavor, so they are always enabled and the`
`component framework will generate appropriate`	`component framework will generate appropriate`
`<TT`	`<TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>#define's</TT`	`>#define's</TT`
`>:</P`	`>:</P`
`><TABLE`	`><TABLE`
`BORDER="5"`	`BORDER="5"`
`BGCOLOR="#E0E0F0"`	`BGCOLOR="#E0E0F0"`
`WIDTH="70%"`	`WIDTH="70%"`
`><TR`	`><TR`
`><TD`	`><TD`
`><PRE`	`><PRE`
`CLASS="PROGRAMLISTING"`	`CLASS="PROGRAMLISTING"`
`>#define CYGNUM_LIBC_RAND_SEED 1`	`>#define CYGNUM_LIBC_RAND_SEED 1`
`#define CYGNUM_LIBC_RAND_SEED_1`	`#define CYGNUM_LIBC_RAND_SEED_1`
`#define CYGNUM_LIBC_RAND_TRACE_LEVEL 0`	`#define CYGNUM_LIBC_RAND_TRACE_LEVEL 0`
`#define CYGNUM_LIBC_RAND_TRACE_LEVEL_0</PRE`	`#define CYGNUM_LIBC_RAND_TRACE_LEVEL_0</PRE`
`></TD`	`></TD`
`></TR`	`></TR`
`></TABLE`	`></TABLE`
`><P`	`><P`
`>Neither option has a <SPAN`	`>Neither option has a <SPAN`
`CLASS="PROPERTY"`	`CLASS="PROPERTY"`
`>compile</SPAN`	`>compile</SPAN`
`> or similar property, but any such`	`> or similar property, but any such`
`properties would take effect. Any references to these options in <SPAN`	`properties would take effect. Any references to these options in <SPAN`
`CLASS="APPLICATION"`	`CLASS="APPLICATION"`
`>CDL</SPAN`	`>CDL</SPAN`
`>`	`>`
`expressions would evaluate to the data part, so a hypothetical`	`expressions would evaluate to the data part, so a hypothetical`
`constraint of the form`	`constraint of the form`
`<TT`	`<TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>{ requires CYGNUM_LIBC_RAND_SEED > 42 }</TT`	`>{ requires CYGNUM_LIBC_RAND_SEED > 42 }</TT`
`>`	`>`
`would not be satisfied with the default values. Both options use a`	`would not be satisfied with the default values. Both options use a`
`simple constant for the <SPAN`	`simple constant for the <SPAN`
`CLASS="PROPERTY"`	`CLASS="PROPERTY"`
`>default_value</SPAN`	`>default_value</SPAN`
`> expression. It would be`	`> expression. It would be`
`possible to use a more complicated expression, for example the default`	`possible to use a more complicated expression, for example the default`
`for <TT`	`for <TT`
`CLASS="VARNAME"`	`CLASS="VARNAME"`
`>CYGNUM_LIBC_RAND_TRACE_LEVEL</TT`	`>CYGNUM_LIBC_RAND_TRACE_LEVEL</TT`
`> could be`	`> could be`
`determined from some global debugging option or from a debugging`	`determined from some global debugging option or from a debugging`
`option that applies to the C library as a whole. Both options also`	`option that applies to the C library as a whole. Both options also`
`have a <SPAN`	`have a <SPAN`
`CLASS="PROPERTY"`	`CLASS="PROPERTY"`
`>legal_values</SPAN`	`>legal_values</SPAN`
`> constraint, which must be satisfied since the`	`> constraint, which must be satisfied since the`
`options are active and enabled. </P`	`options are active and enabled. </P`
`><DIV`	`><DIV`
`CLASS="NOTE"`	`CLASS="NOTE"`
`><BLOCKQUOTE`	`><BLOCKQUOTE`
`CLASS="NOTE"`	`CLASS="NOTE"`
`><P`	`><P`
`><B`	`><B`
`>Note: </B`	`>Note: </B`
`>The value <TT`	`>The value <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>0</TT`	`>0</TT`
`> is legal for both`	`> is legal for both`
`<TT`	`<TT`
`CLASS="VARNAME"`	`CLASS="VARNAME"`
`>CYGNUM_LIBC_RAND_SEED</TT`	`>CYGNUM_LIBC_RAND_SEED</TT`
`> and`	`> and`
`<TT`	`<TT`
`CLASS="VARNAME"`	`CLASS="VARNAME"`
`>CYGNUM_LIBC_RAND_TRACE_LEVEL</TT`	`>CYGNUM_LIBC_RAND_TRACE_LEVEL</TT`
`>, so in a <SPAN`	`>, so in a <SPAN`
`CLASS="APPLICATION"`	`CLASS="APPLICATION"`
`>CDL</SPAN`	`>CDL</SPAN`
`>`	`>`
`expression there is no easy way of distinguishing between the options`	`expression there is no easy way of distinguishing between the options`
`being absent or having that particular value. This will be addressed`	`being absent or having that particular value. This will be addressed`
`by future enhancements to the expression syntax.</P`	`by future enhancements to the expression syntax.</P`
`></BLOCKQUOTE`	`></BLOCKQUOTE`
`></DIV`	`></DIV`
`></DIV`	`></DIV`
`></DIV`	`></DIV`
`><DIV`	`><DIV`
`CLASS="SECT2"`	`CLASS="SECT2"`
`><H2`	`><H2`
`CLASS="SECT2"`	`CLASS="SECT2"`
`><A`	`><A`
`NAME="LANGUAGE.EXPRESSION">Ordinary Expressions</H2`	`NAME="LANGUAGE.EXPRESSION">Ordinary Expressions</H2`
`><P`	`><P`
`>Expressions in <SPAN`	`>Expressions in <SPAN`
`CLASS="APPLICATION"`	`CLASS="APPLICATION"`
`>CDL</SPAN`	`>CDL</SPAN`
`> follow a conventional syntax, for example:</P`	`> follow a conventional syntax, for example:</P`
`><TABLE`	`><TABLE`
`BORDER="5"`	`BORDER="5"`
`BGCOLOR="#E0E0F0"`	`BGCOLOR="#E0E0F0"`
`WIDTH="70%"`	`WIDTH="70%"`
`><TR`	`><TR`
`><TD`	`><TD`
`><PRE`	`><PRE`
`CLASS="PROGRAMLISTING"`	`CLASS="PROGRAMLISTING"`
`> default_value CYGGLO_CODESIZE > CYGGLO_SPEED`	`> default_value CYGGLO_CODESIZE > CYGGLO_SPEED`
`default_value { (CYG_HAL_STARTUP == "RAM" &&`	`default_value { (CYG_HAL_STARTUP == "RAM" &&`
`!CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS &&`	`!CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS &&`
`!CYGINT_HAL_USE_ROM_MONITOR_UNSUPPORTED &&`	`!CYGINT_HAL_USE_ROM_MONITOR_UNSUPPORTED &&`
`!CYGSEM_HAL_POWERPC_COPY_VECTORS) ? 1 : 0 }`	`!CYGSEM_HAL_POWERPC_COPY_VECTORS) ? 1 : 0 }`
`default_value { "\"/dev/ser0\"" }</PRE`	`default_value { "\"/dev/ser0\"" }</PRE`
`></TD`	`></TD`
`></TR`	`></TR`
`></TABLE`	`></TABLE`
`><P`	`><P`
`>However there is a complication in that the various arguments to a`	`>However there is a complication in that the various arguments to a`
`<SPAN`	`<SPAN`
`CLASS="PROPERTY"`	`CLASS="PROPERTY"`
`>default_value</SPAN`	`>default_value</SPAN`
`> property will first get processed by a <SPAN`	`> property will first get processed by a <SPAN`
`CLASS="APPLICATION"`	`CLASS="APPLICATION"`
`>Tcl</SPAN`	`>Tcl</SPAN`
`>`	`>`
`interpreter, so special characters like quotes and square brackets may`	`interpreter, so special characters like quotes and square brackets may`
`get processed. Such problems can be avoided by enclosing non-trivial`	`get processed. Such problems can be avoided by enclosing non-trivial`
`expressions in braces, as in the second example above. The way`	`expressions in braces, as in the second example above. The way`
`expression parsing actually works is as follows:</P`	`expression parsing actually works is as follows:</P`
`><P`	`><P`
`></P`	`></P`
`><OL`	`><OL`
`TYPE="1"`	`TYPE="1"`
`><LI`	`><LI`
`><P`	`><P`
`>The <SPAN`	`>The <SPAN`
`CLASS="APPLICATION"`	`CLASS="APPLICATION"`
`>Tcl</SPAN`	`>Tcl</SPAN`
`> interpreter splits the line or lines into a command and its`	`> interpreter splits the line or lines into a command and its`
`arguments. In the first <SPAN`	`arguments. In the first <SPAN`
`CLASS="PROPERTY"`	`CLASS="PROPERTY"`
`>default_value</SPAN`	`>default_value</SPAN`
`> expression above the command`	`> expression above the command`
`is <TT`	`is <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>default_value</TT`	`>default_value</TT`
`> and there are three arguments,`	`> and there are three arguments,`
`<TT`	`<TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>CYGGLO_CODESIZE</TT`	`>CYGGLO_CODESIZE</TT`
`>, <TT`	`>, <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>></TT`	`>></TT`
`> and`	`> and`
`<TT`	`<TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>CYGGLO_SPEED</TT`	`>CYGGLO_SPEED</TT`
`>. In the second and third examples`	`>. In the second and third examples`
`there is just one argument, courtesy of the braces.</P`	`there is just one argument, courtesy of the braces.</P`
`></LI`	`></LI`
`><LI`	`><LI`
`><P`	`><P`
`>Next option processing takes place, so any initial arguments that`	`>Next option processing takes place, so any initial arguments that`
`begin with a hyphen will be interpreted as options. This can cause`	`begin with a hyphen will be interpreted as options. This can cause`
`problems if the expression involves a negative number, so the`	`problems if the expression involves a negative number, so the`
`special argument <TT`	`special argument <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>--</TT`	`>--</TT`
`> can be used to prevent option`	`> can be used to prevent option`
`processing on the subsequent arguments.</P`	`processing on the subsequent arguments.</P`
`></LI`	`></LI`
`><LI`	`><LI`
`><P`	`><P`
`>All of the arguments are now concatenated, with a single space in`	`>All of the arguments are now concatenated, with a single space in`
`between each one. Hence the following two expressions are equivalent,`	`between each one. Hence the following two expressions are equivalent,`
`even though they will have been processed differently up to this point.</P`	`even though they will have been processed differently up to this point.</P`
`><TABLE`	`><TABLE`
`BORDER="5"`	`BORDER="5"`
`BGCOLOR="#E0E0F0"`	`BGCOLOR="#E0E0F0"`
`WIDTH="70%"`	`WIDTH="70%"`
`><TR`	`><TR`
`><TD`	`><TD`
`><PRE`	`><PRE`
`CLASS="PROGRAMLISTING"`	`CLASS="PROGRAMLISTING"`
`> default_value CYGGLO_CODESIZE > CYGGLO_SPEED`	`> default_value CYGGLO_CODESIZE > CYGGLO_SPEED`
`default_value {CYGGLO_CODESIZE > CYGGLO_SPEED}</PRE`	`default_value {CYGGLO_CODESIZE > CYGGLO_SPEED}</PRE`
`></TD`	`></TD`
`></TR`	`></TR`
`></TABLE`	`></TABLE`
`></LI`	`></LI`
`><LI`	`><LI`
`><P`	`><P`
`>The expression parsing code now has a single string to process.</P`	`>The expression parsing code now has a single string to process.</P`
`></LI`	`></LI`
`></OL`	`></OL`
`><P`	`><P`
`><SPAN`	`><SPAN`
`CLASS="APPLICATION"`	`CLASS="APPLICATION"`
`>CDL</SPAN`	`>CDL</SPAN`
`> expressions consist of four types of element: references to`	`> expressions consist of four types of element: references to`
`configuration options, constant strings, integers, and floating point`	`configuration options, constant strings, integers, and floating point`
`numbers. These are combined using a conventional set of operators: the`	`numbers. These are combined using a conventional set of operators: the`
`unary operators <TT`	`unary operators <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>-</TT`	`>-</TT`
`>, <TT`	`>, <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>~</TT`	`>~</TT`
`> and`	`> and`
`<TT`	`<TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>!</TT`	`>!</TT`
`>; the arithmetic operators <TT`	`>; the arithmetic operators <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>+</TT`	`>+</TT`
`>,`	`>,`
`<TT`	`<TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>-</TT`	`>-</TT`
`>, <TT`	`>, <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>*</TT`	`>*</TT`
`>, <TT`	`>, <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>/</TT`	`>/</TT`
`> and`	`> and`
`<TT`	`<TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>%</TT`	`>%</TT`
`>; the shift operators <TT`	`>; the shift operators <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`><<</TT`	`><<</TT`
`>`	`>`
`and <TT`	`and <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>>></TT`	`>>></TT`
`>; the comparison operators`	`>; the comparison operators`
`<TT`	`<TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>==</TT`	`>==</TT`
`>, <TT`	`>, <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>!=</TT`	`>!=</TT`
`>, <TT`	`>, <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`><</TT`	`><</TT`
`>,`	`>,`
`<TT`	`<TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`><=</TT`	`><=</TT`
`>, <TT`	`>, <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>></TT`	`>></TT`
`> and`	`> and`
`<TT`	`<TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>>=</TT`	`>>=</TT`
`>; the bitwise operators`	`>; the bitwise operators`
`<TT`	`<TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>&</TT`	`>&</TT`
`>, <TT`	`>, <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>^</TT`	`>^</TT`
`> and`	`> and`
`<TT`	`<TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>\|</TT`	`>\|</TT`
`>; the logical operators <TT`	`>; the logical operators <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>&&</TT`	`>&&</TT`
`> and`	`> and`
`<TT`	`<TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>\|\|</TT`	`>\|\|</TT`
`>; the string concatenation operator`	`>; the string concatenation operator`
`<TT`	`<TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>.</TT`	`>.</TT`
`>; and the ternary conditional operator`	`>; and the ternary conditional operator`
`<TT`	`<TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>A ? B : C</TT`	`>A ? B : C</TT`
`>. There is also support for`	`>. There is also support for`
`some less widely available operators for logical equivalence and`	`some less widely available operators for logical equivalence and`
`implication, and for a set of function-style operations. Bracketed`	`implication, and for a set of function-style operations. Bracketed`
`sub-expressions are supported, and the operators have the usual`	`sub-expressions are supported, and the operators have the usual`
`precedence:</P`	`precedence:</P`
`><DIV`	`><DIV`
`CLASS="INFORMALTABLE"`	`CLASS="INFORMALTABLE"`
`><A`	`><A`
`NAME="AEN1653"><P`	`NAME="AEN1653"><P`
`></P`	`></P`
`><TABLE`	`><TABLE`
`BORDER="1"`	`BORDER="1"`
`CLASS="CALSTABLE"`	`CLASS="CALSTABLE"`
`><THEAD`	`><THEAD`
`><TR`	`><TR`
`><TH`	`><TH`
`WIDTH="33%"`	`WIDTH="33%"`
`ALIGN="CENTER"`	`ALIGN="CENTER"`
`VALIGN="TOP"`	`VALIGN="TOP"`
`>Priority</TH`	`>Priority</TH`
`><TH`	`><TH`
`WIDTH="33%"`	`WIDTH="33%"`
`ALIGN="CENTER"`	`ALIGN="CENTER"`
`VALIGN="TOP"`	`VALIGN="TOP"`
`>Operators</TH`	`>Operators</TH`
`><TH`	`><TH`
`WIDTH="33%"`	`WIDTH="33%"`
`ALIGN="CENTER"`	`ALIGN="CENTER"`
`VALIGN="TOP"`	`VALIGN="TOP"`
`>Category</TH`	`>Category</TH`
`></TR`	`></TR`
`></THEAD`	`></THEAD`
`><TBODY`	`><TBODY`
`><TR`	`><TR`
`><TD`	`><TD`
`WIDTH="33%"`	`WIDTH="33%"`
`ALIGN="CENTER"`	`ALIGN="CENTER"`
`VALIGN="TOP"`	`VALIGN="TOP"`
`>16</TD`	`>16</TD`
`><TD`	`><TD`
`WIDTH="33%"`	`WIDTH="33%"`
`ALIGN="CENTER"`	`ALIGN="CENTER"`
`VALIGN="TOP"`	`VALIGN="TOP"`
`>references, constants</TD`	`>references, constants</TD`
`><TD`	`><TD`
`WIDTH="33%"`	`WIDTH="33%"`
`ALIGN="CENTER"`	`ALIGN="CENTER"`
`VALIGN="TOP"`	`VALIGN="TOP"`
`>basic elements</TD`	`>basic elements</TD`
`></TR`	`></TR`
`><TR`	`><TR`
`><TD`	`><TD`
`WIDTH="33%"`	`WIDTH="33%"`
`ALIGN="CENTER"`	`ALIGN="CENTER"`
`VALIGN="TOP"`	`VALIGN="TOP"`
`>15</TD`	`>15</TD`
`><TD`	`><TD`
`WIDTH="33%"`	`WIDTH="33%"`
`ALIGN="CENTER"`	`ALIGN="CENTER"`
`VALIGN="TOP"`	`VALIGN="TOP"`
`><TT`	`><TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>f(a, b, c)</TT`	`>f(a, b, c)</TT`
`></TD`	`></TD`
`><TD`	`><TD`
`WIDTH="33%"`	`WIDTH="33%"`
`ALIGN="CENTER"`	`ALIGN="CENTER"`
`VALIGN="TOP"`	`VALIGN="TOP"`
`>function calls</TD`	`>function calls</TD`
`></TR`	`></TR`
`><TR`	`><TR`
`><TD`	`><TD`
`WIDTH="33%"`	`WIDTH="33%"`
`ALIGN="CENTER"`	`ALIGN="CENTER"`
`VALIGN="TOP"`	`VALIGN="TOP"`
`>14</TD`	`>14</TD`
`><TD`	`><TD`
`WIDTH="33%"`	`WIDTH="33%"`
`ALIGN="CENTER"`	`ALIGN="CENTER"`
`VALIGN="TOP"`	`VALIGN="TOP"`
`><TT`	`><TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>~</TT`	`>~</TT`
`></TD`	`></TD`
`><TD`	`><TD`
`WIDTH="33%"`	`WIDTH="33%"`
`ALIGN="CENTER"`	`ALIGN="CENTER"`
`VALIGN="TOP"`	`VALIGN="TOP"`
`>bitwise not</TD`	`>bitwise not</TD`
`></TR`	`></TR`
`><TR`	`><TR`
`><TD`	`><TD`
`WIDTH="33%"`	`WIDTH="33%"`
`ALIGN="CENTER"`	`ALIGN="CENTER"`
`VALIGN="TOP"`	`VALIGN="TOP"`
`>14</TD`	`>14</TD`
`><TD`	`><TD`
`WIDTH="33%"`	`WIDTH="33%"`
`ALIGN="CENTER"`	`ALIGN="CENTER"`
`VALIGN="TOP"`	`VALIGN="TOP"`
`><TT`	`><TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>!</TT`	`>!</TT`
`></TD`	`></TD`
`><TD`	`><TD`
`WIDTH="33%"`	`WIDTH="33%"`
`ALIGN="CENTER"`	`ALIGN="CENTER"`
`VALIGN="TOP"`	`VALIGN="TOP"`
`>logical not</TD`	`>logical not</TD`
`></TR`	`></TR`
`><TR`	`><TR`
`><TD`	`><TD`
`WIDTH="33%"`	`WIDTH="33%"`
`ALIGN="CENTER"`	`ALIGN="CENTER"`
`VALIGN="TOP"`	`VALIGN="TOP"`
`>14</TD`	`>14</TD`
`><TD`	`><TD`
`WIDTH="33%"`	`WIDTH="33%"`
`ALIGN="CENTER"`	`ALIGN="CENTER"`
`VALIGN="TOP"`	`VALIGN="TOP"`
`><TT`	`><TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>-</TT`	`>-</TT`
`></TD`	`></TD`
`><TD`	`><TD`
`WIDTH="33%"`	`WIDTH="33%"`
`ALIGN="CENTER"`	`ALIGN="CENTER"`
`VALIGN="TOP"`	`VALIGN="TOP"`
`>arithmetic negation</TD`	`>arithmetic negation</TD`
`></TR`	`></TR`
`><TR`	`><TR`
`><TD`	`><TD`
`WIDTH="33%"`	`WIDTH="33%"`
`ALIGN="CENTER"`	`ALIGN="CENTER"`
`VALIGN="TOP"`	`VALIGN="TOP"`
`>13</TD`	`>13</TD`
`><TD`	`><TD`
`WIDTH="33%"`	`WIDTH="33%"`
`ALIGN="CENTER"`	`ALIGN="CENTER"`
`VALIGN="TOP"`	`VALIGN="TOP"`
`><TT`	`><TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>* / %</TT`	`>* / %</TT`
`></TD`	`></TD`
`><TD`	`><TD`
`WIDTH="33%"`	`WIDTH="33%"`
`ALIGN="CENTER"`	`ALIGN="CENTER"`
`VALIGN="TOP"`	`VALIGN="TOP"`
`>multiplicative arithmetic</TD`	`>multiplicative arithmetic</TD`
`></TR`	`></TR`
`><TR`	`><TR`
`><TD`	`><TD`
`WIDTH="33%"`	`WIDTH="33%"`
`ALIGN="CENTER"`	`ALIGN="CENTER"`
`VALIGN="TOP"`	`VALIGN="TOP"`
`>12</TD`	`>12</TD`
`><TD`	`><TD`
`WIDTH="33%"`	`WIDTH="33%"`
`ALIGN="CENTER"`	`ALIGN="CENTER"`
`VALIGN="TOP"`	`VALIGN="TOP"`
`><TT`	`><TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>+ - .</TT`	`>+ - .</TT`
`></TD`	`></TD`
`><TD`	`><TD`
`WIDTH="33%"`	`WIDTH="33%"`
`ALIGN="CENTER"`	`ALIGN="CENTER"`
`VALIGN="TOP"`	`VALIGN="TOP"`
`>additive arithmetic and string concatenation</TD`	`>additive arithmetic and string concatenation</TD`
`></TR`	`></TR`
`><TR`	`><TR`
`><TD`	`><TD`
`WIDTH="33%"`	`WIDTH="33%"`
`ALIGN="CENTER"`	`ALIGN="CENTER"`
`VALIGN="TOP"`	`VALIGN="TOP"`
`>11</TD`	`>11</TD`
`><TD`	`><TD`
`WIDTH="33%"`	`WIDTH="33%"`
`ALIGN="CENTER"`	`ALIGN="CENTER"`
`VALIGN="TOP"`	`VALIGN="TOP"`
`><TT`	`><TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`><< >></TT`	`><< >></TT`
`></TD`	`></TD`
`><TD`	`><TD`
`WIDTH="33%"`	`WIDTH="33%"`
`ALIGN="CENTER"`	`ALIGN="CENTER"`
`VALIGN="TOP"`	`VALIGN="TOP"`
`>bitwise shifts</TD`	`>bitwise shifts</TD`
`></TR`	`></TR`
`><TR`	`><TR`
`><TD`	`><TD`
`WIDTH="33%"`	`WIDTH="33%"`
`ALIGN="CENTER"`	`ALIGN="CENTER"`
`VALIGN="TOP"`	`VALIGN="TOP"`
`>10</TD`	`>10</TD`
`><TD`	`><TD`
`WIDTH="33%"`	`WIDTH="33%"`
`ALIGN="CENTER"`	`ALIGN="CENTER"`
`VALIGN="TOP"`	`VALIGN="TOP"`
`><TT`	`><TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`><= < > >=</TT`	`><= < > >=</TT`
`></TD`	`></TD`
`><TD`	`><TD`
`WIDTH="33%"`	`WIDTH="33%"`
`ALIGN="CENTER"`	`ALIGN="CENTER"`
`VALIGN="TOP"`	`VALIGN="TOP"`
`>inequality</TD`	`>inequality</TD`
`></TR`	`></TR`
`><TR`	`><TR`
`><TD`	`><TD`
`WIDTH="33%"`	`WIDTH="33%"`
`ALIGN="CENTER"`	`ALIGN="CENTER"`
`VALIGN="TOP"`	`VALIGN="TOP"`
`>9</TD`	`>9</TD`
`><TD`	`><TD`
`WIDTH="33%"`	`WIDTH="33%"`
`ALIGN="CENTER"`	`ALIGN="CENTER"`
`VALIGN="TOP"`	`VALIGN="TOP"`
`><TT`	`><TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>== !=</TT`	`>== !=</TT`
`></TD`	`></TD`
`><TD`	`><TD`
`WIDTH="33%"`	`WIDTH="33%"`
`ALIGN="CENTER"`	`ALIGN="CENTER"`
`VALIGN="TOP"`	`VALIGN="TOP"`
`>comparison</TD`	`>comparison</TD`
`></TR`	`></TR`
`><TR`	`><TR`
`><TD`	`><TD`
`WIDTH="33%"`	`WIDTH="33%"`
`ALIGN="CENTER"`	`ALIGN="CENTER"`
`VALIGN="TOP"`	`VALIGN="TOP"`
`>8</TD`	`>8</TD`
`><TD`	`><TD`
`WIDTH="33%"`	`WIDTH="33%"`
`ALIGN="CENTER"`	`ALIGN="CENTER"`
`VALIGN="TOP"`	`VALIGN="TOP"`
`><TT`	`><TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>&</TT`	`>&</TT`
`></TD`	`></TD`
`><TD`	`><TD`
`WIDTH="33%"`	`WIDTH="33%"`
`ALIGN="CENTER"`	`ALIGN="CENTER"`
`VALIGN="TOP"`	`VALIGN="TOP"`
`>bitwise and</TD`	`>bitwise and</TD`
`></TR`	`></TR`
`><TR`	`><TR`
`><TD`	`><TD`
`WIDTH="33%"`	`WIDTH="33%"`
`ALIGN="CENTER"`	`ALIGN="CENTER"`
`VALIGN="TOP"`	`VALIGN="TOP"`
`>7</TD`	`>7</TD`
`><TD`	`><TD`
`WIDTH="33%"`	`WIDTH="33%"`
`ALIGN="CENTER"`	`ALIGN="CENTER"`
`VALIGN="TOP"`	`VALIGN="TOP"`
`><TT`	`><TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>^</TT`	`>^</TT`
`></TD`	`></TD`
`><TD`	`><TD`
`WIDTH="33%"`	`WIDTH="33%"`
`ALIGN="CENTER"`	`ALIGN="CENTER"`
`VALIGN="TOP"`	`VALIGN="TOP"`
`>bitwise xor</TD`	`>bitwise xor</TD`
`></TR`	`></TR`
`><TR`	`><TR`
`><TD`	`><TD`
`WIDTH="33%"`	`WIDTH="33%"`
`ALIGN="CENTER"`	`ALIGN="CENTER"`
`VALIGN="TOP"`	`VALIGN="TOP"`
`>6</TD`	`>6</TD`
`><TD`	`><TD`
`WIDTH="33%"`	`WIDTH="33%"`
`ALIGN="CENTER"`	`ALIGN="CENTER"`
`VALIGN="TOP"`	`VALIGN="TOP"`
`><TT`	`><TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>\|</TT`	`>\|</TT`
`></TD`	`></TD`
`><TD`	`><TD`
`WIDTH="33%"`	`WIDTH="33%"`
`ALIGN="CENTER"`	`ALIGN="CENTER"`
`VALIGN="TOP"`	`VALIGN="TOP"`
`>bitwise or</TD`	`>bitwise or</TD`
`></TR`	`></TR`
`><TR`	`><TR`
`><TD`	`><TD`
`WIDTH="33%"`	`WIDTH="33%"`
`ALIGN="CENTER"`	`ALIGN="CENTER"`
`VALIGN="TOP"`	`VALIGN="TOP"`
`>5</TD`	`>5</TD`
`><TD`	`><TD`
`WIDTH="33%"`	`WIDTH="33%"`
`ALIGN="CENTER"`	`ALIGN="CENTER"`
`VALIGN="TOP"`	`VALIGN="TOP"`
`><TT`	`><TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>&&</TT`	`>&&</TT`
`></TD`	`></TD`
`><TD`	`><TD`
`WIDTH="33%"`	`WIDTH="33%"`
`ALIGN="CENTER"`	`ALIGN="CENTER"`
`VALIGN="TOP"`	`VALIGN="TOP"`
`>logical and</TD`	`>logical and</TD`
`></TR`	`></TR`
`><TR`	`><TR`
`><TD`	`><TD`
`WIDTH="33%"`	`WIDTH="33%"`
`ALIGN="CENTER"`	`ALIGN="CENTER"`
`VALIGN="TOP"`	`VALIGN="TOP"`
`>4</TD`	`>4</TD`
`><TD`	`><TD`
`WIDTH="33%"`	`WIDTH="33%"`
`ALIGN="CENTER"`	`ALIGN="CENTER"`
`VALIGN="TOP"`	`VALIGN="TOP"`
`><TT`	`><TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>\|\|</TT`	`>\|\|</TT`
`></TD`	`></TD`
`><TD`	`><TD`
`WIDTH="33%"`	`WIDTH="33%"`
`ALIGN="CENTER"`	`ALIGN="CENTER"`
`VALIGN="TOP"`	`VALIGN="TOP"`
`>logical or</TD`	`>logical or</TD`
`></TR`	`></TR`
`><TR`	`><TR`
`><TD`	`><TD`
`WIDTH="33%"`	`WIDTH="33%"`
`ALIGN="CENTER"`	`ALIGN="CENTER"`
`VALIGN="TOP"`	`VALIGN="TOP"`
`>3</TD`	`>3</TD`
`><TD`	`><TD`
`WIDTH="33%"`	`WIDTH="33%"`
`ALIGN="CENTER"`	`ALIGN="CENTER"`
`VALIGN="TOP"`	`VALIGN="TOP"`
`><TT`	`><TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>xor, eqv</TT`	`>xor, eqv</TT`
`></TD`	`></TD`
`><TD`	`><TD`
`WIDTH="33%"`	`WIDTH="33%"`
`ALIGN="CENTER"`	`ALIGN="CENTER"`
`VALIGN="TOP"`	`VALIGN="TOP"`
`>logical equivalance</TD`	`>logical equivalance</TD`
`></TR`	`></TR`
`><TR`	`><TR`
`><TD`	`><TD`
`WIDTH="33%"`	`WIDTH="33%"`
`ALIGN="CENTER"`	`ALIGN="CENTER"`
`VALIGN="TOP"`	`VALIGN="TOP"`
`>2</TD`	`>2</TD`
`><TD`	`><TD`
`WIDTH="33%"`	`WIDTH="33%"`
`ALIGN="CENTER"`	`ALIGN="CENTER"`
`VALIGN="TOP"`	`VALIGN="TOP"`
`><TT`	`><TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>implies</TT`	`>implies</TT`
`></TD`	`></TD`
`><TD`	`><TD`
`WIDTH="33%"`	`WIDTH="33%"`
`ALIGN="CENTER"`	`ALIGN="CENTER"`
`VALIGN="TOP"`	`VALIGN="TOP"`
`>logical implication</TD`	`>logical implication</TD`
`></TR`	`></TR`
`><TR`	`><TR`
`><TD`	`><TD`
`WIDTH="33%"`	`WIDTH="33%"`
`ALIGN="CENTER"`	`ALIGN="CENTER"`
`VALIGN="TOP"`	`VALIGN="TOP"`
`>1</TD`	`>1</TD`
`><TD`	`><TD`
`WIDTH="33%"`	`WIDTH="33%"`
`ALIGN="CENTER"`	`ALIGN="CENTER"`
`VALIGN="TOP"`	`VALIGN="TOP"`
`><TT`	`><TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>? :</TT`	`>? :</TT`
`></TD`	`></TD`
`><TD`	`><TD`
`WIDTH="33%"`	`WIDTH="33%"`
`ALIGN="CENTER"`	`ALIGN="CENTER"`
`VALIGN="TOP"`	`VALIGN="TOP"`
`>conditional</TD`	`>conditional</TD`
`></TR`	`></TR`
`></TBODY`	`></TBODY`
`></TABLE`	`></TABLE`
`><P`	`><P`
`></P`	`></P`
`></DIV`	`></DIV`
`><P`	`><P`
`>Function calls have the usual format of a name, an opening bracket,`	`>Function calls have the usual format of a name, an opening bracket,`
`one or more arguments separated by commas, and a closing bracket. For`	`one or more arguments separated by commas, and a closing bracket. For`
`example:</P`	`example:</P`
`><TABLE`	`><TABLE`
`BORDER="5"`	`BORDER="5"`
`BGCOLOR="#E0E0F0"`	`BGCOLOR="#E0E0F0"`
`WIDTH="70%"`	`WIDTH="70%"`
`><TR`	`><TR`
`><TD`	`><TD`
`><PRE`	`><PRE`
`CLASS="PROGRAMLISTING"`	`CLASS="PROGRAMLISTING"`
`> requires { !is_substr(CYGBLD_GLOBAL_CFLAGS, " -fno-rtti") }</PRE`	`> requires { !is_substr(CYGBLD_GLOBAL_CFLAGS, " -fno-rtti") }</PRE`
`></TD`	`></TD`
`></TR`	`></TR`
`></TABLE`	`></TABLE`
`><P`	`><P`
`>Functions will differ in the number of arguments and may impose`	`>Functions will differ in the number of arguments and may impose`
`restrictions on some or all of their arguments. For example it may be`	`restrictions on some or all of their arguments. For example it may be`
`necessary for the first argument to be a reference to a configuration`	`necessary for the first argument to be a reference to a configuration`
`option. The available functions are described in <A`	`option. The available functions are described in <A`
`HREF="language.values.html#LANGUAGE.FUNCTIONS"`	`HREF="language.values.html#LANGUAGE.FUNCTIONS"`
`>the Section called <I`	`>the Section called <I`
`>Functions</I`	`>Functions</I`
`></A`	`></A`
`>. </P`	`>. </P`
`><P`	`><P`
`>The logical <TT`	`>The logical <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>xor</TT`	`>xor</TT`
`> operator evaluates to true if`	`> operator evaluates to true if`
`either the left hand side or the right hand side but not both evaluate`	`either the left hand side or the right hand side but not both evaluate`
`to true The logical <TT`	`to true The logical <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>eqv</TT`	`>eqv</TT`
`> operator evaluates to true`	`> operator evaluates to true`
`if both the left and right hand sides evaluate to true, or if both`	`if both the left and right hand sides evaluate to true, or if both`
`evaluate to false. The <TT`	`evaluate to false. The <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>implies</TT`	`>implies</TT`
`> operator evaluates`	`> operator evaluates`
`to true either if the left hand side is false or if the right hand`	`to true either if the left hand side is false or if the right hand`
`side is true, in other words <TT`	`side is true, in other words <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>A implies B</TT`	`>A implies B</TT`
`>`	`>`
`has the same meaning as <TT`	`has the same meaning as <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>!A \|\| B</TT`	`>!A \|\| B</TT`
`>. An`	`>. An`
`example use would be:</P`	`example use would be:</P`
`><TABLE`	`><TABLE`
`BORDER="5"`	`BORDER="5"`
`BGCOLOR="#E0E0F0"`	`BGCOLOR="#E0E0F0"`
`WIDTH="70%"`	`WIDTH="70%"`
`><TR`	`><TR`
`><TD`	`><TD`
`><PRE`	`><PRE`
`CLASS="PROGRAMLISTING"`	`CLASS="PROGRAMLISTING"`
`> requires { is_active(CYGNUM_LIBC_MAIN_DEFAULT_STACK_SIZE) implies`	`> requires { is_active(CYGNUM_LIBC_MAIN_DEFAULT_STACK_SIZE) implies`
`(CYGNUM_LIBC_MAIN_DEFAULT_STACK_SIZE >= (16 * 1024)) }</PRE`	`(CYGNUM_LIBC_MAIN_DEFAULT_STACK_SIZE >= (16 * 1024)) }</PRE`
`></TD`	`></TD`
`></TR`	`></TR`
`></TABLE`	`></TABLE`
`><P`	`><P`
`>This constraint would be satisfied if either the support for a main`	`>This constraint would be satisfied if either the support for a main`
`stack size is disabled, or if that stack is at least 16K. However if`	`stack size is disabled, or if that stack is at least 16K. However if`
`such a stack were in use but was too small, a conflict would be raised.</P`	`such a stack were in use but was too small, a conflict would be raised.</P`
`><P`	`><P`
`>A valid <SPAN`	`>A valid <SPAN`
`CLASS="APPLICATION"`	`CLASS="APPLICATION"`
`>CDL</SPAN`	`>CDL</SPAN`
`> identifier in an expression, for example`	`> identifier in an expression, for example`
`<TT`	`<TT`
`CLASS="VARNAME"`	`CLASS="VARNAME"`
`>CYGGLO_SPEED</TT`	`>CYGGLO_SPEED</TT`
`>, will be interpreted as a reference to`	`>, will be interpreted as a reference to`
`a configuration option by that name. The option does not have to be`	`a configuration option by that name. The option does not have to be`
`loaded into the current configuration. When the component framework`	`loaded into the current configuration. When the component framework`
`evaluates the expression it will substitute in a suitable value that`	`evaluates the expression it will substitute in a suitable value that`
`depends on whether or not the option is loaded, active, and enabled.`	`depends on whether or not the option is loaded, active, and enabled.`
`The exact rules are described in <A`	`The exact rules are described in <A`
`HREF="language.values.html#LANGUAGE.VALUES.VALUE"`	`HREF="language.values.html#LANGUAGE.VALUES.VALUE"`
`>the Section called <I`	`>the Section called <I`
`>Option Values</I`	`>Option Values</I`
`></A`	`></A`
`>.</P`	`>.</P`
`><P`	`><P`
`>A constant string is any sequence of characters enclosed in quotes.`	`>A constant string is any sequence of characters enclosed in quotes.`
`Care has to be taken that these quotes are not stripped off by the`	`Care has to be taken that these quotes are not stripped off by the`
`<SPAN`	`<SPAN`
`CLASS="APPLICATION"`	`CLASS="APPLICATION"`
`>Tcl</SPAN`	`>Tcl</SPAN`
`> interpreter before the <SPAN`	`> interpreter before the <SPAN`
`CLASS="APPLICATION"`	`CLASS="APPLICATION"`
`>CDL</SPAN`	`>CDL</SPAN`
`> expression parser sees them.`	`> expression parser sees them.`
`Consider the following:</P`	`Consider the following:</P`
`><TABLE`	`><TABLE`
`BORDER="5"`	`BORDER="5"`
`BGCOLOR="#E0E0F0"`	`BGCOLOR="#E0E0F0"`
`WIDTH="70%"`	`WIDTH="70%"`
`><TR`	`><TR`
`><TD`	`><TD`
`><PRE`	`><PRE`
`CLASS="PROGRAMLISTING"`	`CLASS="PROGRAMLISTING"`
`> default_value "RAM"</PRE`	`> default_value "RAM"</PRE`
`></TD`	`></TD`
`></TR`	`></TR`
`></TABLE`	`></TABLE`
`><P`	`><P`
`>The quote marks will be stripped before the <SPAN`	`>The quote marks will be stripped before the <SPAN`
`CLASS="APPLICATION"`	`CLASS="APPLICATION"`
`>CDL</SPAN`	`>CDL</SPAN`
`> expression parser`	`> expression parser`
`sees the data, so the expression will be interpreted as a reference to`	`sees the data, so the expression will be interpreted as a reference to`
`a configuration option <TT`	`a configuration option <TT`
`CLASS="VARNAME"`	`CLASS="VARNAME"`
`>RAM</TT`	`>RAM</TT`
`>. There is unlikely to be`	`>. There is unlikely to be`
`such an option, so the actual default value will be`	`such an option, so the actual default value will be`
`<TT`	`<TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>0</TT`	`>0</TT`
`>. Careful use of braces or other <SPAN`	`>. Careful use of braces or other <SPAN`
`CLASS="APPLICATION"`	`CLASS="APPLICATION"`
`>Tcl</SPAN`	`>Tcl</SPAN`
`> quoting`	`> quoting`
`mechanisms can be used to avoid such problems.</P`	`mechanisms can be used to avoid such problems.</P`
`><P`	`><P`
`>`	`>`
`String constants consist of the data inside the quotes. If the data`	`String constants consist of the data inside the quotes. If the data`
`itself needs to contain quote characters then appropriate quoting is`	`itself needs to contain quote characters then appropriate quoting is`
`again necessary, for example:</P`	`again necessary, for example:</P`
`><TABLE`	`><TABLE`
`BORDER="5"`	`BORDER="5"`
`BGCOLOR="#E0E0F0"`	`BGCOLOR="#E0E0F0"`
`WIDTH="70%"`	`WIDTH="70%"`
`><TR`	`><TR`
`><TD`	`><TD`
`><PRE`	`><PRE`
`CLASS="PROGRAMLISTING"`	`CLASS="PROGRAMLISTING"`
`> default_value { "\"/dev/ser0\"" }</PRE`	`> default_value { "\"/dev/ser0\"" }</PRE`
`></TD`	`></TD`
`></TR`	`></TR`
`></TABLE`	`></TABLE`
`><P`	`><P`
`>An integer constant consists of a sequence of digits, optionally`	`>An integer constant consists of a sequence of digits, optionally`
`preceeded with the unary <TT`	`preceeded with the unary <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>+</TT`	`>+</TT`
`> or <TT`	`> or <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>-</TT`	`>-</TT`
`>`	`>`
`operators. As usual the sequence <TT`	`operators. As usual the sequence <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>0x</TT`	`>0x</TT`
`> or`	`> or`
`<TT`	`<TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>0X</TT`	`>0X</TT`
`> can be used for hexadecimal data, and a leading`	`> can be used for hexadecimal data, and a leading`
`<TT`	`<TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>0</TT`	`>0</TT`
`> indicates octal data. Internally the component`	`> indicates octal data. Internally the component`
`framework uses 64-bit arithmetic for integer data. If a constant is`	`framework uses 64-bit arithmetic for integer data. If a constant is`
`too large then double precision arithmetic will be used instead.`	`too large then double precision arithmetic will be used instead.`
`Traditional syntax is also used for double precision numbers, for`	`Traditional syntax is also used for double precision numbers, for`
`example <TT`	`example <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>3.141592</TT`	`>3.141592</TT`
`> or <TT`	`> or <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>-3E6</TT`	`>-3E6</TT`
`>. </P`	`>. </P`
`><P`	`><P`
`>Of course this is not completely accurate: <SPAN`	`>Of course this is not completely accurate: <SPAN`
`CLASS="APPLICATION"`	`CLASS="APPLICATION"`
`>CDL</SPAN`	`>CDL</SPAN`
`> is not a typed`	`> is not a typed`
`language, all data is treated as if it were a string. For example the`	`language, all data is treated as if it were a string. For example the`
`following two lines are equivalent:</P`	`following two lines are equivalent:</P`
`><TABLE`	`><TABLE`
`BORDER="5"`	`BORDER="5"`
`BGCOLOR="#E0E0F0"`	`BGCOLOR="#E0E0F0"`
`WIDTH="70%"`	`WIDTH="70%"`
`><TR`	`><TR`
`><TD`	`><TD`
`><PRE`	`><PRE`
`CLASS="PROGRAMLISTING"`	`CLASS="PROGRAMLISTING"`
`> requires CYGNUM_UITRON_SEMAS > 10`	`> requires CYGNUM_UITRON_SEMAS > 10`
`requires { CYGNUM_UITRON_SEMAS > "10" }</PRE`	`requires { CYGNUM_UITRON_SEMAS > "10" }</PRE`
`></TD`	`></TD`
`></TR`	`></TR`
`></TABLE`	`></TABLE`
`><P`	`><P`
`>When an expression gets evaluated the operators will attempt`	`>When an expression gets evaluated the operators will attempt`
`appropriate conversions. The <TT`	`appropriate conversions. The <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>></TT`	`>></TT`
`> comparison`	`> comparison`
`operator can be used on either integer or double precision numbers, so`	`operator can be used on either integer or double precision numbers, so`
`it will begin by attempting a string to integer conversion of both`	`it will begin by attempting a string to integer conversion of both`
`operands. If that fails it will attempt string to double conversions.`	`operands. If that fails it will attempt string to double conversions.`
`If that fails as well then the component framework will report a`	`If that fails as well then the component framework will report a`
`conflict, an evaluation exception. If the conversions from string to`	`conflict, an evaluation exception. If the conversions from string to`
`integer are successful then the result will be either the string`	`integer are successful then the result will be either the string`
`<TT`	`<TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>0</TT`	`>0</TT`
`> or the string <TT`	`> or the string <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>1</TT`	`>1</TT`
`>, both of which`	`>, both of which`
`can be converted to integers or doubles as required.</P`	`can be converted to integers or doubles as required.</P`
`><P`	`><P`
`>It is worth noting that the expression`	`>It is worth noting that the expression`
`<TT`	`<TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>CYGNUM_UITRON_SEMAS >10</TT`	`>CYGNUM_UITRON_SEMAS >10</TT`
`> is not ambiguous.`	`> is not ambiguous.`
`<SPAN`	`<SPAN`
`CLASS="APPLICATION"`	`CLASS="APPLICATION"`
`>CDL</SPAN`	`>CDL</SPAN`
`> identifiers can never begin with a digit, so it is not possible`	`> identifiers can never begin with a digit, so it is not possible`
`for <TT`	`for <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>10</TT`	`>10</TT`
`> to be misinterpreted as a reference to an`	`> to be misinterpreted as a reference to an`
`identifier instead of as a string.</P`	`identifier instead of as a string.</P`
`><P`	`><P`
`>Of course the implementation is slightly different again. The <SPAN`	`>Of course the implementation is slightly different again. The <SPAN`
`CLASS="APPLICATION"`	`CLASS="APPLICATION"`
`>CDL</SPAN`	`>CDL</SPAN`
`>`	`>`
`language definition is such that all data is treated as if it were a`	`language definition is such that all data is treated as if it were a`
`string, with conversions to integer, double or boolean as and when`	`string, with conversions to integer, double or boolean as and when`
`required. The implementation is allowed to avoid conversions until`	`required. The implementation is allowed to avoid conversions until`
`they are necessary. For example, given`	`they are necessary. For example, given`
`<TT`	`<TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>CYGNUM_UITRON_SEMAS > 10</TT`	`>CYGNUM_UITRON_SEMAS > 10</TT`
`> the`	`> the`
`expression parsing code will perform an immediate conversion from`	`expression parsing code will perform an immediate conversion from`
`string to integer, storing the integer representation, and there is no`	`string to integer, storing the integer representation, and there is no`
`need for a conversion by the comparison operator when the expression`	`need for a conversion by the comparison operator when the expression`
`gets evaluated. Given`	`gets evaluated. Given`
`<TT`	`<TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>{ CYGNUM_UITRON_SEMAS > "10" }</TT`	`>{ CYGNUM_UITRON_SEMAS > "10" }</TT`
`>`	`>`
`the parsing code will store the string representation and a conversion`	`the parsing code will store the string representation and a conversion`
`happens the first time the expression is evaluated. All of this is an`	`happens the first time the expression is evaluated. All of this is an`
`implementation detail, and does not affect the semantics of the`	`implementation detail, and does not affect the semantics of the`
`language. </P`	`language. </P`
`><P`	`><P`
`>Different operators have different requirements, for example the`	`>Different operators have different requirements, for example the`
`bitwise or operator only makes sense if both operands have an integer`	`bitwise or operator only makes sense if both operands have an integer`
`representation. For operators which can work with either integer or`	`representation. For operators which can work with either integer or`
`double precision numbers, integer arithmetic will be preferred.</P`	`double precision numbers, integer arithmetic will be preferred.</P`
`><P`	`><P`
`>The following operators only accept integer operands:`	`>The following operators only accept integer operands:`
`unary <TT`	`unary <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>~</TT`	`>~</TT`
`> (bitwise not), the shift operators`	`> (bitwise not), the shift operators`
`<TT`	`<TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`><<</TT`	`><<</TT`
`> and <TT`	`> and <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>>></TT`	`>>></TT`
`>, and the`	`>, and the`
`bitwise operators <TT`	`bitwise operators <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>&</TT`	`>&</TT`
`>, <TT`	`>, <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>\|</TT`	`>\|</TT`
`> and`	`> and`
`<TT`	`<TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>^</TT`	`>^</TT`
`>.</P`	`>.</P`
`><P`	`><P`
`>The following operators will attempt integer arithmetic first, then`	`>The following operators will attempt integer arithmetic first, then`
`double precision arithmetic: unary <TT`	`double precision arithmetic: unary <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>-</TT`	`>-</TT`
`>,`	`>,`
`the arithmetic operators <TT`	`the arithmetic operators <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>+</TT`	`>+</TT`
`>, <TT`	`>, <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>-</TT`	`>-</TT`
`>,`	`>,`
`<TT`	`<TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>*</TT`	`>*</TT`
`>, <TT`	`>, <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>/</TT`	`>/</TT`
`>, and <TT`	`>, and <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>%</TT`	`>%</TT`
`>;`	`>;`
`and the comparision operators <TT`	`and the comparision operators <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`><</TT`	`><</TT`
`>,`	`>,`
`<TT`	`<TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`><=</TT`	`><=</TT`
`>, <TT`	`>, <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>></TT`	`>></TT`
`> and`	`> and`
`<TT`	`<TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>>=</TT`	`>>=</TT`
`>. </P`	`>. </P`
`><P`	`><P`
`>The equality <TT`	`>The equality <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>==</TT`	`>==</TT`
`> and inequality`	`> and inequality`
`<TT`	`<TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>!=</TT`	`>!=</TT`
`> operators will first attempt integer conversion`	`> operators will first attempt integer conversion`
`and comparison. If that fails then double precision will be attempted`	`and comparison. If that fails then double precision will be attempted`
`(although arguably using these operators on double precision data is`	`(although arguably using these operators on double precision data is`
`not sensible). As a last resort string comparison will be used.</P`	`not sensible). As a last resort string comparison will be used.</P`
`><P`	`><P`
`>The operators <TT`	`>The operators <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>!</TT`	`>!</TT`
`>, <TT`	`>, <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>&&</TT`	`>&&</TT`
`> and`	`> and`
`<TT`	`<TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>\|\|</TT`	`>\|\|</TT`
`> all work with boolean data. Any string that can`	`> all work with boolean data. Any string that can`
`be converted to the integer <TT`	`be converted to the integer <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>0</TT`	`>0</TT`
`> or the double`	`> or the double`
`<TT`	`<TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>0.0</TT`	`>0.0</TT`
`> is treated as false, as is the empty string or`	`> is treated as false, as is the empty string or`
`the constant string <TT`	`the constant string <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>false</TT`	`>false</TT`
`>. Anything else is`	`>. Anything else is`
`interpreted as true. The result is either <TT`	`interpreted as true. The result is either <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>0</TT`	`>0</TT`
`> or`	`> or`
`<TT`	`<TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>1</TT`	`>1</TT`
`>.</P`	`>.</P`
`><P`	`><P`
`>The conditional operator <TT`	`>The conditional operator <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>? :</TT`	`>? :</TT`
`> will interpret`	`> will interpret`
`its first operand as a boolean. It does not perform any processing on`	`its first operand as a boolean. It does not perform any processing on`
`the second or third operands.</P`	`the second or third operands.</P`
`><P`	`><P`
`>In practice it is rarely necessary to worry about any of these`	`>In practice it is rarely necessary to worry about any of these`
`details. In nearly every case <SPAN`	`details. In nearly every case <SPAN`
`CLASS="APPLICATION"`	`CLASS="APPLICATION"`
`>CDL</SPAN`	`>CDL</SPAN`
`> expressions just work as expected,`	`> expressions just work as expected,`
`and there is no need to understand the full details.</P`	`and there is no need to understand the full details.</P`
`><DIV`	`><DIV`
`CLASS="NOTE"`	`CLASS="NOTE"`
`><BLOCKQUOTE`	`><BLOCKQUOTE`
`CLASS="NOTE"`	`CLASS="NOTE"`
`><P`	`><P`
`><B`	`><B`
`>Note: </B`	`>Note: </B`
`>The current expression syntax does not meet all the needs of component`	`>The current expression syntax does not meet all the needs of component`
`writers. Some future enhancements will definitely be made, others are`	`writers. Some future enhancements will definitely be made, others are`
`more controversial. The list includes the following:</P`	`more controversial. The list includes the following:</P`
`><P`	`><P`
`></P`	`></P`
`><OL`	`><OL`
`TYPE="1"`	`TYPE="1"`
`><LI`	`><LI`
`><P`	`><P`
`>An option's value is determined by several different factors: whether`	`>An option's value is determined by several different factors: whether`
`or not it is loaded, whether or not it is active, whether or not it is`	`or not it is loaded, whether or not it is active, whether or not it is`
`enabled, and the data part. Currently there is no way of querying`	`enabled, and the data part. Currently there is no way of querying`
`these individually. This is very significant in the context of options`	`these individually. This is very significant in the context of options`
`with the <TT`	`with the <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>bool</TT`	`>bool</TT`
`> or <TT`	`> or <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>booldata</TT`	`>booldata</TT`
`>`	`>`
`flavors, because there is no way of distinguishing between the option`	`flavors, because there is no way of distinguishing between the option`
`being absent/inactive/disabled or it being enabled with a data field`	`being absent/inactive/disabled or it being enabled with a data field`
`of <TT`	`of <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>0</TT`	`>0</TT`
`>. There should be unary operators that allow`	`>. There should be unary operators that allow`
`any of the factors to be checked.</P`	`any of the factors to be checked.</P`
`></LI`	`></LI`
`><LI`	`><LI`
`><P`	`><P`
`>Only the <TT`	`>Only the <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>==</TT`	`>==</TT`
`> and <TT`	`> and <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>!=</TT`	`>!=</TT`
`> operators can`	`> operators can`
`be used for string data. More string-related facilities are needed.</P`	`be used for string data. More string-related facilities are needed.</P`
`></LI`	`></LI`
`><LI`	`><LI`
`><P`	`><P`
`>An implies operator would be useful for many goal expression, where`	`>An implies operator would be useful for many goal expression, where`
`<TT`	`<TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>A implies B</TT`	`>A implies B</TT`
`> is equivalent to`	`> is equivalent to`
`<TT`	`<TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>!A \|\|B</TT`	`>!A \|\|B</TT`
`>.</P`	`>.</P`
`></LI`	`></LI`
`><LI`	`><LI`
`><P`	`><P`
`>Similarly there is inadequate support for lists. On occasion it would`	`>Similarly there is inadequate support for lists. On occasion it would`
`be useful to write expressions involving say the list of implementors`	`be useful to write expressions involving say the list of implementors`
`of a given CDL interface, for example a sensible default value could`	`of a given CDL interface, for example a sensible default value could`
`be the first implementor. Associated with this is a need for an`	`be the first implementor. Associated with this is a need for an`
`indirection operator.</P`	`indirection operator.</P`
`></LI`	`></LI`
`><LI`	`><LI`
`><P`	`><P`
`>Arguably extending the basic <SPAN`	`>Arguably extending the basic <SPAN`
`CLASS="APPLICATION"`	`CLASS="APPLICATION"`
`>CDL</SPAN`	`>CDL</SPAN`
`> expression syntax with lots of new`	`> expression syntax with lots of new`
`operators is unnecessary, instead expressions should just support`	`operators is unnecessary, instead expressions should just support`
`<SPAN`	`<SPAN`
`CLASS="APPLICATION"`	`CLASS="APPLICATION"`
`>Tcl</SPAN`	`>Tcl</SPAN`
`> command substitution and then component writers could escape`	`> command substitution and then component writers could escape`
`into <SPAN`	`into <SPAN`
`CLASS="APPLICATION"`	`CLASS="APPLICATION"`
`>Tcl</SPAN`	`>Tcl</SPAN`
`> scripts for complicated operations. This has some major`	`> scripts for complicated operations. This has some major`
`disadvantages. First, the inference engine would no longer have any`	`disadvantages. First, the inference engine would no longer have any`
`sensible way of interpreting an expression to resolve a conflict.`	`sensible way of interpreting an expression to resolve a conflict.`
`Second, the component framework's value propagation code keeps track`	`Second, the component framework's value propagation code keeps track`
`of which options get referenced in which expressions and avoids`	`of which options get referenced in which expressions and avoids`
`unnecessary re-evaluation of expressions; if expressions can involve`	`unnecessary re-evaluation of expressions; if expressions can involve`
`arbitrary <SPAN`	`arbitrary <SPAN`
`CLASS="APPLICATION"`	`CLASS="APPLICATION"`
`>Tcl</SPAN`	`>Tcl</SPAN`
`> code then there is no simple way to eliminate`	`> code then there is no simple way to eliminate`
`unnecessary recalculations, with a potentially major impact on`	`unnecessary recalculations, with a potentially major impact on`
`performance.</P`	`performance.</P`
`></LI`	`></LI`
`></OL`	`></OL`
`></BLOCKQUOTE`	`></BLOCKQUOTE`
`></DIV`	`></DIV`
`><DIV`	`><DIV`
`CLASS="NOTE"`	`CLASS="NOTE"`
`><BLOCKQUOTE`	`><BLOCKQUOTE`
`CLASS="NOTE"`	`CLASS="NOTE"`
`><P`	`><P`
`><B`	`><B`
`>Note: </B`	`>Note: </B`
`>The current implementation of the component framework uses 64 bit`	`>The current implementation of the component framework uses 64 bit`
`arithmetic on all host platforms. Although this is adequate for`	`arithmetic on all host platforms. Although this is adequate for`
`current target architectures, it may cause problems in future. At some`	`current target architectures, it may cause problems in future. At some`
`stage it is likely that an arbitrary precision integer arithmetic`	`stage it is likely that an arbitrary precision integer arithmetic`
`package will be used instead.</P`	`package will be used instead.</P`
`></BLOCKQUOTE`	`></BLOCKQUOTE`
`></DIV`	`></DIV`
`></DIV`	`></DIV`
`><DIV`	`><DIV`
`CLASS="SECT2"`	`CLASS="SECT2"`
`><H2`	`><H2`
`CLASS="SECT2"`	`CLASS="SECT2"`
`><A`	`><A`
`NAME="LANGUAGE.FUNCTIONS">Functions</H2`	`NAME="LANGUAGE.FUNCTIONS">Functions</H2`
`><P`	`><P`
`>CDL expressions can contain calls to a set of built-in functions`	`>CDL expressions can contain calls to a set of built-in functions`
`using the usual syntax, for example;</P`	`using the usual syntax, for example;</P`
`><TABLE`	`><TABLE`
`BORDER="5"`	`BORDER="5"`
`BGCOLOR="#E0E0F0"`	`BGCOLOR="#E0E0F0"`
`WIDTH="70%"`	`WIDTH="70%"`
`><TR`	`><TR`
`><TD`	`><TD`
`><PRE`	`><PRE`
`CLASS="PROGRAMLISTING"`	`CLASS="PROGRAMLISTING"`
`> requires { !is_substr(CYGBLD_GLOBAL_CFLAGS, "-fno-rtti") }</PRE`	`> requires { !is_substr(CYGBLD_GLOBAL_CFLAGS, "-fno-rtti") }</PRE`
`></TD`	`></TD`
`></TR`	`></TR`
`></TABLE`	`></TABLE`
`><P`	`><P`
`>The available function calls are as follows:</P`	`>The available function calls are as follows:</P`
`><P`	`><P`
`></P`	`></P`
`><DIV`	`><DIV`
`CLASS="VARIABLELIST"`	`CLASS="VARIABLELIST"`
`><DL`	`><DL`
`><DT`	`><DT`
`><TT`	`><TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>get_data(option)</TT`	`>get_data(option)</TT`
`></DT`	`></DT`
`><DD`	`><DD`
`><P`	`><P`
`>This function can be used to obtain just the data part of a loaded`	`>This function can be used to obtain just the data part of a loaded`
`configuration option, ignoring other factors such as whether or not`	`configuration option, ignoring other factors such as whether or not`
`the option is active and enabled. It takes a single argument which`	`the option is active and enabled. It takes a single argument which`
`should be the name of a configuration option. If the specified option`	`should be the name of a configuration option. If the specified option`
`is not loaded in the current configuration then the function returns`	`is not loaded in the current configuration then the function returns`
`0, otherwise it returns the data part. Typically this function will`	`0, otherwise it returns the data part. Typically this function will`
`only be used in conjunction with <TT`	`only be used in conjunction with <TT`
`CLASS="FUNCTION"`	`CLASS="FUNCTION"`
`>is_active</TT`	`>is_active</TT`
`> and`	`> and`
`<TT`	`<TT`
`CLASS="FUNCTION"`	`CLASS="FUNCTION"`
`>is_enabled</TT`	`>is_enabled</TT`
`> for fine-grained control over the`	`> for fine-grained control over the`
`various factors that make up an option's value.</P`	`various factors that make up an option's value.</P`
`></DD`	`></DD`
`><DT`	`><DT`
`><TT`	`><TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>is_active(option)</TT`	`>is_active(option)</TT`
`></DT`	`></DT`
`><DD`	`><DD`
`><P`	`><P`
`>This function can be used to determine whether or not a particular`	`>This function can be used to determine whether or not a particular`
`configuration option is active. It takes a single argument which`	`configuration option is active. It takes a single argument which`
`should be the name of an option, and returns a boolean. If the`	`should be the name of an option, and returns a boolean. If the`
`specified option is not loaded then the function will return false.`	`specified option is not loaded then the function will return false.`
`Otherwise it will consider the state of the option's parents and`	`Otherwise it will consider the state of the option's parents and`
`evaluate any <SPAN`	`evaluate any <SPAN`
`CLASS="PROPERTY"`	`CLASS="PROPERTY"`
`>active_if</SPAN`	`>active_if</SPAN`
`> properties, and return the option's current`	`> properties, and return the option's current`
`active state. A typical use might be:</P`	`active state. A typical use might be:</P`
`><TABLE`	`><TABLE`
`BORDER="5"`	`BORDER="5"`
`BGCOLOR="#E0E0F0"`	`BGCOLOR="#E0E0F0"`
`WIDTH="70%"`	`WIDTH="70%"`
`><TR`	`><TR`
`><TD`	`><TD`
`><PRE`	`><PRE`
`CLASS="PROGRAMLISTING"`	`CLASS="PROGRAMLISTING"`
`> requires { is_active(CYGNUM_LIBC_MAIN_DEFAULT_STACK_SIZE) implies`	`> requires { is_active(CYGNUM_LIBC_MAIN_DEFAULT_STACK_SIZE) implies`
`(CYGNUM_LIBC_MAIN_DEFAULT_STACK_SIZE >= (16 * 1024)) }</PRE`	`(CYGNUM_LIBC_MAIN_DEFAULT_STACK_SIZE >= (16 * 1024)) }</PRE`
`></TD`	`></TD`
`></TR`	`></TR`
`></TABLE`	`></TABLE`
`><P`	`><P`
`>In other words either the specified configuration option must be`	`>In other words either the specified configuration option must be`
`inactive, for example because the current application does not use`	`inactive, for example because the current application does not use`
`any related C library or POSIX functionality, or the stack size must`	`any related C library or POSIX functionality, or the stack size must`
`be at least 16K.</P`	`be at least 16K.</P`
`><P`	`><P`
`>The configuration system's inference engine can attempt to satisfy`	`>The configuration system's inference engine can attempt to satisfy`
`constraints involving <TT`	`constraints involving <TT`
`CLASS="FUNCTION"`	`CLASS="FUNCTION"`
`>is_active</TT`	`>is_active</TT`
`> in various`	`> in various`
`different ways, for example by enabling or disabling parent`	`different ways, for example by enabling or disabling parent`
`components, or by examining <SPAN`	`components, or by examining <SPAN`
`CLASS="PROPERTY"`	`CLASS="PROPERTY"`
`>active_if</SPAN`	`>active_if</SPAN`
`> properties and manipulating`	`> properties and manipulating`
`terms in the associated expressions.</P`	`terms in the associated expressions.</P`
`></DD`	`></DD`
`><DT`	`><DT`
`><TT`	`><TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>is_enabled(option)</TT`	`>is_enabled(option)</TT`
`></DT`	`></DT`
`><DD`	`><DD`
`><P`	`><P`
`>This function can be used to determine whether or not a particular`	`>This function can be used to determine whether or not a particular`
`configuration option is enabled. It takes a single argument which`	`configuration option is enabled. It takes a single argument which`
`should be the name of an option, and returns a boolean. If the`	`should be the name of an option, and returns a boolean. If the`
`specified option is not loaded then the function will return false.`	`specified option is not loaded then the function will return false.`
`Otherwise it will return the current boolean part of the option's`	`Otherwise it will return the current boolean part of the option's`
`value. The option's active or inactive state is ignored. Typically`	`value. The option's active or inactive state is ignored. Typically`
`this function will be used in conjunction with`	`this function will be used in conjunction with`
`<TT`	`<TT`
`CLASS="FUNCTION"`	`CLASS="FUNCTION"`
`>is_active</TT`	`>is_active</TT`
`> and possibly`	`> and possibly`
`<TT`	`<TT`
`CLASS="FUNCTION"`	`CLASS="FUNCTION"`
`>get_data</TT`	`>get_data</TT`
`> to provide fine-grained control over the`	`> to provide fine-grained control over the`
`various factors that make up an option's value.</P`	`various factors that make up an option's value.</P`
`></DD`	`></DD`
`><DT`	`><DT`
`><TT`	`><TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>is_loaded(option)</TT`	`>is_loaded(option)</TT`
`></DT`	`></DT`
`><DD`	`><DD`
`><P`	`><P`
`>This function can be used to determine whether or not a particular`	`>This function can be used to determine whether or not a particular`
`configuration option is loaded. It takes a single argument which`	`configuration option is loaded. It takes a single argument which`
`should be the name of an option, and returns a boolean. If the`	`should be the name of an option, and returns a boolean. If the`
`argument is a package then the <TT`	`argument is a package then the <TT`
`CLASS="FUNCTION"`	`CLASS="FUNCTION"`
`>is_loaded</TT`	`>is_loaded</TT`
`> function`	`> function`
`provides little or no extra information, for example the following two`	`provides little or no extra information, for example the following two`
`constraints are usually equivalent:</P`	`constraints are usually equivalent:</P`
`><TABLE`	`><TABLE`
`BORDER="5"`	`BORDER="5"`
`BGCOLOR="#E0E0F0"`	`BGCOLOR="#E0E0F0"`
`WIDTH="70%"`	`WIDTH="70%"`
`><TR`	`><TR`
`><TD`	`><TD`
`><PRE`	`><PRE`
`CLASS="PROGRAMLISTING"`	`CLASS="PROGRAMLISTING"`
`> requires { CYGPKG_KERNEL }`	`> requires { CYGPKG_KERNEL }`
`requires { is_loaded(CYGPKG_KERNEL) }</PRE`	`requires { is_loaded(CYGPKG_KERNEL) }</PRE`
`></TD`	`></TD`
`></TR`	`></TR`
`></TABLE`	`></TABLE`
`><P`	`><P`
`>However if the specified package is loaded but re-parented below a`	`>However if the specified package is loaded but re-parented below a`
`disabled component, or inactive as a result of an <SPAN`	`disabled component, or inactive as a result of an <SPAN`
`CLASS="PROPERTY"`	`CLASS="PROPERTY"`
`>active_if</SPAN`	`>active_if</SPAN`
`>`	`>`
`property, then the first constraint would not be satisfied but the`	`property, then the first constraint would not be satisfied but the`
`second constraint would. In other words the`	`second constraint would. In other words the`
`<TT`	`<TT`
`CLASS="FUNCTION"`	`CLASS="FUNCTION"`
`>is_loaded</TT`	`>is_loaded</TT`
`> makes it possible to consider in`	`> makes it possible to consider in`
`isolation one of the factors that are considered when CDL expressions`	`isolation one of the factors that are considered when CDL expressions`
`are evaluated.</P`	`are evaluated.</P`
`><P`	`><P`
`>The configuration system's inference engine will not automatically`	`>The configuration system's inference engine will not automatically`
`load or unload packages to satisfy <TT`	`load or unload packages to satisfy <TT`
`CLASS="FUNCTION"`	`CLASS="FUNCTION"`
`>is_loaded</TT`	`>is_loaded</TT`
`>`	`>`
`constraints. </P`	`constraints. </P`
`></DD`	`></DD`
`><DT`	`><DT`
`><TT`	`><TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>is_substr(haystack, needle)</TT`	`>is_substr(haystack, needle)</TT`
`></DT`	`></DT`
`><DD`	`><DD`
`><P`	`><P`
`>This can be used to check whether or not a particular string is`	`>This can be used to check whether or not a particular string is`
`present in another string. It is used mainly for manipulating compiler`	`present in another string. It is used mainly for manipulating compiler`
`flags. The function takes two arguments, both of which can be`	`flags. The function takes two arguments, both of which can be`
`arbitrary expressions, and returns a boolean.</P`	`arbitrary expressions, and returns a boolean.</P`
`><P`	`><P`
`><TT`	`><TT`
`CLASS="FUNCTION"`	`CLASS="FUNCTION"`
`>is_substr</TT`	`>is_substr</TT`
`> has some understanding of word`	`> has some understanding of word`
`boundaries. If the second argument starts with a space character then`	`boundaries. If the second argument starts with a space character then`
`that will match either a real space or the start of the string.`	`that will match either a real space or the start of the string.`
`Similarly if the second argument ends with a space character then that`	`Similarly if the second argument ends with a space character then that`
`will match a real space or the end of the string. For example, all of`	`will match a real space or the end of the string. For example, all of`
`the following conditions are satisfied:</P`	`the following conditions are satisfied:</P`
`><TABLE`	`><TABLE`
`BORDER="5"`	`BORDER="5"`
`BGCOLOR="#E0E0F0"`	`BGCOLOR="#E0E0F0"`
`WIDTH="70%"`	`WIDTH="70%"`
`><TR`	`><TR`
`><TD`	`><TD`
`><PRE`	`><PRE`
`CLASS="PROGRAMLISTING"`	`CLASS="PROGRAMLISTING"`
`> is_substr("abracadabra", "abra")`	`> is_substr("abracadabra", "abra")`
`is_substr("abracadabra", " abra")`	`is_substr("abracadabra", " abra")`
`is_substr("hocus pocus", " pocus")`	`is_substr("hocus pocus", " pocus")`
`is_substr("abracadabra", "abra ")</PRE`	`is_substr("abracadabra", "abra ")</PRE`
`></TD`	`></TD`
`></TR`	`></TR`
`></TABLE`	`></TABLE`
`><P`	`><P`
`>The first is an exact match. The second is a match because the leading`	`>The first is an exact match. The second is a match because the leading`
`space matches the start of the string. The third is an exact match,`	`space matches the start of the string. The third is an exact match,`
`with the leading space matching an actual space. The fourth is a match`	`with the leading space matching an actual space. The fourth is a match`
`because the trailing space matches the end of the string. However, the`	`because the trailing space matches the end of the string. However, the`
`following condition is not satisfied.</P`	`following condition is not satisfied.</P`
`><TABLE`	`><TABLE`
`BORDER="5"`	`BORDER="5"`
`BGCOLOR="#E0E0F0"`	`BGCOLOR="#E0E0F0"`
`WIDTH="70%"`	`WIDTH="70%"`
`><TR`	`><TR`
`><TD`	`><TD`
`><PRE`	`><PRE`
`CLASS="PROGRAMLISTING"`	`CLASS="PROGRAMLISTING"`
`> is_substr("abracadabra", " abra ")</PRE`	`> is_substr("abracadabra", " abra ")</PRE`
`></TD`	`></TD`
`></TR`	`></TR`
`></TABLE`	`></TABLE`
`><P`	`><P`
`>This fails to match at the start of the string because the trailing`	`>This fails to match at the start of the string because the trailing`
`space is not matched by either a real space or the end of the string.`	`space is not matched by either a real space or the end of the string.`
`Similarly it fails to match at the end of the string.</P`	`Similarly it fails to match at the end of the string.</P`
`><P`	`><P`
`>If a constraint involving <TT`	`>If a constraint involving <TT`
`CLASS="FUNCTION"`	`CLASS="FUNCTION"`
`>is_substr</TT`	`>is_substr</TT`
`> is not`	`> is not`
`satisfied and the first argument is a reference to a configuration`	`satisfied and the first argument is a reference to a configuration`
`option, the inference engine will attempt to modify that option's`	`option, the inference engine will attempt to modify that option's`
`value. This can be achieved either by appending the second argument to`	`value. This can be achieved either by appending the second argument to`
`the current value, or by removing all occurrences of that argument`	`the current value, or by removing all occurrences of that argument`
`from the current value.</P`	`from the current value.</P`
`><TABLE`	`><TABLE`
`BORDER="5"`	`BORDER="5"`
`BGCOLOR="#E0E0F0"`	`BGCOLOR="#E0E0F0"`
`WIDTH="70%"`	`WIDTH="70%"`
`><TR`	`><TR`
`><TD`	`><TD`
`><PRE`	`><PRE`
`CLASS="PROGRAMLISTING"`	`CLASS="PROGRAMLISTING"`
`> requires { !is_substr(CYGBLD_GLOBAL_CFLAGS, " -fno-rtti ") }`	`> requires { !is_substr(CYGBLD_GLOBAL_CFLAGS, " -fno-rtti ") }`
`requires { is_substr(CYGBLD_GLOBAL_CFLAGS, " -frtti ") }</PRE`	`requires { is_substr(CYGBLD_GLOBAL_CFLAGS, " -frtti ") }</PRE`
`></TD`	`></TD`
`></TR`	`></TR`
`></TABLE`	`></TABLE`
`><P`	`><P`
`>When data is removed the leading and trailing spaces will be left. For`	`>When data is removed the leading and trailing spaces will be left. For`
`example, given an initial value of`	`example, given an initial value of`
`<<TT`	`<<TT`
`CLASS="VARNAME"`	`CLASS="VARNAME"`
`>CYGBLD_GLOBAL_CFLAGS</TT`	`>CYGBLD_GLOBAL_CFLAGS</TT`
`> of`	`> of`
`<TT`	`<TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>-g -fno-rtti -O2</TT`	`>-g -fno-rtti -O2</TT`
`> the result will be`	`> the result will be`
`<TT`	`<TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>-g  -O2</TT`	`>-g  -O2</TT`
`> rather than <TT`	`> rather than <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>-g-O2</TT`	`>-g-O2</TT`
`>.</P`	`>.</P`
`><P`	`><P`
`>If exact matches are needed, the function`	`>If exact matches are needed, the function`
`<TT`	`<TT`
`CLASS="FUNCTION"`	`CLASS="FUNCTION"`
`>is_xsubstr</TT`	`>is_xsubstr</TT`
`> can be used instead.</P`	`> can be used instead.</P`
`></DD`	`></DD`
`><DT`	`><DT`
`><TT`	`><TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>is_xsubstr(haystack, needle)</TT`	`>is_xsubstr(haystack, needle)</TT`
`></DT`	`></DT`
`><DD`	`><DD`
`><P`	`><P`
`>This function checks whether or not the pattern string is an exact`	`>This function checks whether or not the pattern string is an exact`
`substring of the string being searched. It is similar to`	`substring of the string being searched. It is similar to`
`<TT`	`<TT`
`CLASS="FUNCTION"`	`CLASS="FUNCTION"`
`>is_substr</TT`	`>is_substr</TT`
`> but uses exact matching only. In other`	`> but uses exact matching only. In other`
`words, leading or trailing spaces have to match exactly and will not`	`words, leading or trailing spaces have to match exactly and will not`
`match the beginning or end of the string being searched. The function`	`match the beginning or end of the string being searched. The function`
`takes two arguments, both of which can be arbitrary expressions, and`	`takes two arguments, both of which can be arbitrary expressions, and`
`returns a boolean. The difference between`	`returns a boolean. The difference between`
`<TT`	`<TT`
`CLASS="FUNCTION"`	`CLASS="FUNCTION"`
`>is_substr</TT`	`>is_substr</TT`
`> and <TT`	`> and <TT`
`CLASS="FUNCTION"`	`CLASS="FUNCTION"`
`>is_xsubstr</TT`	`>is_xsubstr</TT`
`> is`	`> is`
`illustrated by the following examples:</P`	`illustrated by the following examples:</P`
`><TABLE`	`><TABLE`
`BORDER="5"`	`BORDER="5"`
`BGCOLOR="#E0E0F0"`	`BGCOLOR="#E0E0F0"`
`WIDTH="70%"`	`WIDTH="70%"`
`><TR`	`><TR`
`><TD`	`><TD`
`><PRE`	`><PRE`
`CLASS="PROGRAMLISTING"`	`CLASS="PROGRAMLISTING"`
`> cdl_option MAGIC {`	`> cdl_option MAGIC {`
`flavor data`	`flavor data`
`default_value { "abracadabra" }`	`default_value { "abracadabra" }`
`}`	`}`
`…`	`…`
`requires { is_substr(MAGIC, " abra") }`	`requires { is_substr(MAGIC, " abra") }`
`requires { is_xsubstr(MAGIC, " abra") }</PRE`	`requires { is_xsubstr(MAGIC, " abra") }</PRE`
`></TD`	`></TD`
`></TR`	`></TR`
`></TABLE`	`></TABLE`
`><P`	`><P`
`>The first goal will be satisfied because the leading space in the`	`>The first goal will be satisfied because the leading space in the`
`pattern matches the beginning of the string. The second goal will not`	`pattern matches the beginning of the string. The second goal will not`
`be satisfied initialy because there is no exact match, so the`	`be satisfied initialy because there is no exact match, so the`
`inference engine is likely to update the value of`	`inference engine is likely to update the value of`
`<TT`	`<TT`
`CLASS="VARNAME"`	`CLASS="VARNAME"`
`>MAGIC</TT`	`>MAGIC</TT`
`> to <TT`	`> to <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>abracadabra abra</TT`	`>abracadabra abra</TT`
`> which`	`> which`
`does give an exact match.</P`	`does give an exact match.</P`
`></DD`	`></DD`
`><DT`	`><DT`
`><TT`	`><TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>version_cmp(A, B)</TT`	`>version_cmp(A, B)</TT`
`></DT`	`></DT`
`><DD`	`><DD`
`><P`	`><P`
`>This function is used primarily to check that a sufficiently recent`	`>This function is used primarily to check that a sufficiently recent`
`<A`	`<A`
`HREF="package.versions.html"`	`HREF="package.versions.html"`
`>version</A`	`>version</A`
`> of some other package`	`> of some other package`
`is being used. It takes two arguments, both of which can be arbitrary`	`is being used. It takes two arguments, both of which can be arbitrary`
`expressions. In practice usually one of the arguments will be a`	`expressions. In practice usually one of the arguments will be a`
`reference to a package and the other will be a constant version`	`reference to a package and the other will be a constant version`
`string. The return value is -1 if the first argument is a more recent`	`string. The return value is -1 if the first argument is a more recent`
`version then the second, 0 if the two arguments correspond to`	`version then the second, 0 if the two arguments correspond to`
`identical versions, and 1 if the first argument is an older version.`	`identical versions, and 1 if the first argument is an older version.`
`For example the following constraint can be used to indicate that the`	`For example the following constraint can be used to indicate that the`
`current package depends on kernel functionality that only became`	`current package depends on kernel functionality that only became`
`available in version 1.3:</P`	`available in version 1.3:</P`
`><TABLE`	`><TABLE`
`BORDER="5"`	`BORDER="5"`
`BGCOLOR="#E0E0F0"`	`BGCOLOR="#E0E0F0"`
`WIDTH="70%"`	`WIDTH="70%"`
`><TR`	`><TR`
`><TD`	`><TD`
`><PRE`	`><PRE`
`CLASS="PROGRAMLISTING"`	`CLASS="PROGRAMLISTING"`
`> requires { version_cmp(CYGPKG_KERNEL, "v1.3") <= 0 }</PRE`	`> requires { version_cmp(CYGPKG_KERNEL, "v1.3") <= 0 }</PRE`
`></TD`	`></TD`
`></TR`	`></TR`
`></TABLE`	`></TABLE`
`></DD`	`></DD`
`></DL`	`></DL`
`></DIV`	`></DIV`
`><DIV`	`><DIV`
`CLASS="NOTE"`	`CLASS="NOTE"`
`><BLOCKQUOTE`	`><BLOCKQUOTE`
`CLASS="NOTE"`	`CLASS="NOTE"`
`><P`	`><P`
`><B`	`><B`
`>Note: </B`	`>Note: </B`
`>At this time it is not possible to define new functions inside a CDL`	`>At this time it is not possible to define new functions inside a CDL`
`script. Instead functions can only be added at the C++ level, usually`	`script. Instead functions can only be added at the C++ level, usually`
`by extending libcdl itself. This is partly because there is more to`	`by extending libcdl itself. This is partly because there is more to`
`CDL functions than simple evaluation: associated with most functions`	`CDL functions than simple evaluation: associated with most functions`
`is support for the inference engine, so that if a constraint involving`	`is support for the inference engine, so that if a constraint involving`
`a function is not currently satisfied the system may be able to find a`	`a function is not currently satisfied the system may be able to find a`
`solution automatically.</P`	`solution automatically.</P`
`></BLOCKQUOTE`	`></BLOCKQUOTE`
`></DIV`	`></DIV`
`></DIV`	`></DIV`
`><DIV`	`><DIV`
`CLASS="SECT2"`	`CLASS="SECT2"`
`><H2`	`><H2`
`CLASS="SECT2"`	`CLASS="SECT2"`
`><A`	`><A`
`NAME="LANGUAGE.GOAL-EXPRESSION">Goal Expressions</H2`	`NAME="LANGUAGE.GOAL-EXPRESSION">Goal Expressions</H2`
`><P`	`><P`
`>The arguments to certain properties, notably <SPAN`	`>The arguments to certain properties, notably <SPAN`
`CLASS="PROPERTY"`	`CLASS="PROPERTY"`
`>requires</SPAN`	`>requires</SPAN`
`> and`	`> and`
`<SPAN`	`<SPAN`
`CLASS="PROPERTY"`	`CLASS="PROPERTY"`
`>active_if</SPAN`	`>active_if</SPAN`
`>, constitute a goal expression. As with an ordinary`	`>, constitute a goal expression. As with an ordinary`
`expression, all of the arguments get combined and then the expression`	`expression, all of the arguments get combined and then the expression`
`parser takes over. The same care has to be taken with constant strings`	`parser takes over. The same care has to be taken with constant strings`
`and anything else that may get processed by the Tcl interpreter, so`	`and anything else that may get processed by the Tcl interpreter, so`
`often a goal expression is enclosed entirely in braces and the`	`often a goal expression is enclosed entirely in braces and the`
`expression parsing code sees just a single argument.</P`	`expression parsing code sees just a single argument.</P`
`><P`	`><P`
`>A goal expression is basically just a sequence of ordinary`	`>A goal expression is basically just a sequence of ordinary`
`expressions, for example:</P`	`expressions, for example:</P`
`><TABLE`	`><TABLE`
`BORDER="5"`	`BORDER="5"`
`BGCOLOR="#E0E0F0"`	`BGCOLOR="#E0E0F0"`
`WIDTH="70%"`	`WIDTH="70%"`
`><TR`	`><TR`
`><TD`	`><TD`
`><PRE`	`><PRE`
`CLASS="PROGRAMLISTING"`	`CLASS="PROGRAMLISTING"`
`> requires { CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS`	`> requires { CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS`
`!CYGDBG_HAL_DEBUG_GDB_BREAK_SUPPORT`	`!CYGDBG_HAL_DEBUG_GDB_BREAK_SUPPORT`
`!CYGDBG_HAL_DEBUG_GDB_CTRLC_SUPPORT }</PRE`	`!CYGDBG_HAL_DEBUG_GDB_CTRLC_SUPPORT }</PRE`
`></TD`	`></TD`
`></TR`	`></TR`
`></TABLE`	`></TABLE`
`><P`	`><P`
`>This consists of three separate expressions, all of which should`	`>This consists of three separate expressions, all of which should`
`evaluate to a non-zero result. The same expression could be written`	`evaluate to a non-zero result. The same expression could be written`
`as: </P`	`as: </P`
`><TABLE`	`><TABLE`
`BORDER="5"`	`BORDER="5"`
`BGCOLOR="#E0E0F0"`	`BGCOLOR="#E0E0F0"`
`WIDTH="70%"`	`WIDTH="70%"`
`><TR`	`><TR`
`><TD`	`><TD`
`><PRE`	`><PRE`
`CLASS="PROGRAMLISTING"`	`CLASS="PROGRAMLISTING"`
`> requires { CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS &&`	`> requires { CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS &&`
`!CYGDBG_HAL_DEBUG_GDB_BREAK_SUPPORT &&`	`!CYGDBG_HAL_DEBUG_GDB_BREAK_SUPPORT &&`
`!CYGDBG_HAL_DEBUG_GDB_CTRLC_SUPPORT }</PRE`	`!CYGDBG_HAL_DEBUG_GDB_CTRLC_SUPPORT }</PRE`
`></TD`	`></TD`
`></TR`	`></TR`
`></TABLE`	`></TABLE`
`><P`	`><P`
`>Alternatively the following would have much the same effect:</P`	`>Alternatively the following would have much the same effect:</P`
`><TABLE`	`><TABLE`
`BORDER="5"`	`BORDER="5"`
`BGCOLOR="#E0E0F0"`	`BGCOLOR="#E0E0F0"`
`WIDTH="70%"`	`WIDTH="70%"`
`><TR`	`><TR`
`><TD`	`><TD`
`><PRE`	`><PRE`
`CLASS="PROGRAMLISTING"`	`CLASS="PROGRAMLISTING"`
`> requires CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS`	`> requires CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS`
`requires !CYGDBG_HAL_DEBUG_GDB_BREAK_SUPPORT`	`requires !CYGDBG_HAL_DEBUG_GDB_BREAK_SUPPORT`
`requires !CYGDBG_HAL_DEBUG_GDB_CTRLC_SUPPORT</PRE`	`requires !CYGDBG_HAL_DEBUG_GDB_CTRLC_SUPPORT</PRE`
`></TD`	`></TD`
`></TR`	`></TR`
`></TABLE`	`></TABLE`
`><P`	`><P`
`>Selecting between these alternatives is largely a stylistic choice.`	`>Selecting between these alternatives is largely a stylistic choice.`
`The first is slightly more concise than the others. The second is more`	`The first is slightly more concise than the others. The second is more`
`likely to appeal to mathematical purists. The third is more amenable`	`likely to appeal to mathematical purists. The third is more amenable`
`to cutting and pasting.</P`	`to cutting and pasting.</P`
`><P`	`><P`
`>The result of evaluating a goal expression is a boolean. If any part`	`>The result of evaluating a goal expression is a boolean. If any part`
`of the goal expression evaluates to the integer <TT`	`of the goal expression evaluates to the integer <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>0</TT`	`>0</TT`
`>`	`>`
`or an equivalent string then the result is false, otherwise it is`	`or an equivalent string then the result is false, otherwise it is`
`true. </P`	`true. </P`
`><P`	`><P`
`>The term “goal expression” relates to the component`	`>The term “goal expression” relates to the component`
`framework's inference engine: it is a description of a goal that`	`framework's inference engine: it is a description of a goal that`
`should be satisfied for a conflict-free configuration. If a <SPAN`	`should be satisfied for a conflict-free configuration. If a <SPAN`
`CLASS="PROPERTY"`	`CLASS="PROPERTY"`
`>requires</SPAN`	`>requires</SPAN`
`>`	`>`
`constraint is not satisfied then the inference engine will examine the`	`constraint is not satisfied then the inference engine will examine the`
`goal expression: if there is some way of changing the configuration`	`goal expression: if there is some way of changing the configuration`
`that does not introduce new conflicts and that will cause the goal`	`that does not introduce new conflicts and that will cause the goal`
`expression to evaluate to true, the conflict can be resolved.</P`	`expression to evaluate to true, the conflict can be resolved.</P`
`><P`	`><P`
`>The inference engine works with one conflict and hence one goal`	`>The inference engine works with one conflict and hence one goal`
`expression at a time. This means that there can be slightly different`	`expression at a time. This means that there can be slightly different`
`behavior if a constraint is specified using a single <SPAN`	`behavior if a constraint is specified using a single <SPAN`
`CLASS="PROPERTY"`	`CLASS="PROPERTY"`
`>requires</SPAN`	`>requires</SPAN`
`>`	`>`
`property or several different ones. Given the above example, suppose`	`property or several different ones. Given the above example, suppose`
`that none of the three conditions are satisfied. If a single goal`	`that none of the three conditions are satisfied. If a single goal`
`expression is used then the inference engine might be able to satisfy`	`expression is used then the inference engine might be able to satisfy`
`only two of the three parts, but since the conflict as a whole cannot`	`only two of the three parts, but since the conflict as a whole cannot`
`be resolved no part of the solution will be applied. Instead the user`	`be resolved no part of the solution will be applied. Instead the user`
`will have to resolve the entire conflict. If three separate goal`	`will have to resolve the entire conflict. If three separate goal`
`expressions are used then the inference engine might well find`	`expressions are used then the inference engine might well find`
`solutions to two of them, leaving less work for the user. On the other`	`solutions to two of them, leaving less work for the user. On the other`
`hand, if a single goal expression is used then the inference engine`	`hand, if a single goal expression is used then the inference engine`
`has a bit more information to work with, and it might well find a`	`has a bit more information to work with, and it might well find a`
`solution to the entire conflict where it would be unable to find`	`solution to the entire conflict where it would be unable to find`
`separate solutions for the three parts. Things can get very`	`separate solutions for the three parts. Things can get very`
`complicated, and in general component writers should not worry about`	`complicated, and in general component writers should not worry about`
`the subtleties of the inference engine and how to manipulate its`	`the subtleties of the inference engine and how to manipulate its`
`behavior. </P`	`behavior. </P`
`><P`	`><P`
`>It is possible to write ambiguous goal expressions, for example:</P`	`>It is possible to write ambiguous goal expressions, for example:</P`
`><TABLE`	`><TABLE`
`BORDER="5"`	`BORDER="5"`
`BGCOLOR="#E0E0F0"`	`BGCOLOR="#E0E0F0"`
`WIDTH="70%"`	`WIDTH="70%"`
`><TR`	`><TR`
`><TD`	`><TD`
`><PRE`	`><PRE`
`CLASS="PROGRAMLISTING"`	`CLASS="PROGRAMLISTING"`
`> requires CYGNUM_LIBC_RAND_SEED -CYGNUM_LIBC_RAND_TRACE_LEVEL > 5</PRE`	`> requires CYGNUM_LIBC_RAND_SEED -CYGNUM_LIBC_RAND_TRACE_LEVEL > 5</PRE`
`></TD`	`></TD`
`></TR`	`></TR`
`></TABLE`	`></TABLE`
`><P`	`><P`
`>This could be parsed in two ways:</P`	`>This could be parsed in two ways:</P`
`><TABLE`	`><TABLE`
`BORDER="5"`	`BORDER="5"`
`BGCOLOR="#E0E0F0"`	`BGCOLOR="#E0E0F0"`
`WIDTH="70%"`	`WIDTH="70%"`
`><TR`	`><TR`
`><TD`	`><TD`
`><PRE`	`><PRE`
`CLASS="PROGRAMLISTING"`	`CLASS="PROGRAMLISTING"`
`> requires ((CYGNUM_LIBC_RAND_SEED - CYGNUM_LIBC_RAND_TRACE_LEVEL) > 5)`	`> requires ((CYGNUM_LIBC_RAND_SEED - CYGNUM_LIBC_RAND_TRACE_LEVEL) > 5)`
`requires CYGNUM_LIBC_RAND_SEED && ((-CYGNUM_LIBC_RAND_TRACE_LEVEL) > 5)</PRE`	`requires CYGNUM_LIBC_RAND_SEED && ((-CYGNUM_LIBC_RAND_TRACE_LEVEL) > 5)</PRE`
`></TD`	`></TD`
`></TR`	`></TR`
`></TABLE`	`></TABLE`
`><P`	`><P`
`>The goal expression parsing code will always use the largest ordinary`	`>The goal expression parsing code will always use the largest ordinary`
`expression for each goal, so the first interpretation will be used.`	`expression for each goal, so the first interpretation will be used.`
`In such cases it is a good idea to use brackets and avoid possible`	`In such cases it is a good idea to use brackets and avoid possible`
`confusion. </P`	`confusion. </P`
`></DIV`	`></DIV`
`><DIV`	`><DIV`
`CLASS="SECT2"`	`CLASS="SECT2"`
`><H2`	`><H2`
`CLASS="SECT2"`	`CLASS="SECT2"`
`><A`	`><A`
`NAME="LANGUAGE.LIST-EXPRESSION">List Expressions</H2`	`NAME="LANGUAGE.LIST-EXPRESSION">List Expressions</H2`
`><P`	`><P`
`>The arguments to the <SPAN`	`>The arguments to the <SPAN`
`CLASS="PROPERTY"`	`CLASS="PROPERTY"`
`>legal_values</SPAN`	`>legal_values</SPAN`
`> property constitute a goal`	`> property constitute a goal`
`expression. As with an ordinary and goal expressions, all of the`	`expression. As with an ordinary and goal expressions, all of the`
`arguments get combined and then the expression parser takes over. The`	`arguments get combined and then the expression parser takes over. The`
`same care has to be taken with constant strings and anything else that`	`same care has to be taken with constant strings and anything else that`
`may get processed by the Tcl interpreter, so often a list expression`	`may get processed by the Tcl interpreter, so often a list expression`
`is enclosed entirely in braces and the expression parsing code sees`	`is enclosed entirely in braces and the expression parsing code sees`
`just a single argument.</P`	`just a single argument.</P`
`><P`	`><P`
`>Most list expressions take one of two forms:</P`	`>Most list expressions take one of two forms:</P`
`><TABLE`	`><TABLE`
`BORDER="5"`	`BORDER="5"`
`BGCOLOR="#E0E0F0"`	`BGCOLOR="#E0E0F0"`
`WIDTH="70%"`	`WIDTH="70%"`
`><TR`	`><TR`
`><TD`	`><TD`
`><PRE`	`><PRE`
`CLASS="PROGRAMLISTING"`	`CLASS="PROGRAMLISTING"`
`> legal_values <expr1> <expr2> <expr3> ...`	`> legal_values <expr1> <expr2> <expr3> ...`
`legal_values <expr1> to <expr2></PRE`	`legal_values <expr1> to <expr2></PRE`
`></TD`	`></TD`
`></TR`	`></TR`
`></TABLE`	`></TABLE`
`><P`	`><P`
`><TT`	`><TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>expr1</TT`	`>expr1</TT`
`>, <TT`	`>, <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>expr2</TT`	`>expr2</TT`
`> and so on are`	`> and so on are`
`ordinary expressions. Often these will be constants or references to`	`ordinary expressions. Often these will be constants or references to`
`calculated options in the architectural HAL package, but it is`	`calculated options in the architectural HAL package, but it is`
`possible to use arbitrary expressions when necessary. The first syntax`	`possible to use arbitrary expressions when necessary. The first syntax`
`indicates a list of possible values, which need not be numerical. The`	`indicates a list of possible values, which need not be numerical. The`
`second syntax indicates a numerical range: both sides of the`	`second syntax indicates a numerical range: both sides of the`
`<TT`	`<TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>to</TT`	`>to</TT`
`> must evaluate to a numerical value; if either`	`> must evaluate to a numerical value; if either`
`side involves a floating point number then any floating point number`	`side involves a floating point number then any floating point number`
`in that range is legal; otherwise only integer values are legal;`	`in that range is legal; otherwise only integer values are legal;`
`ranges are inclusive, so <TT`	`ranges are inclusive, so <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>4</TT`	`>4</TT`
`> is a valid value given a`	`> is a valid value given a`
`list expression <TT`	`list expression <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>1 to </TT`	`>1 to </TT`
`>; if one or both`	`>; if one or both`
`sides of the <TT`	`sides of the <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>to</TT`	`>to</TT`
`> does not evaluate to a numerical`	`> does not evaluate to a numerical`
`value then this will result in a run-time conflict. The following`	`value then this will result in a run-time conflict. The following`
`examples illustrate these possibilities:</P`	`examples illustrate these possibilities:</P`
`><TABLE`	`><TABLE`
`BORDER="5"`	`BORDER="5"`
`BGCOLOR="#E0E0F0"`	`BGCOLOR="#E0E0F0"`
`WIDTH="70%"`	`WIDTH="70%"`
`><TR`	`><TR`
`><TD`	`><TD`
`><PRE`	`><PRE`
`CLASS="PROGRAMLISTING"`	`CLASS="PROGRAMLISTING"`
`> legal_values { "red" "green" "blue" }`	`> legal_values { "red" "green" "blue" }`
`legal_values 1 2 4 8 16`	`legal_values 1 2 4 8 16`
`legal_values 1 to CYGARC_MAXINT`	`legal_values 1 to CYGARC_MAXINT`
`legal_values 1.0 to 2.0</PRE`	`legal_values 1.0 to 2.0</PRE`
`></TD`	`></TD`
`></TR`	`></TR`
`></TABLE`	`></TABLE`
`><P`	`><P`
`>It is possible to combine the two syntaxes, for example:</P`	`>It is possible to combine the two syntaxes, for example:</P`
`><TABLE`	`><TABLE`
`BORDER="5"`	`BORDER="5"`
`BGCOLOR="#E0E0F0"`	`BGCOLOR="#E0E0F0"`
`WIDTH="70%"`	`WIDTH="70%"`
`><TR`	`><TR`
`><TD`	`><TD`
`><PRE`	`><PRE`
`CLASS="PROGRAMLISTING"`	`CLASS="PROGRAMLISTING"`
`> legal_values 1 2 4 to CYGARC_MAXINT -1024 -20.0 to -10</PRE`	`> legal_values 1 2 4 to CYGARC_MAXINT -1024 -20.0 to -10</PRE`
`></TD`	`></TD`
`></TR`	`></TR`
`></TABLE`	`></TABLE`
`><P`	`><P`
`>This indicates three legal values <TT`	`>This indicates three legal values <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>1</TT`	`>1</TT`
`>,`	`>,`
`<TT`	`<TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>2</TT`	`>2</TT`
`> and <TT`	`> and <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>-1024</TT`	`>-1024</TT`
`>, one`	`>, one`
`integer range <TT`	`integer range <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>4 to CYGARC_MAXINT</TT`	`>4 to CYGARC_MAXINT</TT`
`>, and one`	`>, and one`
`floating point range <TT`	`floating point range <TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>-20.0 to -10.0</TT`	`>-20.0 to -10.0</TT`
`>. In`	`>. In`
`practice such list expressions are rarely useful.</P`	`practice such list expressions are rarely useful.</P`
`><P`	`><P`
`>The identifier <TT`	`>The identifier <TT`
`CLASS="VARNAME"`	`CLASS="VARNAME"`
`>to</TT`	`>to</TT`
`> is not reserved, so it is`	`> is not reserved, so it is`
`possible to have a configuration option with that name (although it`	`possible to have a configuration option with that name (although it`
`violates every naming convention). Using that option in a list`	`violates every naming convention). Using that option in a list`
`expression may however give unexpected results.</P`	`expression may however give unexpected results.</P`
`><P`	`><P`
`>The graphical configuration tool uses the <SPAN`	`>The graphical configuration tool uses the <SPAN`
`CLASS="PROPERTY"`	`CLASS="PROPERTY"`
`>legal_values</SPAN`	`>legal_values</SPAN`
`> list`	`> list`
`expression to determine how best to let users manipulate the option's`	`expression to determine how best to let users manipulate the option's`
`value. Different widgets will be appropriate for different lists, so`	`value. Different widgets will be appropriate for different lists, so`
`<TT`	`<TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>{ "red" "green" "blue" }</TT`	`>{ "red" "green" "blue" }</TT`
`> might`	`> might`
`involve a pull-down option menu, and`	`involve a pull-down option menu, and`
`<TT`	`<TT`
`CLASS="LITERAL"`	`CLASS="LITERAL"`
`>1 to 16</TT`	`>1 to 16</TT`
`> could involve a spinner. The`	`> could involve a spinner. The`
`exact way in which <SPAN`	`exact way in which <SPAN`
`CLASS="PROPERTY"`	`CLASS="PROPERTY"`
`>legal_values</SPAN`	`>legal_values</SPAN`
`> lists get mapped on to GUI widgets`	`> lists get mapped on to GUI widgets`
`is not defined and is subject to change at any time.</P`	`is not defined and is subject to change at any time.</P`
`><P`	`><P`
`>As with goal expressions, list expressions can be ambiguous. Consider`	`>As with goal expressions, list expressions can be ambiguous. Consider`
`the following hypothetical example:</P`	`the following hypothetical example:</P`
`><TABLE`	`><TABLE`
`BORDER="5"`	`BORDER="5"`
`BGCOLOR="#E0E0F0"`	`BGCOLOR="#E0E0F0"`
`WIDTH="70%"`	`WIDTH="70%"`
`><TR`	`><TR`
`><TD`	`><TD`
`><PRE`	`><PRE`
`CLASS="PROGRAMLISTING"`	`CLASS="PROGRAMLISTING"`
`> legal_values CYGNUM_LIBC_RAND_SEED -CYGNUM_LIBC_RAND_TRACE_LEVEL</PRE`	`> legal_values CYGNUM_LIBC_RAND_SEED -CYGNUM_LIBC_RAND_TRACE_LEVEL</PRE`
`></TD`	`></TD`
`></TR`	`></TR`
`></TABLE`	`></TABLE`
`><P`	`><P`
`>This could be parsed in two ways:</P`	`>This could be parsed in two ways:</P`
`><TABLE`	`><TABLE`
`BORDER="5"`	`BORDER="5"`
`BGCOLOR="#E0E0F0"`	`BGCOLOR="#E0E0F0"`
`WIDTH="70%"`	`WIDTH="70%"`
`><TR`	`><TR`
`><TD`	`><TD`
`><PRE`	`><PRE`
`CLASS="PROGRAMLISTING"`	`CLASS="PROGRAMLISTING"`
`> legal_values (CYGNUM_LIBC_RAND_SEED - CYGNUM_LIBC_RAND_TRACE_LEVEL)`	`> legal_values (CYGNUM_LIBC_RAND_SEED - CYGNUM_LIBC_RAND_TRACE_LEVEL)`
`legal_values (CYGNUM_LIBC_RAND_SEED) (-CYGNUM_LIBC_RAND_TRACE_LEVEL)</PRE`	`legal_values (CYGNUM_LIBC_RAND_SEED) (-CYGNUM_LIBC_RAND_TRACE_LEVEL)</PRE`
`></TD`	`></TD`
`></TR`	`></TR`
`></TABLE`	`></TABLE`
`><P`	`><P`
`>Both are legal. The list expression parsing code will always use the`	`>Both are legal. The list expression parsing code will always use the`
`largest ordinary expression for each element, so the first`	`largest ordinary expression for each element, so the first`
`interpretation will be used. In cases like this it is a good idea to`	`interpretation will be used. In cases like this it is a good idea to`
`use brackets and avoid possible confusion.</P`	`use brackets and avoid possible confusion.</P`
`></DIV`	`></DIV`
`></DIV`	`></DIV`
`><DIV`	`><DIV`
`CLASS="NAVFOOTER"`	`CLASS="NAVFOOTER"`
`><HR`	`><HR`
`ALIGN="LEFT"`	`ALIGN="LEFT"`
`WIDTH="100%"><TABLE`	`WIDTH="100%"><TABLE`
`SUMMARY="Footer navigation table"`	`SUMMARY="Footer navigation table"`
`WIDTH="100%"`	`WIDTH="100%"`
`BORDER="0"`	`BORDER="0"`
`CELLPADDING="0"`	`CELLPADDING="0"`
`CELLSPACING="0"`	`CELLSPACING="0"`
`><TR`	`><TR`
`><TD`	`><TD`
`WIDTH="33%"`	`WIDTH="33%"`
`ALIGN="left"`	`ALIGN="left"`
`VALIGN="top"`	`VALIGN="top"`
`><A`	`><A`
`HREF="language.tcl.html"`	`HREF="language.tcl.html"`
`ACCESSKEY="P"`	`ACCESSKEY="P"`
`>Prev</A`	`>Prev</A`
`></TD`	`></TD`
`><TD`	`><TD`
`WIDTH="34%"`	`WIDTH="34%"`
`ALIGN="center"`	`ALIGN="center"`
`VALIGN="top"`	`VALIGN="top"`
`><A`	`><A`
`HREF="cdl-guide.html"`	`HREF="cdl-guide.html"`
`ACCESSKEY="H"`	`ACCESSKEY="H"`
`>Home</A`	`>Home</A`
`></TD`	`></TD`
`><TD`	`><TD`
`WIDTH="33%"`	`WIDTH="33%"`
`ALIGN="right"`	`ALIGN="right"`
`VALIGN="top"`	`VALIGN="top"`
`><A`	`><A`
`HREF="language.interface.html"`	`HREF="language.interface.html"`
`ACCESSKEY="N"`	`ACCESSKEY="N"`
`>Next</A`	`>Next</A`
`></TD`	`></TD`
`></TR`	`></TR`
`><TR`	`><TR`
`><TD`	`><TD`
`WIDTH="33%"`	`WIDTH="33%"`
`ALIGN="left"`	`ALIGN="left"`
`VALIGN="top"`	`VALIGN="top"`
`>An Introduction to Tcl</TD`	`>An Introduction to Tcl</TD`
`><TD`	`><TD`
`WIDTH="34%"`	`WIDTH="34%"`
`ALIGN="center"`	`ALIGN="center"`
`VALIGN="top"`	`VALIGN="top"`
`><A`	`><A`
`HREF="language.html"`	`HREF="language.html"`
`ACCESSKEY="U"`	`ACCESSKEY="U"`
`>Up</A`	`>Up</A`
`></TD`	`></TD`
`><TD`	`><TD`
`WIDTH="33%"`	`WIDTH="33%"`
`ALIGN="right"`	`ALIGN="right"`
`VALIGN="top"`	`VALIGN="top"`
`>Interfaces</TD`	`>Interfaces</TD`
`></TR`	`></TR`
`></TABLE`	`></TABLE`
`></DIV`	`></DIV`
`></BODY`	`></BODY`
`></HTML`	`></HTML`

Browse

Tools

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [rtos/] [ecos-2.0/] [doc/] [html/] [cdl-guide/] [language.values.html] - Diff between revs 28 and 174