Instruction stringlengths 45 106 | input_code stringlengths 1 13.7k | output_code stringlengths 1 13.7k |
|---|---|---|
Change the following Racket code into VB without altering its purpose. | (terminal-port? (current-output-port))
| Module Module1
Sub Main()
Console.WriteLine("Stdout is tty: {0}", Console.IsOutputRedirected)
End Sub
End Module
|
Keep all operations the same but rewrite the snippet in Go. | (terminal-port? (current-output-port))
| package main
import (
"os"
"fmt"
)
func main() {
if fileInfo, _ := os.Stdout.Stat(); (fileInfo.Mode() & os.ModeCharDevice) != 0 {
fmt.Println("Hello terminal")
} else {
fmt.Println("Who are you? You're not a terminal")
}
}
|
Produce a functionally identical Go code for the snippet given in Racket. | (terminal-port? (current-output-port))
| package main
import (
"os"
"fmt"
)
func main() {
if fileInfo, _ := os.Stdout.Stat(); (fileInfo.Mode() & os.ModeCharDevice) != 0 {
fmt.Println("Hello terminal")
} else {
fmt.Println("Who are you? You're not a terminal")
}
}
|
Produce a functionally identical C code for the snippet given in COBOL. |
identification division.
program-id. istty.
data division.
working-storage section.
01 rc usage binary-long.
procedure division.
sample-main.
call "isatty" using by value 0 returning rc
display "fd 0 tty: " rc
c... | #include <unistd.h>
#include <stdio.h>
int main()
{
puts(isatty(fileno(stdout))
? "stdout is tty"
: "stdout is not tty");
return 0;
}
|
Transform the following COBOL implementation into C, maintaining the same output and logic. |
identification division.
program-id. istty.
data division.
working-storage section.
01 rc usage binary-long.
procedure division.
sample-main.
call "isatty" using by value 0 returning rc
display "fd 0 tty: " rc
c... | #include <unistd.h>
#include <stdio.h>
int main()
{
puts(isatty(fileno(stdout))
? "stdout is tty"
: "stdout is not tty");
return 0;
}
|
Produce a functionally identical C# code for the snippet given in COBOL. |
identification division.
program-id. istty.
data division.
working-storage section.
01 rc usage binary-long.
procedure division.
sample-main.
call "isatty" using by value 0 returning rc
display "fd 0 tty: " rc
c... | using System;
namespace CheckTerminal {
class Program {
static void Main(string[] args) {
Console.WriteLine("Stdout is tty: {0}", Console.IsOutputRedirected);
}
}
}
|
Generate an equivalent C# version of this COBOL code. |
identification division.
program-id. istty.
data division.
working-storage section.
01 rc usage binary-long.
procedure division.
sample-main.
call "isatty" using by value 0 returning rc
display "fd 0 tty: " rc
c... | using System;
namespace CheckTerminal {
class Program {
static void Main(string[] args) {
Console.WriteLine("Stdout is tty: {0}", Console.IsOutputRedirected);
}
}
}
|
Preserve the algorithm and functionality while converting the code from COBOL to C++. |
identification division.
program-id. istty.
data division.
working-storage section.
01 rc usage binary-long.
procedure division.
sample-main.
call "isatty" using by value 0 returning rc
display "fd 0 tty: " rc
c... | #if _WIN32
#include <io.h>
#define ISATTY _isatty
#define FILENO _fileno
#else
#include <unistd.h>
#define ISATTY isatty
#define FILENO fileno
#endif
#include <iostream>
int main() {
if (ISATTY(FILENO(stdout))) {
std::cout << "stdout is a tty\n";
} else {
std::cout << "stdout is not a tty\n";
... |
Can you help me rewrite this code in C++ instead of COBOL, keeping it the same logically? |
identification division.
program-id. istty.
data division.
working-storage section.
01 rc usage binary-long.
procedure division.
sample-main.
call "isatty" using by value 0 returning rc
display "fd 0 tty: " rc
c... | #if _WIN32
#include <io.h>
#define ISATTY _isatty
#define FILENO _fileno
#else
#include <unistd.h>
#define ISATTY isatty
#define FILENO fileno
#endif
#include <iostream>
int main() {
if (ISATTY(FILENO(stdout))) {
std::cout << "stdout is a tty\n";
} else {
std::cout << "stdout is not a tty\n";
... |
Transform the following COBOL implementation into Python, maintaining the same output and logic. |
identification division.
program-id. istty.
data division.
working-storage section.
01 rc usage binary-long.
procedure division.
sample-main.
call "isatty" using by value 0 returning rc
display "fd 0 tty: " rc
c... | from sys import stdout
if stdout.isatty():
print 'The output device is a teletype. Or something like a teletype.'
else:
print 'The output device isn\'t like a teletype.'
|
Change the programming language of this snippet from COBOL to Python without modifying what it does. |
identification division.
program-id. istty.
data division.
working-storage section.
01 rc usage binary-long.
procedure division.
sample-main.
call "isatty" using by value 0 returning rc
display "fd 0 tty: " rc
c... | from sys import stdout
if stdout.isatty():
print 'The output device is a teletype. Or something like a teletype.'
else:
print 'The output device isn\'t like a teletype.'
|
Port the provided COBOL code into VB while preserving the original functionality. |
identification division.
program-id. istty.
data division.
working-storage section.
01 rc usage binary-long.
procedure division.
sample-main.
call "isatty" using by value 0 returning rc
display "fd 0 tty: " rc
c... | Module Module1
Sub Main()
Console.WriteLine("Stdout is tty: {0}", Console.IsOutputRedirected)
End Sub
End Module
|
Can you help me rewrite this code in VB instead of COBOL, keeping it the same logically? |
identification division.
program-id. istty.
data division.
working-storage section.
01 rc usage binary-long.
procedure division.
sample-main.
call "isatty" using by value 0 returning rc
display "fd 0 tty: " rc
c... | Module Module1
Sub Main()
Console.WriteLine("Stdout is tty: {0}", Console.IsOutputRedirected)
End Sub
End Module
|
Can you help me rewrite this code in Go instead of COBOL, keeping it the same logically? |
identification division.
program-id. istty.
data division.
working-storage section.
01 rc usage binary-long.
procedure division.
sample-main.
call "isatty" using by value 0 returning rc
display "fd 0 tty: " rc
c... | package main
import (
"os"
"fmt"
)
func main() {
if fileInfo, _ := os.Stdout.Stat(); (fileInfo.Mode() & os.ModeCharDevice) != 0 {
fmt.Println("Hello terminal")
} else {
fmt.Println("Who are you? You're not a terminal")
}
}
|
Write a version of this COBOL function in Go with identical behavior. |
identification division.
program-id. istty.
data division.
working-storage section.
01 rc usage binary-long.
procedure division.
sample-main.
call "isatty" using by value 0 returning rc
display "fd 0 tty: " rc
c... | package main
import (
"os"
"fmt"
)
func main() {
if fileInfo, _ := os.Stdout.Stat(); (fileInfo.Mode() & os.ModeCharDevice) != 0 {
fmt.Println("Hello terminal")
} else {
fmt.Println("Who are you? You're not a terminal")
}
}
|
Port the provided REXX code into C while preserving the original functionality. |
signal on syntax
say 'output device:' testSTDIN()
exit 0
testSTDIN: syntax.=1; signal .; .: z.= sigl; call linein ,2; ..: syntax.= 0; return z..
syntax: z..= 'other' ... | #include <unistd.h>
#include <stdio.h>
int main()
{
puts(isatty(fileno(stdout))
? "stdout is tty"
: "stdout is not tty");
return 0;
}
|
Transform the following REXX implementation into C, maintaining the same output and logic. |
signal on syntax
say 'output device:' testSTDIN()
exit 0
testSTDIN: syntax.=1; signal .; .: z.= sigl; call linein ,2; ..: syntax.= 0; return z..
syntax: z..= 'other' ... | #include <unistd.h>
#include <stdio.h>
int main()
{
puts(isatty(fileno(stdout))
? "stdout is tty"
: "stdout is not tty");
return 0;
}
|
Translate the given REXX code snippet into C# without altering its behavior. |
signal on syntax
say 'output device:' testSTDIN()
exit 0
testSTDIN: syntax.=1; signal .; .: z.= sigl; call linein ,2; ..: syntax.= 0; return z..
syntax: z..= 'other' ... | using System;
namespace CheckTerminal {
class Program {
static void Main(string[] args) {
Console.WriteLine("Stdout is tty: {0}", Console.IsOutputRedirected);
}
}
}
|
Generate a C# translation of this REXX snippet without changing its computational steps. |
signal on syntax
say 'output device:' testSTDIN()
exit 0
testSTDIN: syntax.=1; signal .; .: z.= sigl; call linein ,2; ..: syntax.= 0; return z..
syntax: z..= 'other' ... | using System;
namespace CheckTerminal {
class Program {
static void Main(string[] args) {
Console.WriteLine("Stdout is tty: {0}", Console.IsOutputRedirected);
}
}
}
|
Write the same algorithm in C++ as shown in this REXX implementation. |
signal on syntax
say 'output device:' testSTDIN()
exit 0
testSTDIN: syntax.=1; signal .; .: z.= sigl; call linein ,2; ..: syntax.= 0; return z..
syntax: z..= 'other' ... | #if _WIN32
#include <io.h>
#define ISATTY _isatty
#define FILENO _fileno
#else
#include <unistd.h>
#define ISATTY isatty
#define FILENO fileno
#endif
#include <iostream>
int main() {
if (ISATTY(FILENO(stdout))) {
std::cout << "stdout is a tty\n";
} else {
std::cout << "stdout is not a tty\n";
... |
Please provide an equivalent version of this REXX code in C++. |
signal on syntax
say 'output device:' testSTDIN()
exit 0
testSTDIN: syntax.=1; signal .; .: z.= sigl; call linein ,2; ..: syntax.= 0; return z..
syntax: z..= 'other' ... | #if _WIN32
#include <io.h>
#define ISATTY _isatty
#define FILENO _fileno
#else
#include <unistd.h>
#define ISATTY isatty
#define FILENO fileno
#endif
#include <iostream>
int main() {
if (ISATTY(FILENO(stdout))) {
std::cout << "stdout is a tty\n";
} else {
std::cout << "stdout is not a tty\n";
... |
Keep all operations the same but rewrite the snippet in Python. |
signal on syntax
say 'output device:' testSTDIN()
exit 0
testSTDIN: syntax.=1; signal .; .: z.= sigl; call linein ,2; ..: syntax.= 0; return z..
syntax: z..= 'other' ... | from sys import stdout
if stdout.isatty():
print 'The output device is a teletype. Or something like a teletype.'
else:
print 'The output device isn\'t like a teletype.'
|
Change the following REXX code into Python without altering its purpose. |
signal on syntax
say 'output device:' testSTDIN()
exit 0
testSTDIN: syntax.=1; signal .; .: z.= sigl; call linein ,2; ..: syntax.= 0; return z..
syntax: z..= 'other' ... | from sys import stdout
if stdout.isatty():
print 'The output device is a teletype. Or something like a teletype.'
else:
print 'The output device isn\'t like a teletype.'
|
Change the following REXX code into VB without altering its purpose. |
signal on syntax
say 'output device:' testSTDIN()
exit 0
testSTDIN: syntax.=1; signal .; .: z.= sigl; call linein ,2; ..: syntax.= 0; return z..
syntax: z..= 'other' ... | Module Module1
Sub Main()
Console.WriteLine("Stdout is tty: {0}", Console.IsOutputRedirected)
End Sub
End Module
|
Port the provided REXX code into VB while preserving the original functionality. |
signal on syntax
say 'output device:' testSTDIN()
exit 0
testSTDIN: syntax.=1; signal .; .: z.= sigl; call linein ,2; ..: syntax.= 0; return z..
syntax: z..= 'other' ... | Module Module1
Sub Main()
Console.WriteLine("Stdout is tty: {0}", Console.IsOutputRedirected)
End Sub
End Module
|
Change the programming language of this snippet from REXX to Go without modifying what it does. |
signal on syntax
say 'output device:' testSTDIN()
exit 0
testSTDIN: syntax.=1; signal .; .: z.= sigl; call linein ,2; ..: syntax.= 0; return z..
syntax: z..= 'other' ... | package main
import (
"os"
"fmt"
)
func main() {
if fileInfo, _ := os.Stdout.Stat(); (fileInfo.Mode() & os.ModeCharDevice) != 0 {
fmt.Println("Hello terminal")
} else {
fmt.Println("Who are you? You're not a terminal")
}
}
|
Produce a language-to-language conversion: from REXX to Go, same semantics. |
signal on syntax
say 'output device:' testSTDIN()
exit 0
testSTDIN: syntax.=1; signal .; .: z.= sigl; call linein ,2; ..: syntax.= 0; return z..
syntax: z..= 'other' ... | package main
import (
"os"
"fmt"
)
func main() {
if fileInfo, _ := os.Stdout.Stat(); (fileInfo.Mode() & os.ModeCharDevice) != 0 {
fmt.Println("Hello terminal")
} else {
fmt.Println("Who are you? You're not a terminal")
}
}
|
Convert the following code from Ruby to C, ensuring the logic remains intact. | File.new("testfile").tty?
File.new("/dev/tty").tty?
STDOUT.tty?
| #include <unistd.h>
#include <stdio.h>
int main()
{
puts(isatty(fileno(stdout))
? "stdout is tty"
: "stdout is not tty");
return 0;
}
|
Translate the given Ruby code snippet into C without altering its behavior. | File.new("testfile").tty?
File.new("/dev/tty").tty?
STDOUT.tty?
| #include <unistd.h>
#include <stdio.h>
int main()
{
puts(isatty(fileno(stdout))
? "stdout is tty"
: "stdout is not tty");
return 0;
}
|
Please provide an equivalent version of this Ruby code in C#. | File.new("testfile").tty?
File.new("/dev/tty").tty?
STDOUT.tty?
| using System;
namespace CheckTerminal {
class Program {
static void Main(string[] args) {
Console.WriteLine("Stdout is tty: {0}", Console.IsOutputRedirected);
}
}
}
|
Port the provided Ruby code into C# while preserving the original functionality. | File.new("testfile").tty?
File.new("/dev/tty").tty?
STDOUT.tty?
| using System;
namespace CheckTerminal {
class Program {
static void Main(string[] args) {
Console.WriteLine("Stdout is tty: {0}", Console.IsOutputRedirected);
}
}
}
|
Generate an equivalent C++ version of this Ruby code. | File.new("testfile").tty?
File.new("/dev/tty").tty?
STDOUT.tty?
| #if _WIN32
#include <io.h>
#define ISATTY _isatty
#define FILENO _fileno
#else
#include <unistd.h>
#define ISATTY isatty
#define FILENO fileno
#endif
#include <iostream>
int main() {
if (ISATTY(FILENO(stdout))) {
std::cout << "stdout is a tty\n";
} else {
std::cout << "stdout is not a tty\n";
... |
Rewrite the snippet below in C++ so it works the same as the original Ruby code. | File.new("testfile").tty?
File.new("/dev/tty").tty?
STDOUT.tty?
| #if _WIN32
#include <io.h>
#define ISATTY _isatty
#define FILENO _fileno
#else
#include <unistd.h>
#define ISATTY isatty
#define FILENO fileno
#endif
#include <iostream>
int main() {
if (ISATTY(FILENO(stdout))) {
std::cout << "stdout is a tty\n";
} else {
std::cout << "stdout is not a tty\n";
... |
Preserve the algorithm and functionality while converting the code from Ruby to Python. | File.new("testfile").tty?
File.new("/dev/tty").tty?
STDOUT.tty?
| from sys import stdout
if stdout.isatty():
print 'The output device is a teletype. Or something like a teletype.'
else:
print 'The output device isn\'t like a teletype.'
|
Keep all operations the same but rewrite the snippet in Python. | File.new("testfile").tty?
File.new("/dev/tty").tty?
STDOUT.tty?
| from sys import stdout
if stdout.isatty():
print 'The output device is a teletype. Or something like a teletype.'
else:
print 'The output device isn\'t like a teletype.'
|
Ensure the translated VB code behaves exactly like the original Ruby snippet. | File.new("testfile").tty?
File.new("/dev/tty").tty?
STDOUT.tty?
| Module Module1
Sub Main()
Console.WriteLine("Stdout is tty: {0}", Console.IsOutputRedirected)
End Sub
End Module
|
Keep all operations the same but rewrite the snippet in VB. | File.new("testfile").tty?
File.new("/dev/tty").tty?
STDOUT.tty?
| Module Module1
Sub Main()
Console.WriteLine("Stdout is tty: {0}", Console.IsOutputRedirected)
End Sub
End Module
|
Rewrite the snippet below in Go so it works the same as the original Ruby code. | File.new("testfile").tty?
File.new("/dev/tty").tty?
STDOUT.tty?
| package main
import (
"os"
"fmt"
)
func main() {
if fileInfo, _ := os.Stdout.Stat(); (fileInfo.Mode() & os.ModeCharDevice) != 0 {
fmt.Println("Hello terminal")
} else {
fmt.Println("Who are you? You're not a terminal")
}
}
|
Translate the given Ruby code snippet into Go without altering its behavior. | File.new("testfile").tty?
File.new("/dev/tty").tty?
STDOUT.tty?
| package main
import (
"os"
"fmt"
)
func main() {
if fileInfo, _ := os.Stdout.Stat(); (fileInfo.Mode() & os.ModeCharDevice) != 0 {
fmt.Println("Hello terminal")
} else {
fmt.Println("Who are you? You're not a terminal")
}
}
|
Rewrite this program in C while keeping its functionality equivalent to the Scala version. |
import platform.posix.*
fun main(args: Array<String>) {
if (isatty(STDOUT_FILENO) != 0)
println("stdout is a terminal")
else
println("stdout is not a terminal")
}
| #include <unistd.h>
#include <stdio.h>
int main()
{
puts(isatty(fileno(stdout))
? "stdout is tty"
: "stdout is not tty");
return 0;
}
|
Ensure the translated C code behaves exactly like the original Scala snippet. |
import platform.posix.*
fun main(args: Array<String>) {
if (isatty(STDOUT_FILENO) != 0)
println("stdout is a terminal")
else
println("stdout is not a terminal")
}
| #include <unistd.h>
#include <stdio.h>
int main()
{
puts(isatty(fileno(stdout))
? "stdout is tty"
: "stdout is not tty");
return 0;
}
|
Convert this Scala block to C#, preserving its control flow and logic. |
import platform.posix.*
fun main(args: Array<String>) {
if (isatty(STDOUT_FILENO) != 0)
println("stdout is a terminal")
else
println("stdout is not a terminal")
}
| using System;
namespace CheckTerminal {
class Program {
static void Main(string[] args) {
Console.WriteLine("Stdout is tty: {0}", Console.IsOutputRedirected);
}
}
}
|
Preserve the algorithm and functionality while converting the code from Scala to C#. |
import platform.posix.*
fun main(args: Array<String>) {
if (isatty(STDOUT_FILENO) != 0)
println("stdout is a terminal")
else
println("stdout is not a terminal")
}
| using System;
namespace CheckTerminal {
class Program {
static void Main(string[] args) {
Console.WriteLine("Stdout is tty: {0}", Console.IsOutputRedirected);
}
}
}
|
Port the following code from Scala to C++ with equivalent syntax and logic. |
import platform.posix.*
fun main(args: Array<String>) {
if (isatty(STDOUT_FILENO) != 0)
println("stdout is a terminal")
else
println("stdout is not a terminal")
}
| #if _WIN32
#include <io.h>
#define ISATTY _isatty
#define FILENO _fileno
#else
#include <unistd.h>
#define ISATTY isatty
#define FILENO fileno
#endif
#include <iostream>
int main() {
if (ISATTY(FILENO(stdout))) {
std::cout << "stdout is a tty\n";
} else {
std::cout << "stdout is not a tty\n";
... |
Produce a functionally identical C++ code for the snippet given in Scala. |
import platform.posix.*
fun main(args: Array<String>) {
if (isatty(STDOUT_FILENO) != 0)
println("stdout is a terminal")
else
println("stdout is not a terminal")
}
| #if _WIN32
#include <io.h>
#define ISATTY _isatty
#define FILENO _fileno
#else
#include <unistd.h>
#define ISATTY isatty
#define FILENO fileno
#endif
#include <iostream>
int main() {
if (ISATTY(FILENO(stdout))) {
std::cout << "stdout is a tty\n";
} else {
std::cout << "stdout is not a tty\n";
... |
Translate the given Scala code snippet into Python without altering its behavior. |
import platform.posix.*
fun main(args: Array<String>) {
if (isatty(STDOUT_FILENO) != 0)
println("stdout is a terminal")
else
println("stdout is not a terminal")
}
| from sys import stdout
if stdout.isatty():
print 'The output device is a teletype. Or something like a teletype.'
else:
print 'The output device isn\'t like a teletype.'
|
Write the same code in Python as shown below in Scala. |
import platform.posix.*
fun main(args: Array<String>) {
if (isatty(STDOUT_FILENO) != 0)
println("stdout is a terminal")
else
println("stdout is not a terminal")
}
| from sys import stdout
if stdout.isatty():
print 'The output device is a teletype. Or something like a teletype.'
else:
print 'The output device isn\'t like a teletype.'
|
Transform the following Scala implementation into VB, maintaining the same output and logic. |
import platform.posix.*
fun main(args: Array<String>) {
if (isatty(STDOUT_FILENO) != 0)
println("stdout is a terminal")
else
println("stdout is not a terminal")
}
| Module Module1
Sub Main()
Console.WriteLine("Stdout is tty: {0}", Console.IsOutputRedirected)
End Sub
End Module
|
Transform the following Scala implementation into VB, maintaining the same output and logic. |
import platform.posix.*
fun main(args: Array<String>) {
if (isatty(STDOUT_FILENO) != 0)
println("stdout is a terminal")
else
println("stdout is not a terminal")
}
| Module Module1
Sub Main()
Console.WriteLine("Stdout is tty: {0}", Console.IsOutputRedirected)
End Sub
End Module
|
Transform the following Scala implementation into Go, maintaining the same output and logic. |
import platform.posix.*
fun main(args: Array<String>) {
if (isatty(STDOUT_FILENO) != 0)
println("stdout is a terminal")
else
println("stdout is not a terminal")
}
| package main
import (
"os"
"fmt"
)
func main() {
if fileInfo, _ := os.Stdout.Stat(); (fileInfo.Mode() & os.ModeCharDevice) != 0 {
fmt.Println("Hello terminal")
} else {
fmt.Println("Who are you? You're not a terminal")
}
}
|
Rewrite this program in Go while keeping its functionality equivalent to the Scala version. |
import platform.posix.*
fun main(args: Array<String>) {
if (isatty(STDOUT_FILENO) != 0)
println("stdout is a terminal")
else
println("stdout is not a terminal")
}
| package main
import (
"os"
"fmt"
)
func main() {
if fileInfo, _ := os.Stdout.Stat(); (fileInfo.Mode() & os.ModeCharDevice) != 0 {
fmt.Println("Hello terminal")
} else {
fmt.Println("Who are you? You're not a terminal")
}
}
|
Produce a functionally identical C code for the snippet given in Tcl. | set toTTY [dict exists [fconfigure stdout] -mode]
puts [expr {$toTTY ? "Output goes to tty" : "Output doesn't go to tty"}]
| #include <unistd.h>
#include <stdio.h>
int main()
{
puts(isatty(fileno(stdout))
? "stdout is tty"
: "stdout is not tty");
return 0;
}
|
Convert this Tcl snippet to C and keep its semantics consistent. | set toTTY [dict exists [fconfigure stdout] -mode]
puts [expr {$toTTY ? "Output goes to tty" : "Output doesn't go to tty"}]
| #include <unistd.h>
#include <stdio.h>
int main()
{
puts(isatty(fileno(stdout))
? "stdout is tty"
: "stdout is not tty");
return 0;
}
|
Generate a C# translation of this Tcl snippet without changing its computational steps. | set toTTY [dict exists [fconfigure stdout] -mode]
puts [expr {$toTTY ? "Output goes to tty" : "Output doesn't go to tty"}]
| using System;
namespace CheckTerminal {
class Program {
static void Main(string[] args) {
Console.WriteLine("Stdout is tty: {0}", Console.IsOutputRedirected);
}
}
}
|
Rewrite this program in C# while keeping its functionality equivalent to the Tcl version. | set toTTY [dict exists [fconfigure stdout] -mode]
puts [expr {$toTTY ? "Output goes to tty" : "Output doesn't go to tty"}]
| using System;
namespace CheckTerminal {
class Program {
static void Main(string[] args) {
Console.WriteLine("Stdout is tty: {0}", Console.IsOutputRedirected);
}
}
}
|
Please provide an equivalent version of this Tcl code in C++. | set toTTY [dict exists [fconfigure stdout] -mode]
puts [expr {$toTTY ? "Output goes to tty" : "Output doesn't go to tty"}]
| #if _WIN32
#include <io.h>
#define ISATTY _isatty
#define FILENO _fileno
#else
#include <unistd.h>
#define ISATTY isatty
#define FILENO fileno
#endif
#include <iostream>
int main() {
if (ISATTY(FILENO(stdout))) {
std::cout << "stdout is a tty\n";
} else {
std::cout << "stdout is not a tty\n";
... |
Preserve the algorithm and functionality while converting the code from Tcl to C++. | set toTTY [dict exists [fconfigure stdout] -mode]
puts [expr {$toTTY ? "Output goes to tty" : "Output doesn't go to tty"}]
| #if _WIN32
#include <io.h>
#define ISATTY _isatty
#define FILENO _fileno
#else
#include <unistd.h>
#define ISATTY isatty
#define FILENO fileno
#endif
#include <iostream>
int main() {
if (ISATTY(FILENO(stdout))) {
std::cout << "stdout is a tty\n";
} else {
std::cout << "stdout is not a tty\n";
... |
Generate a Python translation of this Tcl snippet without changing its computational steps. | set toTTY [dict exists [fconfigure stdout] -mode]
puts [expr {$toTTY ? "Output goes to tty" : "Output doesn't go to tty"}]
| from sys import stdout
if stdout.isatty():
print 'The output device is a teletype. Or something like a teletype.'
else:
print 'The output device isn\'t like a teletype.'
|
Can you help me rewrite this code in Python instead of Tcl, keeping it the same logically? | set toTTY [dict exists [fconfigure stdout] -mode]
puts [expr {$toTTY ? "Output goes to tty" : "Output doesn't go to tty"}]
| from sys import stdout
if stdout.isatty():
print 'The output device is a teletype. Or something like a teletype.'
else:
print 'The output device isn\'t like a teletype.'
|
Convert the following code from Tcl to VB, ensuring the logic remains intact. | set toTTY [dict exists [fconfigure stdout] -mode]
puts [expr {$toTTY ? "Output goes to tty" : "Output doesn't go to tty"}]
| Module Module1
Sub Main()
Console.WriteLine("Stdout is tty: {0}", Console.IsOutputRedirected)
End Sub
End Module
|
Convert this Tcl snippet to VB and keep its semantics consistent. | set toTTY [dict exists [fconfigure stdout] -mode]
puts [expr {$toTTY ? "Output goes to tty" : "Output doesn't go to tty"}]
| Module Module1
Sub Main()
Console.WriteLine("Stdout is tty: {0}", Console.IsOutputRedirected)
End Sub
End Module
|
Generate a Go translation of this Tcl snippet without changing its computational steps. | set toTTY [dict exists [fconfigure stdout] -mode]
puts [expr {$toTTY ? "Output goes to tty" : "Output doesn't go to tty"}]
| package main
import (
"os"
"fmt"
)
func main() {
if fileInfo, _ := os.Stdout.Stat(); (fileInfo.Mode() & os.ModeCharDevice) != 0 {
fmt.Println("Hello terminal")
} else {
fmt.Println("Who are you? You're not a terminal")
}
}
|
Translate the given Tcl code snippet into Go without altering its behavior. | set toTTY [dict exists [fconfigure stdout] -mode]
puts [expr {$toTTY ? "Output goes to tty" : "Output doesn't go to tty"}]
| package main
import (
"os"
"fmt"
)
func main() {
if fileInfo, _ := os.Stdout.Stat(); (fileInfo.Mode() & os.ModeCharDevice) != 0 {
fmt.Println("Hello terminal")
} else {
fmt.Println("Who are you? You're not a terminal")
}
}
|
Rewrite this program in PHP while keeping its functionality equivalent to the Rust version. | f = File.open("test.txt")
p f.isatty # => false
p STDOUT.isatty # => true
| if(posix_isatty(STDOUT)) {
echo "The output device is a terminal".PHP_EOL;
} else {
echo "The output device is NOT a terminal".PHP_EOL;
}
|
Rewrite the snippet below in PHP so it works the same as the original Rust code. | f = File.open("test.txt")
p f.isatty # => false
p STDOUT.isatty # => true
| if(posix_isatty(STDOUT)) {
echo "The output device is a terminal".PHP_EOL;
} else {
echo "The output device is NOT a terminal".PHP_EOL;
}
|
Produce a functionally identical PHP code for the snippet given in Ada. | with Ada.Text_IO; use Ada.Text_IO;
with Interfaces.C_Streams; use Interfaces.C_Streams;
procedure Test_tty is
begin
if Isatty(Fileno(Stdout)) = 0 then
Put_Line(Standard_Error, "stdout is not a tty.");
else
Put_Line(Standard_Error, "stdout is a tty.");
end if;
end Test_tty;
| if(posix_isatty(STDOUT)) {
echo "The output device is a terminal".PHP_EOL;
} else {
echo "The output device is NOT a terminal".PHP_EOL;
}
|
Rewrite the snippet below in PHP so it works the same as the original Ada code. | with Ada.Text_IO; use Ada.Text_IO;
with Interfaces.C_Streams; use Interfaces.C_Streams;
procedure Test_tty is
begin
if Isatty(Fileno(Stdout)) = 0 then
Put_Line(Standard_Error, "stdout is not a tty.");
else
Put_Line(Standard_Error, "stdout is a tty.");
end if;
end Test_tty;
| if(posix_isatty(STDOUT)) {
echo "The output device is a terminal".PHP_EOL;
} else {
echo "The output device is NOT a terminal".PHP_EOL;
}
|
Change the programming language of this snippet from Common_Lisp to PHP without modifying what it does. | (with-open-stream (s *standard-output*)
(format T "stdout is~:[ not~
(interactive-stream-p s)))
| if(posix_isatty(STDOUT)) {
echo "The output device is a terminal".PHP_EOL;
} else {
echo "The output device is NOT a terminal".PHP_EOL;
}
|
Convert this Common_Lisp snippet to PHP and keep its semantics consistent. | (with-open-stream (s *standard-output*)
(format T "stdout is~:[ not~
(interactive-stream-p s)))
| if(posix_isatty(STDOUT)) {
echo "The output device is a terminal".PHP_EOL;
} else {
echo "The output device is NOT a terminal".PHP_EOL;
}
|
Ensure the translated PHP code behaves exactly like the original D snippet. | import std.stdio;
extern(C) int isatty(int);
void main() {
writeln("Stdout is tty: ", stdout.fileno.isatty == 1);
}
| if(posix_isatty(STDOUT)) {
echo "The output device is a terminal".PHP_EOL;
} else {
echo "The output device is NOT a terminal".PHP_EOL;
}
|
Rewrite the snippet below in PHP so it works the same as the original D code. | import std.stdio;
extern(C) int isatty(int);
void main() {
writeln("Stdout is tty: ", stdout.fileno.isatty == 1);
}
| if(posix_isatty(STDOUT)) {
echo "The output device is a terminal".PHP_EOL;
} else {
echo "The output device is NOT a terminal".PHP_EOL;
}
|
Please provide an equivalent version of this Factor code in PHP. | IN: scratchpad USE: unix.ffi
IN: scratchpad 1 isatty
--- Data stack:
1
| if(posix_isatty(STDOUT)) {
echo "The output device is a terminal".PHP_EOL;
} else {
echo "The output device is NOT a terminal".PHP_EOL;
}
|
Produce a functionally identical PHP code for the snippet given in Factor. | IN: scratchpad USE: unix.ffi
IN: scratchpad 1 isatty
--- Data stack:
1
| if(posix_isatty(STDOUT)) {
echo "The output device is a terminal".PHP_EOL;
} else {
echo "The output device is NOT a terminal".PHP_EOL;
}
|
Convert this Haskell snippet to PHP and keep its semantics consistent. | module Main where
import System.Posix.Terminal (queryTerminal)
import System.Posix.IO (stdOutput)
main :: IO ()
main = do
istty <- queryTerminal stdOutput
putStrLn
(if istty
then "stdout is tty"
else "stdout is not tty")
| if(posix_isatty(STDOUT)) {
echo "The output device is a terminal".PHP_EOL;
} else {
echo "The output device is NOT a terminal".PHP_EOL;
}
|
Write a version of this Haskell function in PHP with identical behavior. | module Main where
import System.Posix.Terminal (queryTerminal)
import System.Posix.IO (stdOutput)
main :: IO ()
main = do
istty <- queryTerminal stdOutput
putStrLn
(if istty
then "stdout is tty"
else "stdout is not tty")
| if(posix_isatty(STDOUT)) {
echo "The output device is a terminal".PHP_EOL;
} else {
echo "The output device is NOT a terminal".PHP_EOL;
}
|
Preserve the algorithm and functionality while converting the code from J to PHP. | 3=nc<'wd'
| if(posix_isatty(STDOUT)) {
echo "The output device is a terminal".PHP_EOL;
} else {
echo "The output device is NOT a terminal".PHP_EOL;
}
|
Generate a PHP translation of this J snippet without changing its computational steps. | 3=nc<'wd'
| if(posix_isatty(STDOUT)) {
echo "The output device is a terminal".PHP_EOL;
} else {
echo "The output device is NOT a terminal".PHP_EOL;
}
|
Translate this program into PHP but keep the logic exactly as in Julia. | if isa(STDOUT, Base.TTY)
println("This program sees STDOUT as a TTY.")
else
println("This program does not see STDOUT as a TTY.")
end
| if(posix_isatty(STDOUT)) {
echo "The output device is a terminal".PHP_EOL;
} else {
echo "The output device is NOT a terminal".PHP_EOL;
}
|
Maintain the same structure and functionality when rewriting this code in PHP. | if isa(STDOUT, Base.TTY)
println("This program sees STDOUT as a TTY.")
else
println("This program does not see STDOUT as a TTY.")
end
| if(posix_isatty(STDOUT)) {
echo "The output device is a terminal".PHP_EOL;
} else {
echo "The output device is NOT a terminal".PHP_EOL;
}
|
Produce a language-to-language conversion: from Lua to PHP, same semantics. | local function isTTY ( fd )
fd = tonumber( fd ) or 1
local ok, exit, signal = os.execute( string.format( "test -t %d", fd ) )
return (ok and exit == "exit") and signal == 0 or false
end
print( "stdin", isTTY( 0 ) )
print( "stdout", isTTY( 1 ) )
print( "stderr", isTTY( 2 ) )
| if(posix_isatty(STDOUT)) {
echo "The output device is a terminal".PHP_EOL;
} else {
echo "The output device is NOT a terminal".PHP_EOL;
}
|
Write a version of this Lua function in PHP with identical behavior. | local function isTTY ( fd )
fd = tonumber( fd ) or 1
local ok, exit, signal = os.execute( string.format( "test -t %d", fd ) )
return (ok and exit == "exit") and signal == 0 or false
end
print( "stdin", isTTY( 0 ) )
print( "stdout", isTTY( 1 ) )
print( "stderr", isTTY( 2 ) )
| if(posix_isatty(STDOUT)) {
echo "The output device is a terminal".PHP_EOL;
} else {
echo "The output device is NOT a terminal".PHP_EOL;
}
|
Write the same algorithm in PHP as shown in this Nim implementation. | import terminal
stderr.write if stdout.isatty: "stdout is a terminal\n" else: "stdout is not a terminal\n"
| if(posix_isatty(STDOUT)) {
echo "The output device is a terminal".PHP_EOL;
} else {
echo "The output device is NOT a terminal".PHP_EOL;
}
|
Produce a language-to-language conversion: from Nim to PHP, same semantics. | import terminal
stderr.write if stdout.isatty: "stdout is a terminal\n" else: "stdout is not a terminal\n"
| if(posix_isatty(STDOUT)) {
echo "The output device is a terminal".PHP_EOL;
} else {
echo "The output device is NOT a terminal".PHP_EOL;
}
|
Generate an equivalent PHP version of this OCaml code. | let () =
print_endline (
if Unix.isatty Unix.stdout
then "Output goes to tty."
else "Output doesn't go to tty."
)
| if(posix_isatty(STDOUT)) {
echo "The output device is a terminal".PHP_EOL;
} else {
echo "The output device is NOT a terminal".PHP_EOL;
}
|
Convert this OCaml snippet to PHP and keep its semantics consistent. | let () =
print_endline (
if Unix.isatty Unix.stdout
then "Output goes to tty."
else "Output doesn't go to tty."
)
| if(posix_isatty(STDOUT)) {
echo "The output device is a terminal".PHP_EOL;
} else {
echo "The output device is NOT a terminal".PHP_EOL;
}
|
Port the following code from Racket to PHP with equivalent syntax and logic. | (terminal-port? (current-output-port))
| if(posix_isatty(STDOUT)) {
echo "The output device is a terminal".PHP_EOL;
} else {
echo "The output device is NOT a terminal".PHP_EOL;
}
|
Translate the given Racket code snippet into PHP without altering its behavior. | (terminal-port? (current-output-port))
| if(posix_isatty(STDOUT)) {
echo "The output device is a terminal".PHP_EOL;
} else {
echo "The output device is NOT a terminal".PHP_EOL;
}
|
Convert the following code from COBOL to PHP, ensuring the logic remains intact. |
identification division.
program-id. istty.
data division.
working-storage section.
01 rc usage binary-long.
procedure division.
sample-main.
call "isatty" using by value 0 returning rc
display "fd 0 tty: " rc
c... | if(posix_isatty(STDOUT)) {
echo "The output device is a terminal".PHP_EOL;
} else {
echo "The output device is NOT a terminal".PHP_EOL;
}
|
Generate an equivalent PHP version of this COBOL code. |
identification division.
program-id. istty.
data division.
working-storage section.
01 rc usage binary-long.
procedure division.
sample-main.
call "isatty" using by value 0 returning rc
display "fd 0 tty: " rc
c... | if(posix_isatty(STDOUT)) {
echo "The output device is a terminal".PHP_EOL;
} else {
echo "The output device is NOT a terminal".PHP_EOL;
}
|
Can you help me rewrite this code in PHP instead of REXX, keeping it the same logically? |
signal on syntax
say 'output device:' testSTDIN()
exit 0
testSTDIN: syntax.=1; signal .; .: z.= sigl; call linein ,2; ..: syntax.= 0; return z..
syntax: z..= 'other' ... | if(posix_isatty(STDOUT)) {
echo "The output device is a terminal".PHP_EOL;
} else {
echo "The output device is NOT a terminal".PHP_EOL;
}
|
Translate this program into PHP but keep the logic exactly as in REXX. |
signal on syntax
say 'output device:' testSTDIN()
exit 0
testSTDIN: syntax.=1; signal .; .: z.= sigl; call linein ,2; ..: syntax.= 0; return z..
syntax: z..= 'other' ... | if(posix_isatty(STDOUT)) {
echo "The output device is a terminal".PHP_EOL;
} else {
echo "The output device is NOT a terminal".PHP_EOL;
}
|
Convert the following code from Ruby to PHP, ensuring the logic remains intact. | File.new("testfile").tty?
File.new("/dev/tty").tty?
STDOUT.tty?
| if(posix_isatty(STDOUT)) {
echo "The output device is a terminal".PHP_EOL;
} else {
echo "The output device is NOT a terminal".PHP_EOL;
}
|
Ensure the translated PHP code behaves exactly like the original Ruby snippet. | File.new("testfile").tty?
File.new("/dev/tty").tty?
STDOUT.tty?
| if(posix_isatty(STDOUT)) {
echo "The output device is a terminal".PHP_EOL;
} else {
echo "The output device is NOT a terminal".PHP_EOL;
}
|
Write the same code in PHP as shown below in Scala. |
import platform.posix.*
fun main(args: Array<String>) {
if (isatty(STDOUT_FILENO) != 0)
println("stdout is a terminal")
else
println("stdout is not a terminal")
}
| if(posix_isatty(STDOUT)) {
echo "The output device is a terminal".PHP_EOL;
} else {
echo "The output device is NOT a terminal".PHP_EOL;
}
|
Write the same algorithm in PHP as shown in this Scala implementation. |
import platform.posix.*
fun main(args: Array<String>) {
if (isatty(STDOUT_FILENO) != 0)
println("stdout is a terminal")
else
println("stdout is not a terminal")
}
| if(posix_isatty(STDOUT)) {
echo "The output device is a terminal".PHP_EOL;
} else {
echo "The output device is NOT a terminal".PHP_EOL;
}
|
Produce a language-to-language conversion: from Tcl to PHP, same semantics. | set toTTY [dict exists [fconfigure stdout] -mode]
puts [expr {$toTTY ? "Output goes to tty" : "Output doesn't go to tty"}]
| if(posix_isatty(STDOUT)) {
echo "The output device is a terminal".PHP_EOL;
} else {
echo "The output device is NOT a terminal".PHP_EOL;
}
|
Convert this Tcl block to PHP, preserving its control flow and logic. | set toTTY [dict exists [fconfigure stdout] -mode]
puts [expr {$toTTY ? "Output goes to tty" : "Output doesn't go to tty"}]
| if(posix_isatty(STDOUT)) {
echo "The output device is a terminal".PHP_EOL;
} else {
echo "The output device is NOT a terminal".PHP_EOL;
}
|
Convert the following code from C to Rust, ensuring the logic remains intact. | #include <unistd.h>
#include <stdio.h>
int main()
{
puts(isatty(fileno(stdout))
? "stdout is tty"
: "stdout is not tty");
return 0;
}
| f = File.open("test.txt")
p f.isatty # => false
p STDOUT.isatty # => true
|
Convert this C++ snippet to Rust and keep its semantics consistent. | #if _WIN32
#include <io.h>
#define ISATTY _isatty
#define FILENO _fileno
#else
#include <unistd.h>
#define ISATTY isatty
#define FILENO fileno
#endif
#include <iostream>
int main() {
if (ISATTY(FILENO(stdout))) {
std::cout << "stdout is a tty\n";
} else {
std::cout << "stdout is not a tty\n";
... | f = File.open("test.txt")
p f.isatty # => false
p STDOUT.isatty # => true
|
Ensure the translated Rust code behaves exactly like the original C++ snippet. | #if _WIN32
#include <io.h>
#define ISATTY _isatty
#define FILENO _fileno
#else
#include <unistd.h>
#define ISATTY isatty
#define FILENO fileno
#endif
#include <iostream>
int main() {
if (ISATTY(FILENO(stdout))) {
std::cout << "stdout is a tty\n";
} else {
std::cout << "stdout is not a tty\n";
... | f = File.open("test.txt")
p f.isatty # => false
p STDOUT.isatty # => true
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.