www/philosophy/po stallman-kth.fr.po stallman-k...

[GNUN]

CVSROOT:        /web/www
Module name:    www
Changes by:     GNUN <gnun>     21/09/14 16:03:34

Modified files:
        philosophy/po  : stallman-kth.fr.po stallman-kth.pot 
                         stallman-kth.ru.po 

Log message:
        Automatic update by GNUnited Nations.

CVSWeb URLs:
http://web.cvs.savannah.gnu.org/viewcvs/www/philosophy/po/stallman-kth.fr.po?cvsroot=www&r1=1.55&r2=1.56
http://web.cvs.savannah.gnu.org/viewcvs/www/philosophy/po/stallman-kth.pot?cvsroot=www&r1=1.17&r2=1.18
http://web.cvs.savannah.gnu.org/viewcvs/www/philosophy/po/stallman-kth.ru.po?cvsroot=www&r1=1.20&r2=1.21

Patches:
Index: stallman-kth.fr.po
===================================================================
RCS file: /web/www/www/philosophy/po/stallman-kth.fr.po,v
retrieving revision 1.55
retrieving revision 1.56
diff -u -b -r1.55 -r1.56
--- stallman-kth.fr.po  14 Sep 2021 16:34:10 -0000      1.55
+++ stallman-kth.fr.po  14 Sep 2021 20:03:34 -0000      1.56
@@ -9,7 +9,7 @@
 msgid ""
 msgstr ""
 "Project-Id-Version: stallman-kth\n"
-"POT-Creation-Date: 2021-09-14 16:26+0000\n"
+"POT-Creation-Date: 2021-09-14 19:56+0000\n"
 "PO-Revision-Date: 2021-01-26 13:46+0100\n"
 "Last-Translator: Thérèse Godefroy <godef.th AT free.fr>\n"
 "Language-Team: French <trad-gnu@april.org>\n"
@@ -2025,10 +2025,10 @@
 # | breakpoint, so that's a cheap way of having it break the tenth time the
 # | breakpoint is hit, you can do [-&ldquo;$foo--==0&rdquo;.-]
 # | {+<code>$foo--==0</code>.+}  Does everyone follow that? Decrement foo and
-# | if it's zero now, break.  And then you set $foo to the number of times you
-# | want it to skip, and you let it go.  You can also use that to examine
-# | elements of an array.  Suppose you have an array of pointers, you can then
-# | do:
+# | if it's zero now, break.  And then you set [-$foo-] {+<code>$foo</code>+}
+# | to the number of times you want it to skip, and you let it go.  You can
+# | also use that to examine elements of an array.  Suppose you have an array
+# | of pointers, you can then do:
 #, fuzzy
 #| msgid ""
 #| "There are also explicitly settable variables in the debugger, any number "
@@ -2073,9 +2073,10 @@
 "do.  You can even do this in a conditional breakpoint, so that's a cheap way "
 "of having it break the tenth time the breakpoint is hit, you can do <code>"
 "$foo--==0</code>.  Does everyone follow that? Decrement foo and if it's zero "
-"now, break.  And then you set $foo to the number of times you want it to "
-"skip, and you let it go.  You can also use that to examine elements of an "
-"array.  Suppose you have an array of pointers, you can then do:"
+"now, break.  And then you set <code>$foo</code> to the number of times you "
+"want it to skip, and you let it go.  You can also use that to examine "
+"elements of an array.  Suppose you have an array of pointers, you can then "
+"do:"
 msgstr ""
 "Vous pouvez aussi définir des variables de façon explicite dans le "
 "débogueur, en nombre illimité. Vous posez le signe dollar suivi d'un nom et 
"
@@ -2123,7 +2124,7 @@
 
 #. type: Content of: <div><p>
 # | Okay, when you do that [points at the [-&ldquo;Print&rdquo;-]
-# | {+<code>Print</code>+} expression], you get the zeroth element of X, and
+# | {+<code>PRINT</code>+} expression], you get the zeroth element of X, and
 # | then you do it again and it gets the first element, and suppose these are
 # | pointers to structures, then you probably put an asterisk there [before
 # | the X in the PRINT expression] and each time it prints the next structure
@@ -2163,7 +2164,7 @@
 #| "that they get handled by the &ldquo;help&rdquo; features just like the "
 #| "built-in commands."
 msgid ""
-"Okay, when you do that [points at the <code>Print</code> expression], you "
+"Okay, when you do that [points at the <code>PRINT</code> expression], you "
 "get the zeroth element of X, and then you do it again and it gets the first "
 "element, and suppose these are pointers to structures, then you probably put "
 "an asterisk there [before the X in the PRINT expression] and each time it "
@@ -2422,10 +2423,36 @@
 "donne pour l'instruction combinée une expression algébrique plus 
compliquée."
 
 #. type: Content of: <div><p>
+# | Sometimes depending on whether the result of the first instruction had any
+# | further use, it might be necessary to make a combined instruction with two
+# | assignment operators.  One for this value [pointing at ???]{+ +}and
+# | another one with this value [pointing at ???] substituted in it with what
+# | came from the second instruction.  But if this value was only used that
+# | once, you could eliminate it after substituting for it; there'd be no need
+# | to compute it any more.  So it's actually somewhat complicated doing the
+# | substitution correctly checking that the intervening instructions don't
+# | change any of these values and other such things.  When you support such
+# | things as auto-increment and auto-decrement addressing, which I do now,
+# | you also have to do various checks for those to check for situations where
+# | what you're doing is not value preserving.
+#, fuzzy
+#| msgid ""
+#| "Sometimes depending on whether the result of the first instruction had "
+#| "any further use, it might be necessary to make a combined instruction "
+#| "with two assignment operators.  One for this value [pointing at ???]and "
+#| "another one with this value [pointing at ???] substituted in it with what "
+#| "came from the second instruction.  But if this value was only used that "
+#| "once, you could eliminate it after substituting for it; there'd be no "
+#| "need to compute it any more.  So it's actually somewhat complicated doing "
+#| "the substitution correctly checking that the intervening instructions "
+#| "don't change any of these values and other such things.  When you support "
+#| "such things as auto-increment and auto-decrement addressing, which I do "
+#| "now, you also have to do various checks for those to check for situations "
+#| "where what you're doing is not value preserving."
 msgid ""
 "Sometimes depending on whether the result of the first instruction had any "
 "further use, it might be necessary to make a combined instruction with two "
-"assignment operators.  One for this value [pointing at ???]and another one "
+"assignment operators.  One for this value [pointing at ???] and another one "
 "with this value [pointing at ???] substituted in it with what came from the "
 "second instruction.  But if this value was only used that once, you could "
 "eliminate it after substituting for it; there'd be no need to compute it any "

Index: stallman-kth.pot
===================================================================
RCS file: /web/www/www/philosophy/po/stallman-kth.pot,v
retrieving revision 1.17
retrieving revision 1.18
diff -u -b -r1.17 -r1.18
--- stallman-kth.pot    14 Sep 2021 16:34:10 -0000      1.17
+++ stallman-kth.pot    14 Sep 2021 20:03:34 -0000      1.18
@@ -7,7 +7,7 @@
 msgid ""
 msgstr ""
 "Project-Id-Version: stallman-kth.html\n"
-"POT-Creation-Date: 2021-09-14 16:26+0000\n"
+"POT-Creation-Date: 2021-09-14 19:56+0000\n"
 "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
 "Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
 "Language-Team: LANGUAGE <LL@li.org>\n"
@@ -834,9 +834,10 @@
 "do.  You can even do this in a conditional breakpoint, so that's a cheap way "
 "of having it break the tenth time the breakpoint is hit, you can do "
 "<code>$foo--==0</code>.  Does everyone follow that? Decrement foo and if "
-"it's zero now, break.  And then you set $foo to the number of times you want "
-"it to skip, and you let it go.  You can also use that to examine elements of "
-"an array.  Suppose you have an array of pointers, you can then do:"
+"it's zero now, break.  And then you set <code>$foo</code> to the number of "
+"times you want it to skip, and you let it go.  You can also use that to "
+"examine elements of an array.  Suppose you have an array of pointers, you "
+"can then do:"
 msgstr ""
 
 #. type: Content of: <div><pre>
@@ -855,7 +856,7 @@
 
 #. type: Content of: <div><p>
 msgid ""
-"Okay, when you do that [points at the <code>Print</code> expression], you "
+"Okay, when you do that [points at the <code>PRINT</code> expression], you "
 "get the zeroth element of X, and then you do it again and it gets the first "
 "element, and suppose these are pointers to structures, then you probably put "
 "an asterisk there [before the X in the PRINT expression] and each time it "
@@ -991,7 +992,7 @@
 msgid ""
 "Sometimes depending on whether the result of the first instruction had any "
 "further use, it might be necessary to make a combined instruction with two "
-"assignment operators.  One for this value [pointing at ???]and another one "
+"assignment operators.  One for this value [pointing at ???] and another one "
 "with this value [pointing at ???] substituted in it with what came from the "
 "second instruction.  But if this value was only used that once, you could "
 "eliminate it after substituting for it; there'd be no need to compute it any "

Index: stallman-kth.ru.po
===================================================================
RCS file: /web/www/www/philosophy/po/stallman-kth.ru.po,v
retrieving revision 1.20
retrieving revision 1.21
diff -u -b -r1.20 -r1.21
--- stallman-kth.ru.po  14 Sep 2021 16:34:10 -0000      1.20
+++ stallman-kth.ru.po  14 Sep 2021 20:03:34 -0000      1.21
@@ -7,7 +7,7 @@
 msgid ""
 msgstr ""
 "Project-Id-Version: stallman-kth.html\n"
-"POT-Creation-Date: 2021-09-14 16:26+0000\n"
+"POT-Creation-Date: 2021-09-14 19:56+0000\n"
 "PO-Revision-Date: 2020-07-01 17:17+0000\n"
 "Last-Translator: Ineiev <ineiev@gnu.org>\n"
 "Language-Team: Russian <www-ru-list@gnu.org>\n"
@@ -2024,10 +2024,10 @@
 # | breakpoint, so that's a cheap way of having it break the tenth time the
 # | breakpoint is hit, you can do [-&ldquo;$foo--==0&rdquo;.-]
 # | {+<code>$foo--==0</code>.+}  Does everyone follow that? Decrement foo and
-# | if it's zero now, break.  And then you set $foo to the number of times you
-# | want it to skip, and you let it go.  You can also use that to examine
-# | elements of an array.  Suppose you have an array of pointers, you can then
-# | do:
+# | if it's zero now, break.  And then you set [-$foo-] {+<code>$foo</code>+}
+# | to the number of times you want it to skip, and you let it go.  You can
+# | also use that to examine elements of an array.  Suppose you have an array
+# | of pointers, you can then do:
 #, fuzzy
 #| msgid ""
 #| "There are also explicitly settable variables in the debugger, any number "
@@ -2072,9 +2072,10 @@
 "do.  You can even do this in a conditional breakpoint, so that's a cheap way "
 "of having it break the tenth time the breakpoint is hit, you can do <code>"
 "$foo--==0</code>.  Does everyone follow that? Decrement foo and if it's zero "
-"now, break.  And then you set $foo to the number of times you want it to "
-"skip, and you let it go.  You can also use that to examine elements of an "
-"array.  Suppose you have an array of pointers, you can then do:"
+"now, break.  And then you set <code>$foo</code> to the number of times you "
+"want it to skip, and you let it go.  You can also use that to examine "
+"elements of an array.  Suppose you have an array of pointers, you can then "
+"do:"
 msgstr ""
 "Ещё в отладчике есть переменные, которые 
можно явно присваивать, любое число "
 "переменных. Ты говоришь знак доллара с 
последующим именем, и это&nbsp;"
@@ -2123,7 +2124,7 @@
 # type: Content of: <p>
 #. type: Content of: <div><p>
 # | Okay, when you do that [points at the [-&ldquo;Print&rdquo;-]
-# | {+<code>Print</code>+} expression], you get the zeroth element of X, and
+# | {+<code>PRINT</code>+} expression], you get the zeroth element of X, and
 # | then you do it again and it gets the first element, and suppose these are
 # | pointers to structures, then you probably put an asterisk there [before
 # | the X in the PRINT expression] and each time it prints the next structure
@@ -2163,7 +2164,7 @@
 #| "that they get handled by the &ldquo;help&rdquo; features just like the "
 #| "built-in commands."
 msgid ""
-"Okay, when you do that [points at the <code>Print</code> expression], you "
+"Okay, when you do that [points at the <code>PRINT</code> expression], you "
 "get the zeroth element of X, and then you do it again and it gets the first "
 "element, and suppose these are pointers to structures, then you probably put "
 "an asterisk there [before the X in the PRINT expression] and each time it "
@@ -2424,10 +2425,36 @@
 
 # type: Content of: <p>
 #. type: Content of: <div><p>
+# | Sometimes depending on whether the result of the first instruction had any
+# | further use, it might be necessary to make a combined instruction with two
+# | assignment operators.  One for this value [pointing at ???]{+ +}and
+# | another one with this value [pointing at ???] substituted in it with what
+# | came from the second instruction.  But if this value was only used that
+# | once, you could eliminate it after substituting for it; there'd be no need
+# | to compute it any more.  So it's actually somewhat complicated doing the
+# | substitution correctly checking that the intervening instructions don't
+# | change any of these values and other such things.  When you support such
+# | things as auto-increment and auto-decrement addressing, which I do now,
+# | you also have to do various checks for those to check for situations where
+# | what you're doing is not value preserving.
+#, fuzzy
+#| msgid ""
+#| "Sometimes depending on whether the result of the first instruction had "
+#| "any further use, it might be necessary to make a combined instruction "
+#| "with two assignment operators.  One for this value [pointing at ???]and "
+#| "another one with this value [pointing at ???] substituted in it with what "
+#| "came from the second instruction.  But if this value was only used that "
+#| "once, you could eliminate it after substituting for it; there'd be no "
+#| "need to compute it any more.  So it's actually somewhat complicated doing "
+#| "the substitution correctly checking that the intervening instructions "
+#| "don't change any of these values and other such things.  When you support "
+#| "such things as auto-increment and auto-decrement addressing, which I do "
+#| "now, you also have to do various checks for those to check for situations "
+#| "where what you're doing is not value preserving."
 msgid ""
 "Sometimes depending on whether the result of the first instruction had any "
 "further use, it might be necessary to make a combined instruction with two "
-"assignment operators.  One for this value [pointing at ???]and another one "
+"assignment operators.  One for this value [pointing at ???] and another one "
 "with this value [pointing at ???] substituted in it with what came from the "
 "second instruction.  But if this value was only used that once, you could "
 "eliminate it after substituting for it; there'd be no need to compute it any "