← Back to branch summary

~ubuntu-branches/debian/sid/octave3.0/sid

« back to all changes in this revision

Viewing changes to liboctave/sparse-mk-ops.awk

  • Committer: Bazaar Package Importer
  • Author(s): Rafael Laboissiere
  • Date: 2007-12-23 16:04:15 UTC
  • Revision ID: james.westby@ubuntu.com-20071223160415-n4gk468dihy22e9v
Tags: upstream-3.0.0
Import upstream version 3.0.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
liboctave/sparse-mk-ops.awk
 
1
# Copyright (C) 2004, 2005, 2007 John W. Eaton
 
2
#
 
3
# This file is part of Octave.
 
4
# 
 
5
# Octave is free software; you can redistribute it and/or modify it
 
6
# under the terms of the GNU General Public License as published by the
 
7
# Free Software Foundation; either version 3 of the License, or (at
 
8
# your option) any later version.
 
9
# 
 
10
# Octave is distributed in the hope that it will be useful, but WITHOUT
 
11
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 
12
# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 
13
# for more details.
 
14
# 
 
15
# You should have received a copy of the GNU General Public License
 
16
# along with Octave; see the file COPYING.  If not, see
 
17
# <http://www.gnu.org/licenses/>.
 
18
 
 
19
BEGIN {
 
20
  declare_types = 0;
 
21
  generate_ops = 0;
 
22
  ntypes = 0;
 
23
} {
 
24
  if (NR == 1 && make_inclusive_header)
 
25
    {
 
26
      print "// DO NOT EDIT -- generated by sparse-mk-ops";
 
27
      tmp = make_inclusive_header;
 
28
      gsub (/[\.-]/, "_", tmp);
 
29
      printf ("#if !defined (octave_%s)\n", tmp);
 
30
      printf ("#define octave_%s 1\n", tmp);
 
31
    }
 
32
}
 
33
/^#/ {
 
34
  if ($2 == "types")
 
35
    declare_types = 1;
 
36
  else if ($2 == "ops")
 
37
    {
 
38
      generate_ops = 1;
 
39
      declare_types = 0;
 
40
    }
 
41
  next;
 
42
} {
 
43
  if (declare_types)
 
44
    {
 
45
      ntypes++;
 
46
 
 
47
      if (NF == 6)
 
48
        {
 
49
          scalar_zero_val[ntypes] = $6;
 
50
          fwd_decl_ok[ntypes] = $5 == "YES";
 
51
          header[ntypes] = $4 == "NONE" ? "" : $4;
 
52
          class[ntypes] = $3;
 
53
          type[ntypes] = $2;
 
54
          tag[ntypes] = $1;
 
55
          rev_tag[$1] = ntypes;
 
56
        }
 
57
      else
 
58
        printf ("skipping line %d: %s\n", NR, $0); 
 
59
    }
 
60
  else if (generate_ops)
 
61
    {
 
62
      if (NF >= 5)
 
63
        {
 
64
          result_tag_1 = $1;
 
65
          result_tag_2 = $2;
 
66
          lhs_tag = $3;
 
67
          rhs_tag = $4;
 
68
          op_type = $5;
 
69
 
 
70
          bin_ops = index (op_type, "B") != 0;
 
71
          cmp_ops = index (op_type, "C") != 0;
 
72
          eqne_ops = index (op_type, "E") != 0;
 
73
          bool_ops = index (op_type, "L") != 0;
 
74
 
 
75
          n = 5;
 
76
 
 
77
          lhs_conv = cmp_ops ? $(++n) : "";
 
78
          rhs_conv = cmp_ops ? $(++n) : "";
 
79
 
 
80
          if (lhs_conv == "NONE")
 
81
            lhs_conv = "";
 
82
 
 
83
          if (rhs_conv == "NONE")
 
84
            rhs_conv = "";
 
85
 
 
86
          k = 0
 
87
          while (NF > n)
 
88
            bool_headers[k++] = $(++n);
 
89
 
 
90
          cc_file = sprintf ("%s-%s-%s.cc", prefix, lhs_tag, rhs_tag);
 
91
          h_file = sprintf ("%s-%s-%s.h", prefix, lhs_tag, rhs_tag);
 
92
 
 
93
          if (list_cc_files)
 
94
            {
 
95
              print cc_file;
 
96
              next;
 
97
            }
 
98
 
 
99
          if (list_h_files)
 
100
            {
 
101
              print h_file;
 
102
              next;
 
103
            }
 
104
 
 
105
          if (make_inclusive_header)
 
106
            {
 
107
              printf ("#include \"%s\"\n", h_file);
 
108
              next;
 
109
            }
 
110
 
 
111
          h_guard = sprintf ("octave_%s_%s_%s_h", prefix, lhs_tag, rhs_tag);
 
112
 
 
113
          result_num_1 = rev_tag[result_tag_1];
 
114
          result_num_2 = rev_tag[result_tag_2];
 
115
          lhs_num = rev_tag[lhs_tag];
 
116
          rhs_num = rev_tag[rhs_tag];
 
117
 
 
118
          result_type_1 = type[result_num_1];
 
119
          result_type_2 = type[result_num_2];
 
120
          lhs_type = type[lhs_num];
 
121
          rhs_type = type[rhs_num];
 
122
 
 
123
          result_scalar_zero_val_1 = scalar_zero_val[result_num_1];
 
124
          result_scalar_zero_val_2 = scalar_zero_val[result_num_2];
 
125
          lhs_scalar_zero_val = scalar_zero_val[lhs_num];
 
126
          rhs_scalar_zero_val = scalar_zero_val[rhs_num];
 
127
 
 
128
          result_header_1 = header[result_num_1];
 
129
          result_header_2 = header[result_num_2];
 
130
          lhs_header = header[lhs_num];
 
131
          rhs_header = header[rhs_num];
 
132
 
 
133
          lhs_class = class[lhs_num];
 
134
          rhs_class = class[rhs_num];
 
135
 
 
136
          print "// DO NOT EDIT -- generated by sparse-mk-ops" > h_file;
 
137
 
 
138
          printf ("#if !defined (%s)\n", h_guard) >> h_file;
 
139
          printf ("#define %s 1\n", h_guard) >> h_file;
 
140
 
 
141
          if (result_header_1)
 
142
            {
 
143
              if (result_fwd_decl_ok)
 
144
                printf ("class %s\n", result_type_1) >> h_file;
 
145
              else
 
146
                printf ("#include \"%s\"\n", result_header_1) >> h_file;
 
147
            }
 
148
 
 
149
          if (result_header_2 && ! (result_header_2 == result_header_1))
 
150
            {
 
151
              if (result_fwd_decl_ok)
 
152
                printf ("class %s\n", result_type_2) >> h_file;
 
153
              else
 
154
                printf ("#include \"%s\"\n", result_header_2) >> h_file;
 
155
            }
 
156
 
 
157
          if (lhs_header && ! (lhs_header == result_header_1 || lhs_header == result_header_2))
 
158
            {
 
159
              if (result_fwd_decl_ok)
 
160
                printf ("class %s\n", lhs_type) >> h_file;
 
161
              else
 
162
                printf ("#include \"%s\"\n", lhs_header) >> h_file;
 
163
            }
 
164
 
 
165
          if (rhs_header && ! (rhs_header == lhs_header || rhs_header == result_header_1 || rhs_header == result_header_2))
 
166
            {
 
167
              if (result_fwd_decl_ok)
 
168
                printf ("class %s\n", rhs_type) >> h_file;
 
169
              else
 
170
                printf ("#include \"%s\"\n", rhs_header) >> h_file;
 
171
            }
 
172
 
 
173
          printf ("#include \"Sparse-op-defs.h\"\n") >> h_file;
 
174
 
 
175
          if (bin_ops)
 
176
            printf ("SPARSE_%s%s_BIN_OP_DECLS (%s, %s, %s, %s, OCTAVE_API)\n", lhs_class,
 
177
                    rhs_class, result_type_1, result_type_2, lhs_type, 
 
178
                    rhs_type) >> h_file
 
179
 
 
180
          if (cmp_ops)
 
181
            printf ("SPARSE_%s%s_CMP_OP_DECLS (%s, %s, OCTAVE_API)\n", lhs_class,
 
182
                    rhs_class, lhs_type, rhs_type) >> h_file
 
183
 
 
184
          if (eqne_ops)
 
185
            printf ("SPARSE_%s%s_EQNE_OP_DECLS (%s, %s, OCTAVE_API)\n", lhs_class,
 
186
                    rhs_class, lhs_type, rhs_type) >> h_file
 
187
 
 
188
          if (bool_ops)
 
189
            printf ("SPARSE_%s%s_BOOL_OP_DECLS (%s, %s, OCTAVE_API)\n", lhs_class,
 
190
                    rhs_class, lhs_type, rhs_type) >> h_file
 
191
 
 
192
 
 
193
          print "#endif" >> h_file;
 
194
 
 
195
          close (h_file);
 
196
 
 
197
 
 
198
          print "// DO NOT EDIT -- generated by sparse-mk-ops" > cc_file;
 
199
 
 
200
          ## print "#ifdef HAVE_CONFIG_H" >> cc_file;
 
201
          print "#include <config.h>" >> cc_file;
 
202
          ## print "#endif" >> cc_file;
 
203
 
 
204
          print "#include \"Array-util.h\"" >> cc_file;
 
205
          print "#include \"quit.h\"" >> cc_file;
 
206
 
 
207
          printf ("#include \"%s\"\n", h_file) >> cc_file;
 
208
 
 
209
          for (i in bool_headers)
 
210
            {
 
211
              printf ("#include \"%s\"\n", bool_headers[i]) >> cc_file;
 
212
              delete bool_headers[i];
 
213
            }
 
214
 
 
215
          if (result_header_1)
 
216
            printf ("#include \"%s\"\n", result_header_1) >> cc_file;
 
217
 
 
218
          if (result_header_2 && ! (result_header_2 == result_header_1))
 
219
            printf ("#include \"%s\"\n", result_header_2) >> cc_file;
 
220
 
 
221
          if (lhs_header && ! (lhs_header == result_header_1 || lhs_header == result_header_2))
 
222
            printf ("#include \"%s\"\n", lhs_header) >> cc_file;
 
223
 
 
224
          if (rhs_header && ! (rhs_header == lhs_header || rhs_header == result_header_1 || rhs_heaer == result_header_2))
 
225
            printf ("#include \"%s\"\n", rhs_header) >> cc_file;
 
226
 
 
227
          if (bin_ops)
 
228
            printf ("SPARSE_%s%s_BIN_OPS (%s, %s, %s, %s)\n", lhs_class, 
 
229
                    rhs_class, result_type_1, result_type_2, lhs_type, 
 
230
                    rhs_type) >> cc_file
 
231
 
 
232
          if (cmp_ops)
 
233
            printf ("SPARSE_%s%s_CMP_OPS (%s, %s, %s, %s, %s, %s)\n", 
 
234
                    lhs_class, rhs_class, lhs_type, lhs_scalar_zero_val,
 
235
                    lhs_conv, rhs_type, rhs_scalar_zero_val, rhs_conv) >> cc_file
 
236
 
 
237
          if (eqne_ops)
 
238
            printf ("SPARSE_%s%s_EQNE_OPS (%s, %s, %s, %s, %s, %s)\n", 
 
239
                    lhs_class, rhs_class, lhs_type, lhs_scalar_zero_val,
 
240
                    lhs_conv, rhs_type, rhs_scalar_zero_val, rhs_conv) >> cc_file
 
241
 
 
242
          if (bool_ops)
 
243
            printf ("SPARSE_%s%s_BOOL_OPS2 (%s, %s, %s, %s)\n", lhs_class, 
 
244
                    rhs_class, lhs_type, rhs_type, lhs_scalar_zero_val,
 
245
                    rhs_scalar_zero_val) >> cc_file
 
246
 
 
247
 
 
248
          close (cc_file);
 
249
        }
 
250
      else
 
251
        printf ("skipping line %d: %s\n", NR, $0); 
 
252
    }
 
253
}
 
254
END {
 
255
  if (make_inclusive_header)
 
256
    print "#endif";
 
257
}