[Gd-chatter] r11365 - in trunk/gwydion: common/common-dylan common/io common/io/streams d2c/compiler/base d2c/compiler/main
agent at gwydiondylan.org
agent at gwydiondylan.org
Mon May 21 04:00:38 CEST 2007
Author: agent
Date: Mon May 21 04:00:34 2007
New Revision: 11365
Modified:
trunk/gwydion/common/common-dylan/byte-vector.dylan
trunk/gwydion/common/io/pprint.dylan
trunk/gwydion/common/io/streams/buffer.dylan
trunk/gwydion/common/io/streams/buffered-stream.dylan
trunk/gwydion/common/io/streams/native-buffer.dylan
trunk/gwydion/common/io/streams/sequence-stream.dylan
trunk/gwydion/common/io/streams/typed-stream.dylan
trunk/gwydion/d2c/compiler/base/header.dylan
trunk/gwydion/d2c/compiler/base/source.dylan
trunk/gwydion/d2c/compiler/base/utils.dylan
trunk/gwydion/d2c/compiler/main/evaluate.dylan
trunk/gwydion/d2c/compiler/main/lid-mode-state.dylan
trunk/gwydion/d2c/compiler/main/single-file-mode-state.dylan
Log:
Bug: 7352
Rationalized copy-bytes argument order and removed duplicate methods.
Modified: trunk/gwydion/common/common-dylan/byte-vector.dylan
==============================================================================
--- trunk/gwydion/common/common-dylan/byte-vector.dylan (original)
+++ trunk/gwydion/common/common-dylan/byte-vector.dylan Mon May 21 04:00:34 2007
@@ -54,11 +54,11 @@
end method;
//---*** It would sure be nice to have low-level run-time support for this
-define open generic copy-bytes (src, src-start, dst, dst-start, n) => ();
+define open generic copy-bytes (dst, dst-start, src, src-start, n) => ();
define open method copy-bytes
- (src :: <sequence>, src-start :: <integer>, dst :: <sequence>,
- dst-start :: <integer>, n :: <integer>)
+ (dst :: <sequence>, dst-start :: <integer>,
+ src :: <sequence>, src-start :: <integer>, n :: <integer>)
=> ()
for (i :: <integer> from 0 below n)
dst[dst-start + i] := src[src-start + i]
@@ -66,8 +66,8 @@
end method;
define open method copy-bytes
- (src :: <vector>, src-start :: <integer>, dst :: <vector>,
- dst-start :: <integer>, n :: <integer>)
+ (dst :: <vector>, dst-start :: <integer>,
+ src :: <vector>, src-start :: <integer>, n :: <integer>)
=> ()
for (i :: <integer> from 0 below n)
dst[dst-start + i] := src[src-start + i]
@@ -75,8 +75,8 @@
end method;
define open method copy-bytes
- (src :: <string>, src-start :: <integer>, dst :: <string>,
- dst-start :: <integer>, n :: <integer>)
+ (dst :: <string>, dst-start :: <integer>,
+ src :: <string>, src-start :: <integer>, n :: <integer>)
=> ()
for (i :: <integer> from 0 below n)
dst[dst-start + i] := src[src-start + i]
@@ -84,8 +84,8 @@
end method;
define open method copy-bytes
- (src :: <vector>, src-start :: <integer>, dst :: <string>,
- dst-start :: <integer>, n :: <integer>)
+ (dst :: <string>, dst-start :: <integer>,
+ src :: <vector>, src-start :: <integer>, n :: <integer>)
=> ()
for (i :: <integer> from 0 below n)
dst[dst-start + i] := as(<character>, src[src-start + i])
@@ -93,8 +93,8 @@
end method;
define open method copy-bytes
- (src :: <string>, src-start :: <integer>, dst :: <vector>,
- dst-start :: <integer>, n :: <integer>)
+ (dst :: <vector>, dst-start :: <integer>,
+ src :: <string>, src-start :: <integer>, n :: <integer>)
=> ()
for (i :: <integer> from 0 below n)
dst[dst-start + i] := as(<integer>, src[src-start + i])
@@ -109,55 +109,8 @@
end function;
define sealed method copy-bytes
- (src :: <byte-vector>, src-start :: <integer>, dst :: <byte-vector>,
- dst-start :: <integer>, n :: <integer>) => ()
- let src-end :: <integer> = src-start + n;
- let dst-end :: <integer> = dst-start + n;
- if (n >= 0 & src-start >= 0 & dst-start >= 0 & src-end <= size(src) & dst-end <= size(dst))
- %copy-bytes(dst, dst-start, src, src-start, n);
- else
- copy-bytes-range-error(src, src-start, dst, dst-start, n);
- end if;
-end method;
-
-define sealed method copy-bytes
- (src :: <byte-vector>, src-start :: <integer>, dst :: <byte-string>,
- dst-start :: <integer>, n :: <integer>) => ()
- let src-end :: <integer> = src-start + n;
- let dst-end :: <integer> = dst-start + n;
- if (n >= 0 & src-start >= 0 & dst-start >= 0 & src-end <= size(src) & dst-end <= size(dst))
- else
- copy-bytes-range-error(src, src-start, dst, dst-start, n);
- end if;
-end method;
-
-define sealed method copy-bytes
- (src :: <byte-string>, src-start :: <integer>, dst :: <byte-vector>,
- dst-start :: <integer>, n :: <integer>) => ()
- let src-end :: <integer> = src-start + n;
- let dst-end :: <integer> = dst-start + n;
- if (n >= 0 & src-start >= 0 & dst-start >= 0 & src-end <= size(src) & dst-end <= size(dst))
- %copy-bytes(dst, dst-start, src, src-start, n);
- else
- copy-bytes-range-error(src, src-start, dst, dst-start, n);
- end if;
-end method;
-
-define sealed method copy-bytes
- (src :: <byte-string>, src-start :: <integer>, dst :: <byte-string>,
- dst-start :: <integer>, n :: <integer>) => ()
- let src-end :: <integer> = src-start + n;
- let dst-end :: <integer> = dst-start + n;
- if (n >= 0 & src-start >= 0 & dst-start >= 0 & src-end <= size(src) & dst-end <= size(dst))
- %copy-bytes(dst, dst-start, src, src-start, n);
- else
- copy-bytes-range-error(src, src-start, dst, dst-start, n);
- end if;
-end method;
-
-define sealed method copy-bytes
- (src :: <simple-object-vector>, src-start :: <integer>,
- dst :: <byte-vector>, dst-start :: <integer>, n :: <integer>) => ()
+ (dst :: <byte-vector>, dst-start :: <integer>,
+ src :: <simple-object-vector>, src-start :: <integer>, n :: <integer>) => ()
let src-end :: <integer> = src-start + n;
let dst-end :: <integer> = dst-start + n;
if (n >= 0 & src-start >= 0 & dst-start >= 0 & src-end <= size(src) & dst-end <= size(dst))
@@ -171,9 +124,8 @@
end method;
define sealed method copy-bytes
- (src :: <byte-vector>, src-start :: <integer>,
- dst :: <simple-object-vector>, dst-start :: <integer>, n :: <integer>)
- => ()
+ (dst :: <simple-object-vector>, dst-start :: <integer>,
+ src :: <byte-vector>, src-start :: <integer>, n :: <integer>) => ()
let src-end :: <integer> = src-start + n;
let dst-end :: <integer> = dst-start + n;
if (n >= 0 & src-start >= 0 & dst-start >= 0 & src-end <= size(src) & dst-end <= size(dst))
Modified: trunk/gwydion/common/io/pprint.dylan
==============================================================================
--- trunk/gwydion/common/io/pprint.dylan (original)
+++ trunk/gwydion/common/io/pprint.dylan Mon May 21 04:00:34 2007
@@ -58,7 +58,7 @@
src ~== dst
=> // Use the standard "any which way" version, which is likely to be
// faster.
- copy-bytes(src, src-start, dst, dst-start, n);
+ copy-bytes(dst, dst-start, src, src-start, n);
src-start < 0 | src-start + n > size(src)
=> error("Source parameters for copy-maybe-overlapping-bytes from %= "
"are out of range - start at %d, copy %d bytes.",
@@ -321,7 +321,7 @@
let count = min(chars, available);
let fill-pointer = stream.pretty-stream-buffer-fill-pointer;
let new-fill-ptr = fill-pointer + count;
- copy-bytes(stuff, start, stream.pretty-stream-buffer, fill-pointer, count);
+ copy-bytes(stream.pretty-stream-buffer, fill-pointer, stuff, start, count);
stream.pretty-stream-buffer-fill-pointer := new-fill-ptr;
unless (count == chars)
append-raw-output(stream, stuff, start + count, stop);
@@ -400,8 +400,8 @@
// Therefore, set-indentation grew the prefix enough to put spaces in where
// we are about to put the per-line-prefix.
new-block.logical-block-per-line-prefix-end := column;
- copy-bytes(prefix, 0,
- stream.pretty-stream-prefix, column - prefix.size,
+ copy-bytes(stream.pretty-stream-prefix, column - prefix.size,
+ prefix, 0,
prefix.size);
end;
if (suffix)
@@ -414,15 +414,15 @@
= max(total-suffix-len * 2,
suffix-length + floor/(additional * 5, 4));
let new-total-suffix = make(<byte-string>, size: new-total-suffix-len);
- copy-bytes(total-suffix, total-suffix-len - suffix-length,
- new-total-suffix, new-total-suffix-len - suffix-length,
+ copy-bytes(new-total-suffix, new-total-suffix-len - suffix-length,
+ total-suffix, total-suffix-len - suffix-length,
suffix-length);
total-suffix := new-total-suffix;
total-suffix-len := new-total-suffix-len;
stream.pretty-stream-suffix := total-suffix;
end;
- copy-bytes(suffix, 0,
- total-suffix, total-suffix-len - new-suffix-len,
+ copy-bytes(total-suffix, total-suffix-len - new-suffix-len,
+ suffix, 0,
additional);
new-block.logical-block-suffix-length := new-suffix-len;
end;
@@ -445,7 +445,7 @@
let new-prefix-len
= max(prefix-len * 2, prefix-len + floor/((column - prefix-len) * 5, 4));
let new-prefix = make(<byte-string>, size: new-prefix-len);
- copy-bytes(prefix, 0, new-prefix, 0, current);
+ copy-bytes(new-prefix, 0, prefix, 0, current);
prefix := stream.pretty-stream-prefix := new-prefix;
end;
if (column > current)
@@ -854,7 +854,7 @@
stop := tabpos;
end;
unless (new-buffer == buffer)
- copy-bytes(buffer, 0, new-buffer, 0, stop);
+ copy-bytes(new-buffer, 0, buffer, 0, stop);
end;
end;
end;
@@ -886,7 +886,7 @@
let new-length = max(length * 2, length + floor/(want * 5, 4));
let new-buffer = make(<byte-string>, size: new-length);
stream.pretty-stream-buffer := new-buffer;
- copy-bytes(buffer, 0, new-buffer, 0, fill-ptr);
+ copy-bytes(new-buffer, 0, buffer, 0, fill-ptr);
new-length - fill-ptr;
end;
end;
@@ -1103,7 +1103,7 @@
copy-maybe-overlapping-bytes
(buffer, amount-to-consume, new-buffer, prefix-len,
fill-ptr - amount-to-consume);
- copy-bytes(stream.pretty-stream-prefix, 0, new-buffer, 0, prefix-len);
+ copy-bytes(new-buffer, 0, stream.pretty-stream-prefix, 0, prefix-len);
stream.pretty-stream-buffer-fill-pointer := new-fill-ptr;
stream.pretty-stream-buffer-offset
:= stream.pretty-stream-buffer-offset + shift;
@@ -1134,7 +1134,7 @@
write(stream.pretty-stream-target, buffer, start: 0, end: count);
stream.pretty-stream-buffer-start-column
:= stream.pretty-stream-buffer-start-column + count;
- copy-bytes(buffer, count, buffer, 0, new-fill-ptr);
+ copy-bytes(buffer, 0, buffer, count, new-fill-ptr);
stream.pretty-stream-buffer-fill-pointer := new-fill-ptr;
stream.pretty-stream-buffer-offset
:= stream.pretty-stream-buffer-offset + count;
Modified: trunk/gwydion/common/io/streams/buffer.dylan
==============================================================================
--- trunk/gwydion/common/io/streams/buffer.dylan (original)
+++ trunk/gwydion/common/io/streams/buffer.dylan Mon May 21 04:00:34 2007
@@ -134,7 +134,7 @@
=> (result :: <byte-string>)
let count = end-index - start-index;
let seq = make(<byte-string>, size: count);
- copy-bytes(buffer, start-index, seq, 0, count);
+ copy-bytes(seq, 0, buffer, start-index, count);
seq
end method buffer-subsequence;
@@ -144,7 +144,7 @@
=> (result :: <byte-vector>)
let count = end-index - start-index;
let seq = make(<byte-vector>, size: count);
- copy-bytes(buffer, start-index, seq, 0, count);
+ copy-bytes(seq, 0, buffer, start-index, count);
seq
end method buffer-subsequence;
@@ -176,21 +176,21 @@
(buffer :: <buffer>, buffer-start-index :: <buffer-index>,
sequence :: <byte-string>,
#key start: start-index = 0, end: end-index = sequence.size) => ()
- copy-bytes(sequence, start-index, buffer, buffer-start-index, end-index - start-index)
+ copy-bytes(buffer, buffer-start-index, sequence, start-index, end-index - start-index)
end method copy-into-buffer!;
define sealed method copy-into-buffer!
(buffer :: <buffer>, buffer-start-index :: <buffer-index>,
sequence :: <byte-vector>,
#key start: start-index = 0, end: end-index = sequence.size) => ()
- copy-bytes(sequence, start-index, buffer, buffer-start-index, end-index - start-index)
+ copy-bytes(buffer, buffer-start-index, sequence, start-index, end-index - start-index)
end method copy-into-buffer!;
define sealed method copy-into-buffer!
(buffer :: <buffer>, buffer-start-index :: <buffer-index>,
sequence :: <buffer>,
#key start: start-index = 0, end: end-index = sequence.size) => ()
- copy-bytes(sequence, start-index, buffer, buffer-start-index, end-index - start-index)
+ copy-bytes(buffer, buffer-start-index, sequence, start-index, end-index - start-index)
end method copy-into-buffer!;
@@ -204,14 +204,14 @@
(buffer :: <buffer>, buffer-start-index :: <buffer-index>,
sequence :: <byte-string>,
#key start: start-index = 0, end: end-index = sequence.size) => ()
- copy-bytes(buffer, buffer-start-index, sequence, start-index, end-index - start-index)
+ copy-bytes(sequence, start-index, buffer, buffer-start-index, end-index - start-index)
end method copy-from-buffer!;
define sealed method copy-from-buffer!
(buffer :: <buffer>, buffer-start-index :: <buffer-index>,
sequence :: <byte-vector>,
#key start: start-index = 0, end: end-index = sequence.size) => ()
- copy-bytes(buffer, buffer-start-index, sequence, start-index, end-index - start-index)
+ copy-bytes(sequence, start-index, buffer, buffer-start-index, end-index - start-index)
end method copy-from-buffer!;
//
Modified: trunk/gwydion/common/io/streams/buffered-stream.dylan
==============================================================================
--- trunk/gwydion/common/io/streams/buffered-stream.dylan (original)
+++ trunk/gwydion/common/io/streams/buffered-stream.dylan Mon May 21 04:00:34 2007
@@ -532,13 +532,13 @@
if (line)
let new = make(stream-sequence-class(stream),
size: line.size + i - bi);
- copy-bytes(line, 0, new, 0, line.size);
- copy-bytes(sb, bi, new, line.size, i - bi);
+ copy-bytes(new, 0, line, 0, line.size);
+ copy-bytes(new, line.size, sb, bi, i - bi);
line := new
else
line := make(stream-sequence-class(stream),
size: i - bi);
- copy-bytes(sb, bi, line, 0, i - bi)
+ copy-bytes(line, 0, sb, bi, i - bi)
end
end method;
iterate loop (sb :: false-or(<buffer>) = sb)
Modified: trunk/gwydion/common/io/streams/native-buffer.dylan
==============================================================================
--- trunk/gwydion/common/io/streams/native-buffer.dylan (original)
+++ trunk/gwydion/common/io/streams/native-buffer.dylan Mon May 21 04:00:34 2007
@@ -245,8 +245,8 @@
end function;
define sealed method copy-bytes
- (src :: <buffer>, src-start :: <integer>, dst :: <byte-string>,
- dst-start :: <integer>, n :: <integer>) => ()
+ (dst :: <byte-string>, dst-start :: <integer>,
+ src :: <buffer>, src-start :: <integer>, n :: <integer>) => ()
let src-end :: <integer> = src-start + n;
let dst-end :: <integer> = dst-start + n;
if (n >= 0 & src-start >= 0 & dst-start >= 0 & src-end <= size(src) & dst-end <= size(dst))
@@ -260,8 +260,8 @@
end method;
define sealed method copy-bytes
- (src :: <byte-string>, src-start :: <integer>, dst :: <buffer>,
- dst-start :: <integer>, n :: <integer>) => ()
+ (dst :: <buffer>, dst-start :: <integer>,
+ src :: <byte-string>, src-start :: <integer>, n :: <integer>) => ()
let src-end :: <integer> = src-start + n;
let dst-end :: <integer> = dst-start + n;
if (n >= 0 & src-start >= 0 & dst-start >= 0 & src-end <= size(src)
@@ -276,8 +276,8 @@
end method;
define sealed method copy-bytes
- (src :: <buffer>, src-start :: <integer>, dst :: <buffer>,
- dst-start :: <integer>, n :: <integer>) => ()
+ (dst :: <buffer>, dst-start :: <integer>,
+ src :: <buffer>, src-start :: <integer>, n :: <integer>) => ()
let src-end :: <integer> = src-start + n;
let dst-end :: <integer> = dst-start + n;
if (n >= 0 & src-start >= 0 & dst-start >= 0 & src-end <= size(src) & dst-end <= size(dst))
@@ -291,8 +291,8 @@
end method;
define sealed method copy-bytes
- (src :: <buffer>, src-start :: <integer>, dst :: <byte-vector>,
- dst-start :: <integer>, n :: <integer>) => ()
+ (dst :: <byte-vector>, dst-start :: <integer>,
+ src :: <buffer>, src-start :: <integer>, n :: <integer>) => ()
let src-end :: <integer> = src-start + n;
let dst-end :: <integer> = dst-start + n;
if (n >= 0 & src-start >= 0 & dst-start >= 0 & src-end <= size(src) & dst-end <= size(dst))
@@ -306,8 +306,8 @@
end method;
define sealed method copy-bytes
- (src :: <byte-vector>, src-start :: <integer>, dst :: <buffer>,
- dst-start :: <integer>, n :: <integer>) => ()
+ (dst :: <buffer>, dst-start :: <integer>,
+ src :: <byte-vector>, src-start :: <integer>, n :: <integer>) => ()
let src-end :: <integer> = src-start + n;
let dst-end :: <integer> = dst-start + n;
if (n >= 0 & src-start >= 0 & dst-start >= 0 & src-end <= size(src)
@@ -322,8 +322,8 @@
end method;
define sealed method copy-bytes
- (src :: <simple-object-vector>, src-start :: <integer>,
- dst :: <buffer>, dst-start :: <integer>, n :: <integer>) => ()
+ (dst :: <buffer>, dst-start :: <integer>,
+ src :: <simple-object-vector>, src-start :: <integer>, n :: <integer>) => ()
let src-end :: <integer> = src-start + n;
let dst-end :: <integer> = dst-start + n;
if (n >= 0 & src-start >= 0 & dst-start >= 0 & src-end <= size(src) & dst-end <= size(dst))
@@ -337,8 +337,8 @@
end method;
define sealed method copy-bytes
- (src :: <buffer>, src-start :: <integer>,
- dst :: <simple-object-vector>, dst-start :: <integer>, n :: <integer>)
+ (dst :: <simple-object-vector>, dst-start :: <integer>,
+ src :: <buffer>, src-start :: <integer>, n :: <integer>)
=> ()
let src-end :: <integer> = src-start + n;
let dst-end :: <integer> = dst-start + n;
Modified: trunk/gwydion/common/io/streams/sequence-stream.dylan
==============================================================================
--- trunk/gwydion/common/io/streams/sequence-stream.dylan (original)
+++ trunk/gwydion/common/io/streams/sequence-stream.dylan Mon May 21 04:00:34 2007
@@ -189,7 +189,7 @@
let src-n :: <integer> = (stream-limit(stream) | stream.final-position) - pos;
let dst-n :: <integer> = dst.size - start;
let n-read :: <integer> = min(n, src-n, dst-n);
- copy-bytes(seq, pos, dst, start, n-read);
+ copy-bytes(dst, start, seq, pos, n-read);
stream.current-position := pos + n-read;
if (n > src-n & dst-n > src-n
& unsupplied?(on-end-of-stream))
@@ -242,7 +242,7 @@
dst := grow-for-stream(dst, required-space);
stream-sequence(stream) := dst
end;
- copy-bytes(src, start-index, dst, pos, count);
+ copy-bytes(dst, pos, src, start-index, count);
let new-pos = pos + count;
stream.current-position := new-pos;
if (new-pos > stream.final-position)
@@ -255,7 +255,7 @@
=> (new-seq :: <sequence>)
let n :: <integer> = seq.size;
let new-seq = make(object-class(seq), size: max(min-size, 2 * n));
- copy-bytes(seq, 0, new-seq, 0, n);
+ copy-bytes(new-seq, 0, seq, 0, n);
new-seq
end method grow-for-stream;
@@ -304,7 +304,7 @@
let _end = stream-limit(stream) | stream.final-position;
let n = _end - _start;
let result = make(type, size: n);
- copy-bytes(stream-sequence(stream), _start, result, 0, n);
+ copy-bytes(result, 0, stream-sequence(stream), _start, n);
if (clear-contents?)
clear-contents(stream)
end;
Modified: trunk/gwydion/common/io/streams/typed-stream.dylan
==============================================================================
--- trunk/gwydion/common/io/streams/typed-stream.dylan (original)
+++ trunk/gwydion/common/io/streams/typed-stream.dylan Mon May 21 04:00:34 2007
@@ -29,8 +29,10 @@
slot sequence-type /* ---*** :: subclass(<sequence>) */ = <byte-string>;
slot to-element-mapper :: <function> = byte-to-byte-char;
slot from-element-mapper :: <function> = byte-char-to-byte;
- constant slot to-sequence-mapper :: <function> = copy-bytes;
- constant slot from-sequence-mapper :: <function> = copy-bytes;
+ constant slot to-sequence-mapper :: <function> =
+ method (s, ss, d, ds, n)=>() copy-bytes(d, ds, s, ss, n) end;
+ constant slot from-sequence-mapper :: <function> =
+ method (s, ss, d, ds, n)=>() copy-bytes(d, ds, s, ss, n) end;
end class <typed-stream>;
define open abstract class <general-typed-stream> (<typed-stream>)
@@ -141,7 +143,7 @@
buffer :: <buffer>, buf-start :: <integer>,
sequence :: <sequence>, seq-start :: <integer>,
count :: <integer>) => ()
- copy-bytes(buffer, buf-start, sequence, seq-start, count)
+ copy-bytes(sequence, seq-start, buffer, buf-start, count)
end method coerce-to-sequence;
define sealed inline method coerce-to-sequence
@@ -149,7 +151,7 @@
buffer :: <buffer>, buf-start :: <integer>,
sequence :: <sequence>, seq-start :: <integer>,
count :: <integer>) => ()
- copy-bytes(buffer, buf-start, sequence, seq-start, count)
+ copy-bytes(sequence, seq-start, buffer, buf-start, count)
end method coerce-to-sequence;
define method coerce-to-sequence
@@ -157,7 +159,7 @@
buffer :: <buffer>, buf-start :: <integer>,
sequence :: <sequence>, seq-start :: <integer>,
count :: <integer>) => ()
- copy-bytes(buffer, buf-start, sequence, seq-start, count)
+ copy-bytes(sequence, seq-start, buffer, buf-start, count)
end method coerce-to-sequence;
@@ -180,7 +182,7 @@
buffer :: <buffer>, buf-start :: <integer>,
sequence :: <sequence>, seq-start :: <integer>,
count :: <integer>) => ()
- copy-bytes(sequence, seq-start, buffer, buf-start, count)
+ copy-bytes(buffer, buf-start, sequence, seq-start, count)
end method coerce-from-sequence;
define sealed inline method coerce-from-sequence
@@ -188,7 +190,7 @@
buffer :: <buffer>, buf-start :: <integer>,
sequence :: <sequence>, seq-start :: <integer>,
count :: <integer>) => ()
- copy-bytes(sequence, seq-start, buffer, buf-start, count)
+ copy-bytes(buffer, buf-start, sequence, seq-start, count)
end method coerce-from-sequence;
define method coerce-from-sequence
@@ -196,5 +198,5 @@
buffer :: <buffer>, buf-start :: <integer>,
sequence :: <sequence>, seq-start :: <integer>,
count :: <integer>) => ()
- copy-bytes(sequence, seq-start, buffer, buf-start, count)
+ copy-bytes(buffer, buf-start, sequence, seq-start, count)
end method coerce-from-sequence;
Modified: trunk/gwydion/d2c/compiler/base/header.dylan
==============================================================================
--- trunk/gwydion/d2c/compiler/base/header.dylan (original)
+++ trunk/gwydion/d2c/compiler/base/header.dylan Mon May 21 04:00:34 2007
@@ -326,7 +326,7 @@
if (char == ':')
let len = posn - start;
let str = make(<byte-string>, size: len);
- copy-bytes(contents, start, str, 0, len);
+ copy-bytes(str, 0, contents, start, len);
values(as(<symbol>, str), posn + 1);
elseif (alphanumeric?(char) | char == '-' | char == '?' | char == ' ')
repeat(posn + 1);
@@ -370,8 +370,8 @@
let value-start = min(ws-end, newline, value-end);
let len = value-end - value-start + if (continued?) 1 else 0 end;
let result = make(<byte-string>, size: len + prefix.size);
- copy-bytes(prefix, 0, result, 0, prefix.size);
- copy-bytes(contents, value-start, result, prefix.size, len);
+ copy-bytes(result, 0, prefix, 0, prefix.size);
+ copy-bytes(result, prefix.size, contents, value-start, len);
if (continued?)
result.last := '\n';
repeat(newline + 1, line + 1, result);
Modified: trunk/gwydion/d2c/compiler/base/source.dylan
==============================================================================
--- trunk/gwydion/d2c/compiler/base/source.dylan (original)
+++ trunk/gwydion/d2c/compiler/base/source.dylan Mon May 21 04:00:34 2007
@@ -132,7 +132,7 @@
finally
let len = index - line-start;
let result = make(<byte-string>, size: len);
- copy-bytes(contents, line-start, result, 0, len);
+ copy-bytes(result, 0, contents, line-start, len);
result;
end for;
end method extract-line;
@@ -417,7 +417,7 @@
let len = finish - start;
if (len.positive?)
let result = make(<string>, size: len);
- copy-bytes(source-location.source.contents, start, result, 0, len);
+ copy-bytes(result, 0, source-location.source.contents, start, len);
result;
else
"";
Modified: trunk/gwydion/d2c/compiler/base/utils.dylan
==============================================================================
--- trunk/gwydion/d2c/compiler/base/utils.dylan (original)
+++ trunk/gwydion/d2c/compiler/base/utils.dylan Mon May 21 04:00:34 2007
@@ -313,7 +313,7 @@
let result = make(<byte-string>, size: length + pieces.size - 1, fill: ' ');
for (piece :: <byte-string> in pieces,
index = 0 then index + piece.size + 1)
- copy-bytes(piece, 0, result, index, piece.size);
+ copy-bytes(result, index, piece, 0, piece.size);
end for;
result;
end method integer-to-english;
@@ -595,7 +595,7 @@
(res :: <byte-string>, offset :: <integer>, what :: <byte-string>)
=> new-offset :: <integer>;
let len = what.size;
- copy-bytes(what, 0, res, offset, len);
+ copy-bytes(res, offset, what, 0, len);
offset + len;
end method append;
Modified: trunk/gwydion/d2c/compiler/main/evaluate.dylan
==============================================================================
--- trunk/gwydion/d2c/compiler/main/evaluate.dylan (original)
+++ trunk/gwydion/d2c/compiler/main/evaluate.dylan Mon May 21 04:00:34 2007
@@ -135,7 +135,7 @@
*/
*top-level-forms* := make(<stretchy-vector>);
let expression-buffer = make(<buffer>, size: expression.size);
- copy-bytes(expression, 0, expression-buffer, 0, expression.size);
+ copy-bytes(expression-buffer, 0, expression, 0, expression.size);
let tokenizer = make(<lexer>,
module: *Current-Module*,
Modified: trunk/gwydion/d2c/compiler/main/lid-mode-state.dylan
==============================================================================
--- trunk/gwydion/d2c/compiler/main/lid-mode-state.dylan (original)
+++ trunk/gwydion/d2c/compiler/main/lid-mode-state.dylan Mon May 21 04:00:34 2007
@@ -127,7 +127,7 @@
let name-end = find-end-of-word(posn);
let len = name-end - posn;
let name = make(<byte-string>, size: len);
- copy-bytes(contents, posn, name, 0, len);
+ copy-bytes(name, 0, contents, posn, len);
add!(files, name);
repeat(name-end);
end;
Modified: trunk/gwydion/d2c/compiler/main/single-file-mode-state.dylan
==============================================================================
--- trunk/gwydion/d2c/compiler/main/single-file-mode-state.dylan (original)
+++ trunk/gwydion/d2c/compiler/main/single-file-mode-state.dylan Mon May 21 04:00:34 2007
@@ -108,7 +108,7 @@
let libmod-declaration
= format-to-string("%s %s\n\n", lib-string, mod-string);
let libmod-buffer = make(<buffer>, size: libmod-declaration.size);
- copy-bytes(libmod-declaration, 0, libmod-buffer, 0, libmod-declaration.size);
+ copy-bytes(libmod-buffer, 0, libmod-declaration, 0, libmod-declaration.size);
// XXX these two look suspicious
// second one is ok, default is now according to DRM
More information about the chatter
mailing list