glue/glue_port.cpp

Go to the documentation of this file.

#include <basix/int.hpp>
#include <basix/vector.hpp>
#include <basix/port.hpp>
#include <basix/tuple.hpp>
#include <basix/glue.hpp>

#define int_literal(x) as_int (as_string (x))

namespace mmx {
  static port
  GLUE_1 (const string &arg_1) {
    return input_string_port (arg_1);
  }
  
  static port
  GLUE_2 (const string &arg_1) {
    return input_file_port (arg_1);
  }
  
  static port
  GLUE_3 (const string &arg_1) {
    return output_file_port (arg_1);
  }
  
  static port
  GLUE_4 (const string &arg_1, const int &arg_2) {
    return socket_server_port (arg_1, arg_2);
  }
  
  static port
  GLUE_5 (const string &arg_1, const int &arg_2) {
    return socket_client_port (arg_1, arg_2);
  }
  
  static port
  GLUE_6 (const string &arg_1) {
    return pipe_port (arg_1);
  }
  
  static port
  GLUE_7 (const tuple<port> &arg_1) {
    return composite_port (as_vector (arg_1));
  }
  
  static port
  GLUE_8 (const string &arg_1) {
    return error_port (arg_1);
  }
  
  static bool
  GLUE_9 (const port &arg_1) {
    return is_output_port (arg_1);
  }
  
  static bool
  GLUE_10 (const port &arg_1) {
    return is_input_port (arg_1);
  }
  
  static bool
  GLUE_11 (const port &arg_1) {
    return error_flag (arg_1);
  }
  
  static string
  GLUE_12 (const port &arg_1) {
    return error_message (arg_1);
  }
  
  static bool
  GLUE_13 (const port &arg_1) {
    return busy (arg_1);
  }
  
  static int
  GLUE_14 (const port &arg_1) {
    return can_write (arg_1);
  }
  
  static int
  GLUE_15 (const port &arg_1) {
    return can_read (arg_1);
  }
  
  static void
  GLUE_16 (const port &arg_1, const string &arg_2) {
    write (arg_1, arg_2);
  }
  
  static string
  GLUE_17 (const port &arg_1, const int &arg_2) {
    return read (arg_1, arg_2);
  }
  
  static void
  GLUE_18 (const port &arg_1) {
    flush (arg_1);
  }
  
  static bool
  GLUE_19 (const port &arg_1, const int &arg_2) {
    return mmx_wait (arg_1, arg_2);
  }
  
  static port
  GLUE_20 (const port &arg_1) {
    return accept (arg_1);
  }
  
  static port
  GLUE_21 (const port &arg_1, const string &arg_2) {
    return component (arg_1, arg_2);
  }
  
  static int
  GLUE_22 (const int &arg_1) {
    return wait_port_event (arg_1);
  }
  
  static port
  GLUE_23 (const port &arg_1, const generic &arg_2) {
    return arg_1 << arg_2;
  }
  
  static port
  GLUE_24 (const port &arg_1, const string &arg_2) {
    return arg_1 << arg_2;
  }
  
  static port
  GLUE_25 (const port &arg_1, const print_format &arg_2) {
    return arg_1 << arg_2;
  }
  
  static generic
  GLUE_26 (const generic &arg_1) {
    return generic_assemble (arg_1);
  }
  
  static generic
  GLUE_27 (const generic &arg_1) {
    return generic_disassemble (arg_1);
  }
  
  static void
  GLUE_28 (const port &arg_1, const generic &arg_2) {
    binary_write_generic (arg_1, arg_2);
  }
  
  static generic
  GLUE_29 (const port &arg_1) {
    return binary_read_generic (arg_1);
  }
  
  void
  glue_port () {
    static bool done = false;
    if (done) return;
    done = true;
    call_glue (string ("glue_int"));
    call_glue (string ("glue_string"));
    define_type<print_format > (lit ("Print_format"));
    define_constant<print_format > ("blank", blank);
    define_constant<print_format > ("stroke", stroke);
    define_constant<print_format > ("indent", indent);
    define_constant<print_format > ("unindent", unindent);
    define_constant<print_format > ("reset_indent", reset_indent);
    define_constant<print_format > ("cr", cr);
    define_constant<print_format > ("lf", lf);
    define_constant<print_format > ("hrule", hrule);
    define_constant<print_format > ("flush_now", flush_now);
    define_constant<print_format > ("black_foreground", black_foreground);
    define_constant<print_format > ("red_foreground", red_foreground);
    define_constant<print_format > ("green_foreground", green_foreground);
    define_constant<print_format > ("yellow_foreground", yellow_foreground);
    define_constant<print_format > ("blue_foreground", blue_foreground);
    define_constant<print_format > ("magenta_foreground", magenta_foreground);
    define_constant<print_format > ("cyan_foreground", cyan_foreground);
    define_constant<print_format > ("white_foreground", white_foreground);
    define_constant<print_format > ("black_background", black_background);
    define_constant<print_format > ("red_background", red_background);
    define_constant<print_format > ("green_background", green_background);
    define_constant<print_format > ("yellow_background", yellow_background);
    define_constant<print_format > ("blue_background", blue_background);
    define_constant<print_format > ("magenta_background", magenta_background);
    define_constant<print_format > ("cyan_background", cyan_background);
    define_constant<print_format > ("white_background", white_background);
    define_constant<print_format > ("bold", bold);
    define_constant<print_format > ("underline", underline);
    define_constant<print_format > ("blink", blink);
    define_constant<print_format > ("reset_attributes", reset_attributes);
    define_type<port > (lit ("Port"));
    define_constant<port > ("mmin", mmin);
    define_constant<port > ("mmout", mmout);
    define_constant<port > ("mmerr", mmerr);
    define ("input_string_port", GLUE_1);
    define ("input_file_port", GLUE_2);
    define ("output_file_port", GLUE_3);
    define ("socket_server_port", GLUE_4);
    define ("socket_client_port", GLUE_5);
    define ("pipe_port", GLUE_6);
    define ("composite_port", GLUE_7);
    define ("error_port", GLUE_8);
    define (".output_port?", GLUE_9);
    define (".input_port?", GLUE_10);
    define (".error?", GLUE_11);
    define (".error", GLUE_12);
    define (".busy?", GLUE_13);
    define (".can_write", GLUE_14);
    define (".can_read", GLUE_15);
    define ("write", GLUE_16);
    define ("read", GLUE_17);
    define ("flush", GLUE_18);
    define ("wait", GLUE_19);
    define ("accept", GLUE_20);
    define (".[]", GLUE_21);
    define ("wait", GLUE_22);
    define ("<<", GLUE_23);
    define ("<<", GLUE_24);
    define ("<<", GLUE_25);
    define ("binary_assemble", GLUE_26);
    define ("binary_disassemble", GLUE_27);
    define ("binary_write", GLUE_28);
    define ("binary_read", GLUE_29);
  }
}

---