csswg/css3-lists Overview.src.html,1.103,1.104

Update of /sources/public/csswg/css3-lists
In directory hutz:/tmp/cvs-serv13549

Modified Files:
	Overview.src.html 
Log Message:
Swapped out I and N for 'value' and 'length' in the algorithms.


Index: Overview.src.html
===================================================================
RCS file: /sources/public/csswg/css3-lists/Overview.src.html,v
retrieving revision 1.103
retrieving revision 1.104
diff -u -d -r1.103 -r1.104
--- Overview.src.html	2 Jun 2011 00:51:44 -0000	1.103
+++ Overview.src.html	2 Jun 2011 01:33:12 -0000	1.104
@@ -885,10 +885,10 @@
 	representation of the value 1, the second <i>counter glyph</i> (if it exists) 
 	is used as the representation of the value 2, etc.</p>
 
-	<p>In general, if there are <var>N</var> <i>counter glyphs</i> and
-	a representation is being constructed for the value <var>I</var>, 
+	<p>In general, if there are <var>length</var> <i>counter glyphs</i> and
+	a representation is being constructed for the value <var>value</var>, 
 	the representation is the <i>counter glyph</i> at index 
-	(<var>I</var> mod <var>N</var>) of the list of <i>counter glyph</i>s
+	(<var>value</var> mod <var>length</var>) of the list of <i>counter glyph</i>s
 	(0-indexed).</p>
 
 	<div class=example>
@@ -922,27 +922,27 @@
 	<i>counter glyph</i>s as digits to a number system, similar to the default
 	''decimal'' counter style.  The first <i>counter glyph</i> in the list is 
 	interpreted as the digit 0, the second as the digit 1, and so on.  If there 
-	are <var>N</var> <i>counter glyph</i>s, the representation is a base 
-	<var>N</var> number using the <i>counter glyph</i>s as digits.</p>
+	are <var>length</var> <i>counter glyph</i>s, the representation is a base 
+	<var>length</var> number using the <i>counter glyph</i>s as digits.</p>
 
 	<p>To construct the representation, run the following algorithm. Let
-	<var>N</var> be the length of the list of <i>counter glyphs</i>, 
-	<var>I</var> initially be the counter value, <var>S</var>
+	<var>length</var> be the length of the list of <i>counter glyphs</i>, 
+	<var>value</var> initially be the counter value, <var>S</var>
 	initially be the empty string, <var>negative</var> be a boolean flag
 	that is initially false, and <var>glyph(n)</var> be the nth
 	<i>counter glyph</i> in the list of <i>counter glyph</i>s (0-indexed).</p>
 
 	<ol>
-		<li>If <var>I</var> is 0, append <var>glyph(0)</var> to 
+		<li>If <var>value</var> is 0, append <var>glyph(0)</var> to 
 		<var>S</var> and return <var>S</var>.</li>
 
-		<li>While <var>I</var> is not equal to 0:
+		<li>While <var>value</var> is not equal to 0:
 
 			<ol>
-				<li>Prepend <var>glyph( <var>I</var> mod <var>N</var> )</var> 
+				<li>Prepend <var>glyph( <var>value</var> mod <var>length</var> )</var> 
 				to <var>S</var>.</li>
 
-				<li>Set <var>I</var> to <code>floor( <var>I</var> / <var>N</var> )</code>.</li>
+				<li>Set <var>value</var> to <code>floor( <var>value</var> / <var>length</var> )</code>.</li>
 			</ol>
 		</li>
 
@@ -984,26 +984,26 @@
 	''lower-alpha'' counter style. Alphabetic numbering systems are commonly used 
 	for lists, and also appear in many spreadsheet programs to number columns. 
 	The first <i>counter glyph</i> in the list is interpreted as the digit 1, 
-	the second as the digit 2, and so on.  If there are <var>N</var> 
-	<i>counter glyph</i>s, the representation is a base <var>N</var> alphabetic 
+	the second as the digit 2, and so on.  If there are <var>length</var> 
+	<i>counter glyph</i>s, the representation is a base <var>length</var> alphabetic 
 	number using the <i>counter glyph</i>s as digits.  Alphabetic numbering 
 	systems do not contain a digit representing 0.</p>
 
 	<p>To construct the representation, run the following algorithm.  Let
-	<var>N</var> be the length of the list of <i>counter glyph</i>s,
-	<var>I</var> initially be the counter value, <var>S</var> initially
+	<var>length</var> be the length of the list of <i>counter glyph</i>s,
+	<var>value</var> initially be the counter value, <var>S</var> initially
 	be the empty string, and <var>glyph(n)</var> be the nth <i>counter glyph</i>
 	in the list of <i>counter glyph</i>s (0-indexed).</p>
 
-	<p>While <var>I</var> is not equal to 0:</p>
+	<p>While <var>value</var> is not equal to 0:</p>
 
 	<ol>
-		<li>Set <var>I</var> to <code><var>I</var> - 1</code>.</li>
+		<li>Set <var>value</var> to <code><var>value</var> - 1</code>.</li>
 
-		<li>Prepend <var>glyph( <var>I</var> mod <var>N</var> )</var>
+		<li>Prepend <var>glyph( <var>value</var> mod <var>length</var> )</var>
 		to <var>S</var>.</li>
 
-		<li>Set <var>I</var> to <code>floor( <var>I</var> / <var>N</var> )</code>.</li>
+		<li>Set <var>value</var> to <code>floor( <var>value</var> / <var>length</var> )</code>.</li>
 	</ol>
 
 	<p>Finally, return <var>S</var>.</p>
@@ -1084,12 +1084,12 @@
 	alphabetic-style lists for a slightly different presentation than what the
 	''alphabetic'' type presents.</p>
 
-	<p>To construct the representation, let <var>N</var> be the length of 
-	the list of <i>counter glyph</i>s, <var>I</var> initially be the counter 
+	<p>To construct the representation, let <var>length</var> be the length of 
+	the list of <i>counter glyph</i>s, <var>value</var> initially be the counter 
 	value, <var>S</var> initially be the empty string, and <code>glyph(n)</code> 
 	be the nth <i>counter glyph</i>	in the list of <i>counter glyph</i>s 
-	(0-indexed).  Append <code class='inline'>glyph( <var>I</var> mod <var>N</var> )</code>
-	to <var>S</var> <code class='inline'>floor( (<var>I</var> - 1) / <var>N</var> )</code>
+	(0-indexed).  Append <code class='inline'>glyph( <var>value</var> mod <var>length</var> )</code>
+	to <var>S</var> <code class='inline'>floor( (<var>value</var> - 1) / <var>length</var> )</code>
 	times, then return <var>S</var>.</p>
 
 	<div class=example>
@@ -1184,15 +1184,15 @@
 	several languages which use different characters for the digits in differnt
 	positions.</p>
 
-	<p>To construct the representation, run this algorithm.  let <var>I</var> 
+	<p>To construct the representation, run this algorithm.  let <var>value</var> 
 	initially be the counter value, <var>S</var> initially be the empty string, 
 	and <var>glyph list</var> initially be the list of <i>additive tuple</i>s.
 
-	<p>If <var>I</var> is initially 0, and there is an <i>additive tuple</i>
+	<p>If <var>value</var> is initially 0, and there is an <i>additive tuple</i>
 	with a weight of 0, append that tuple's <i>counter glyph</i> to S
 	and return S.</p>
 
-	<p>Otherwise, while <var>I</var> is greater than 0 and there are elements
+	<p>Otherwise, while <var>value</var> is greater than 0 and there are elements
 	left in the <var>glyph list</var>:</p>
 
 	<ol>
@@ -1200,11 +1200,11 @@
 		This is the <dfn>current tuple</dfn>.</li>
 
 		<li>Append the <i>current tuple</i>'s <i>counter glyph</i> to <var>S</var> 
-		<code>floor( <var>I</var> / <var><i>current tuple</i>'s weight</var> )</code>
+		<code>floor( <var>value</var> / <var><i>current tuple</i>'s weight</var> )</code>
 		times (this may be 0).</li>
 	</ol>
 
-	<p>If the loop ended because <var>I</var> is 0, return S.  Otherwise, the 
+	<p>If the loop ended because <var>value</var> is 0, return S.  Otherwise, the 
 	given counter value cannot be represented by this counter style, and must
 	instead be represented by the fallback counter style.</p>
 

Received on Thursday, 2 June 2011 01:33:16 UTC