compiler/cpp/src/generate/t_erl_generator.h

   1 #ifndef T_ERL_GENERATOR_H
   2 #define T_ERL_GENERATOR_H
   3
   4 #include <string>
   5 #include <fstream>
   6 #include <iostream>
   7 #include <vector>
   8
   9 #include "t_oop_generator.h"
  10
  11 /**
  12  * Erlang code generator.
  13  *
  14  * @author
  15  */
  16 class t_erl_generator : public t_oop_generator {
  17  public:
  18   t_erl_generator(t_program* program) :
  19     t_oop_generator(program)
  20   {
  21     program_name_[0] = tolower(program_name_[0]);
  22     service_name_[0] = tolower(service_name_[0]);
  23     out_dir_base_ = "gen-erl";
  24   }
  25
  26   /**
  27    * Init and close methods
  28    */
  29
  30   void init_generator();
  31   void close_generator();
  32
  33   /**
  34    * Program-level generation functions
  35    */
  36
  37   void generate_typedef  (t_typedef*  ttypedef);
  38   void generate_enum     (t_enum*     tenum);
  39   void generate_const    (t_const*    tconst);
  40   void generate_struct   (t_struct*   tstruct);
  41   void generate_xception (t_struct*   txception);
  42   void generate_service  (t_service*  tservice);
  43
  44   std::string render_const_value(t_type* type, t_const_value* value);
  45
  46   /**
  47    * Struct generation code
  48    */
  49
  50   void generate_erl_struct(t_struct* tstruct, bool is_exception);
  51   void generate_erl_struct_definition(std::ostream& out, std::ostream& hrl_out, t_struct* tstruct, bool is_xception=false, bool is_result=false);
  52   void generate_erl_struct_reader(std::ostream& out, t_struct* tstruct);
  53   void generate_erl_struct_writer(std::ostream& out, t_struct* tstruct);
  54   void generate_erl_function_helpers(t_function* tfunction);
  55
  56   /**
  57    * Service-level generation functions
  58    */
  59
  60   void generate_service_helpers   (t_service*  tservice);
  61   void generate_service_interface (t_service* tservice);
  62   void generate_service_client    (t_service* tservice);
  63   void generate_service_server    (t_service* tservice);
  64   void generate_process_function  (t_service* tservice, t_function* tfunction);
  65
  66   /**
  67    * Serialization constructs
  68    */
  69
  70   void generate_deserialize_field        (std::ostream &out,
  71                                           t_field*    tfield,
  72                                           std::string prefix="",
  73                                           bool inclass=false);
  74
  75   void generate_deserialize_struct       (std::ostream &out,
  76                                           t_struct*   tstruct,
  77                                           std::string prefix="");
  78
  79   void generate_deserialize_container    (std::ostream &out,
  80                                           t_type*     ttype,
  81                                           std::string prefix="");
  82
  83   void generate_deserialize_set_element  (std::ostream &out,
  84                                           t_set*      tset,
  85                                           std::string prefix="");
  86
  87   void generate_deserialize_map_element  (std::ostream &out,
  88                                           t_map*      tmap,
  89                                           std::string prefix="");
  90
  91   void generate_deserialize_list_element (std::ostream &out,
  92                                           t_list*     tlist,
  93                                           std::string prefix="");
  94
  95   void generate_serialize_field          (std::ostream &out,
  96                                           t_field*    tfield,
  97                                           std::string prefix="");
  98
  99   void generate_serialize_struct         (std::ostream &out,
 100                                           t_struct*   tstruct,
 101                                           std::string prefix="");
 102
 103   void generate_serialize_container      (std::ostream &out,
 104                                           t_type*     ttype,
 105                                           std::string prefix="");
 106
 107   void generate_serialize_map_element    (std::ostream &out,
 108                                           t_map*      tmap,
 109                                           std::string kiter,
 110                                           std::string viter);
 111
 112   void generate_serialize_set_element    (std::ostream &out,
 113                                           t_set*      tmap,
 114                                           std::string iter);
 115
 116   void generate_serialize_list_element   (std::ostream &out,
 117                                           t_list*     tlist,
 118                                           std::string iter);
 119
 120   /**
 121    * Helper rendering functions
 122    */
 123
 124   std::string erl_autogen_comment();
 125   std::string erl_imports();
 126   std::string render_includes();
 127   std::string declare_field(t_field* tfield);
 128   std::string type_name(t_type* ttype);
 129   std::string function_signature(t_function* tfunction, std::string prefix="");
 130
 131   std::string argument_list(t_struct* tstruct);
 132   std::string type_to_enum(t_type* ttype);
 133
 134   std::string capitalize(std::string in) {
 135     in[0] = toupper(in[0]);
 136     return in;
 137   }
 138
 139   std::string uncapitalize(std::string in) {
 140     in[0] = tolower(in[0]);
 141     return in;
 142   }
 143
 144   std::string atomize(std::string in) {
 145     if (isupper(in[0])) {
 146       return "'" + in + "'";
 147     } else {
 148       return in;
 149     }
 150   }
 151
 152  private:
 153
 154   /**
 155    * add function to export list
 156    */
 157
 158   void export_function(t_function* tfunction, std::string prefix="");
 159   void export_string(std::string name, int num);
 160
 161   void export_types_function(t_function* tfunction, std::string prefix="");
 162   void export_types_string(std::string name, int num);
 163
 164   /**
 165    * write out headers and footers for hrl files
 166    */
 167
 168   void hrl_header(std::ostream& out, std::string name);
 169   void hrl_footer(std::ostream& out, std::string name);
 170
 171   /**
 172    * stuff to spit out at the top of generated files
 173    */
 174
 175   bool export_lines_first_;
 176   std::ostringstream export_lines_;
 177
 178   bool export_types_lines_first_;
 179   std::ostringstream export_types_lines_;
 180
 181   /**
 182    * File streams
 183    */
 184
 185   std::ostringstream f_types_;
 186   std::ofstream f_types_file_;
 187   std::ofstream f_types_hrl_file_;
 188
 189   std::ofstream f_consts_;
 190   std::ostringstream f_service_;
 191   std::ofstream f_service_file_;
 192   std::ofstream f_service_hrl_;
 193
 194 };
 195
 196 #endif