← Back to branch summary

~ubuntu-branches/debian/sid/freehdl/sid

« back to all changes in this revision

Viewing changes to ieee/std_logic_unsigned.vhdl

  • Committer: Bazaar Package Importer
  • Author(s): José L. Redrejo Rodríguez
  • Date: 2007-03-17 11:53:16 UTC
  • Revision ID: james.westby@ubuntu.com-20070317115316-4dar2jcct6hz0f6f
Tags: upstream-0.0.4
Import upstream version 0.0.4

Show diffs side-by-side

added added

removed removed

Lines of Context:
ieee/std_logic_unsigned.vhdl
 
1
--------------------------------------------------------------------------
 
2
--                                                                      --
 
3
-- Copyright (c) 1990, 1991, 1992 by Synopsys, Inc.                     --
 
4
--                                             All rights reserved.     --
 
5
--                                                                      --
 
6
-- This source file may be used and distributed without restriction     --
 
7
-- provided that this copyright statement is not removed from the file  --
 
8
-- and that any derivative work contains this copyright notice.         --
 
9
--                                                                      --
 
10
--      Package name: STD_LOGIC_UNSIGNED                                --
 
11
--                                                                      --
 
12
--                                                                      --
 
13
--      Date:           09/11/92        KN                              --
 
14
--                      10/08/92        AMT                             --
 
15
--                                                                      --
 
16
--      Purpose:                                                        --
 
17
--       A set of unsigned arithemtic, conversion,                      --
 
18
--           and comparision functions for STD_LOGIC_VECTOR.            --
 
19
--                                                                      --
 
20
--      Note:  comparision of same length discrete arrays is defined    --
 
21
--              by the LRM.  This package will "overload" those         --
 
22
--              definitions                                             --
 
23
--                                                                      --
 
24
--------------------------------------------------------------------------
 
25
 
 
26
library IEEE;
 
27
use IEEE.std_logic_1164.all;
 
28
use IEEE.std_logic_arith.all;
 
29
 
 
30
package STD_LOGIC_UNSIGNED is
 
31
 
 
32
    function "+"(L: STD_LOGIC_VECTOR; R: STD_LOGIC_VECTOR) return STD_LOGIC_VECTOR;
 
33
    function "+"(L: STD_LOGIC_VECTOR; R: INTEGER) return STD_LOGIC_VECTOR;
 
34
    function "+"(L: INTEGER; R: STD_LOGIC_VECTOR) return STD_LOGIC_VECTOR;
 
35
    function "+"(L: STD_LOGIC_VECTOR; R: STD_LOGIC) return STD_LOGIC_VECTOR;
 
36
    function "+"(L: STD_LOGIC; R: STD_LOGIC_VECTOR) return STD_LOGIC_VECTOR;
 
37
 
 
38
    function "-"(L: STD_LOGIC_VECTOR; R: STD_LOGIC_VECTOR) return STD_LOGIC_VECTOR;
 
39
    function "-"(L: STD_LOGIC_VECTOR; R: INTEGER) return STD_LOGIC_VECTOR;
 
40
    function "-"(L: INTEGER; R: STD_LOGIC_VECTOR) return STD_LOGIC_VECTOR;
 
41
    function "-"(L: STD_LOGIC_VECTOR; R: STD_LOGIC) return STD_LOGIC_VECTOR;
 
42
    function "-"(L: STD_LOGIC; R: STD_LOGIC_VECTOR) return STD_LOGIC_VECTOR;
 
43
 
 
44
    function "+"(L: STD_LOGIC_VECTOR) return STD_LOGIC_VECTOR;
 
45
 
 
46
    function "*"(L: STD_LOGIC_VECTOR; R: STD_LOGIC_VECTOR) return STD_LOGIC_VECTOR;
 
47
 
 
48
    function "<"(L: STD_LOGIC_VECTOR; R: STD_LOGIC_VECTOR) return BOOLEAN;
 
49
    function "<"(L: STD_LOGIC_VECTOR; R: INTEGER) return BOOLEAN;
 
50
    function "<"(L: INTEGER; R: STD_LOGIC_VECTOR) return BOOLEAN;
 
51
 
 
52
    function "<="(L: STD_LOGIC_VECTOR; R: STD_LOGIC_VECTOR) return BOOLEAN;
 
53
    function "<="(L: STD_LOGIC_VECTOR; R: INTEGER) return BOOLEAN;
 
54
    function "<="(L: INTEGER; R: STD_LOGIC_VECTOR) return BOOLEAN;
 
55
 
 
56
    function ">"(L: STD_LOGIC_VECTOR; R: STD_LOGIC_VECTOR) return BOOLEAN;
 
57
    function ">"(L: STD_LOGIC_VECTOR; R: INTEGER) return BOOLEAN;
 
58
    function ">"(L: INTEGER; R: STD_LOGIC_VECTOR) return BOOLEAN;
 
59
 
 
60
    function ">="(L: STD_LOGIC_VECTOR; R: STD_LOGIC_VECTOR) return BOOLEAN;
 
61
    function ">="(L: STD_LOGIC_VECTOR; R: INTEGER) return BOOLEAN;
 
62
    function ">="(L: INTEGER; R: STD_LOGIC_VECTOR) return BOOLEAN;
 
63
 
 
64
--  function "="(L: STD_LOGIC_VECTOR; R: STD_LOGIC_VECTOR) return BOOLEAN;
 
65
    function "="(L: STD_LOGIC_VECTOR; R: INTEGER) return BOOLEAN;
 
66
    function "="(L: INTEGER; R: STD_LOGIC_VECTOR) return BOOLEAN;
 
67
 
 
68
    function "/="(L: STD_LOGIC_VECTOR; R: STD_LOGIC_VECTOR) return BOOLEAN;
 
69
    function "/="(L: STD_LOGIC_VECTOR; R: INTEGER) return BOOLEAN;
 
70
    function "/="(L: INTEGER; R: STD_LOGIC_VECTOR) return BOOLEAN;
 
71
    function SHL(ARG:STD_LOGIC_VECTOR;COUNT: STD_LOGIC_VECTOR) return STD_LOGIC_VECTOR;
 
72
    function SHR(ARG:STD_LOGIC_VECTOR;COUNT: STD_LOGIC_VECTOR) return STD_LOGIC_VECTOR;
 
73
 
 
74
    function CONV_INTEGER(ARG: STD_LOGIC_VECTOR) return INTEGER;
 
75
 
 
76
-- remove this since it is already in std_logic_arith
 
77
--    function CONV_STD_LOGIC_VECTOR(ARG: INTEGER; SIZE: INTEGER) return STD_LOGIC_VECTOR;
 
78
 
 
79
end STD_LOGIC_UNSIGNED;
 
80
 
 
81
 
 
82
 
 
83
library IEEE;
 
84
use IEEE.std_logic_1164.all;
 
85
use IEEE.std_logic_arith.all;
 
86
 
 
87
package body STD_LOGIC_UNSIGNED is
 
88
 
 
89
 
 
90
    function maximum(L, R: INTEGER) return INTEGER is
 
91
    begin
 
92
        if L > R then
 
93
            return L;
 
94
        else
 
95
            return R;
 
96
        end if;
 
97
    end;
 
98
 
 
99
 
 
100
    function "+"(L: STD_LOGIC_VECTOR; R: STD_LOGIC_VECTOR) return STD_LOGIC_VECTOR is
 
101
        -- pragma label_applies_to plus
 
102
        constant length: INTEGER := maximum(L'length, R'length);
 
103
        variable result  : STD_LOGIC_VECTOR (length-1 downto 0);
 
104
    begin
 
105
        result  := UNSIGNED(L) + UNSIGNED(R);-- pragma label plus
 
106
        return   std_logic_vector(result);
 
107
    end;
 
108
 
 
109
    function "+"(L: STD_LOGIC_VECTOR; R: INTEGER) return STD_LOGIC_VECTOR is
 
110
        -- pragma label_applies_to plus
 
111
        variable result  : STD_LOGIC_VECTOR (L'range);
 
112
    begin
 
113
        result  := UNSIGNED(L) + R;-- pragma label plus
 
114
        return   std_logic_vector(result);
 
115
    end;
 
116
 
 
117
    function "+"(L: INTEGER; R: STD_LOGIC_VECTOR) return STD_LOGIC_VECTOR is
 
118
        -- pragma label_applies_to plus
 
119
        variable result  : STD_LOGIC_VECTOR (R'range);
 
120
    begin
 
121
        result  := L + UNSIGNED(R);-- pragma label plus
 
122
        return   std_logic_vector(result);
 
123
    end;
 
124
 
 
125
    function "+"(L: STD_LOGIC_VECTOR; R: STD_LOGIC) return STD_LOGIC_VECTOR is
 
126
        -- pragma label_applies_to plus
 
127
        variable result  : STD_LOGIC_VECTOR (L'range);
 
128
    begin
 
129
        result  := UNSIGNED(L) + R;-- pragma label plus
 
130
        return   std_logic_vector(result);
 
131
    end;
 
132
 
 
133
    function "+"(L: STD_LOGIC; R: STD_LOGIC_VECTOR) return STD_LOGIC_VECTOR is
 
134
            -- pragma label_applies_to plus
 
135
    variable result  : STD_LOGIC_VECTOR (R'range);
 
136
    begin
 
137
        result  := L + UNSIGNED(R);-- pragma label plus
 
138
        return   std_logic_vector(result);
 
139
    end;
 
140
 
 
141
    function "-"(L: STD_LOGIC_VECTOR; R: STD_LOGIC_VECTOR) return STD_LOGIC_VECTOR is
 
142
        -- pragma label_applies_to minus
 
143
        constant length: INTEGER := maximum(L'length, R'length);
 
144
        variable result  : STD_LOGIC_VECTOR (length-1 downto 0);
 
145
    begin
 
146
        result  := UNSIGNED(L) - UNSIGNED(R); -- pragma label minus
 
147
        return   std_logic_vector(result);
 
148
    end;
 
149
 
 
150
    function "-"(L: STD_LOGIC_VECTOR; R: INTEGER) return STD_LOGIC_VECTOR is
 
151
        -- pragma label_applies_to minus
 
152
        variable result  : STD_LOGIC_VECTOR (L'range);
 
153
    begin
 
154
        result  := UNSIGNED(L) - R; -- pragma label minus
 
155
        return   std_logic_vector(result);
 
156
    end;
 
157
 
 
158
    function "-"(L: INTEGER; R: STD_LOGIC_VECTOR) return STD_LOGIC_VECTOR is
 
159
        -- pragma label_applies_to minus
 
160
        variable result  : STD_LOGIC_VECTOR (R'range);
 
161
    begin
 
162
        result  := L - UNSIGNED(R);  -- pragma label minus
 
163
        return   std_logic_vector(result);
 
164
    end;
 
165
 
 
166
    function "-"(L: STD_LOGIC_VECTOR; R: STD_LOGIC) return STD_LOGIC_VECTOR is
 
167
        variable result  : STD_LOGIC_VECTOR (L'range);
 
168
    begin
 
169
        result  := UNSIGNED(L) - R;
 
170
        return   std_logic_vector(result);
 
171
    end;
 
172
 
 
173
    function "-"(L: STD_LOGIC; R: STD_LOGIC_VECTOR) return STD_LOGIC_VECTOR is
 
174
        -- pragma label_applies_to minus
 
175
        variable result  : STD_LOGIC_VECTOR (R'range);
 
176
    begin
 
177
        result  := L - UNSIGNED(R);  -- pragma label minus
 
178
        return   std_logic_vector(result);
 
179
    end;
 
180
 
 
181
    function "+"(L: STD_LOGIC_VECTOR) return STD_LOGIC_VECTOR is
 
182
        variable result  : STD_LOGIC_VECTOR (L'range);
 
183
    begin
 
184
        result  := + UNSIGNED(L);
 
185
        return   std_logic_vector(result);
 
186
    end;
 
187
 
 
188
    function "*"(L: STD_LOGIC_VECTOR; R: STD_LOGIC_VECTOR) return STD_LOGIC_VECTOR is
 
189
        -- pragma label_applies_to mult
 
190
        constant length: INTEGER := maximum(L'length, R'length);
 
191
        variable result  : STD_LOGIC_VECTOR ((L'length+R'length-1) downto 0);
 
192
    begin
 
193
        result  := UNSIGNED(L) * UNSIGNED(R); -- pragma label mult
 
194
        return   std_logic_vector(result);
 
195
    end;
 
196
        
 
197
    function "<"(L: STD_LOGIC_VECTOR; R: STD_LOGIC_VECTOR) return BOOLEAN is
 
198
        -- pragma label_applies_to lt
 
199
        constant length: INTEGER := maximum(L'length, R'length);
 
200
    begin
 
201
        return   UNSIGNED(L) < UNSIGNED(R); -- pragma label lt
 
202
    end;
 
203
 
 
204
    function "<"(L: STD_LOGIC_VECTOR; R: INTEGER) return BOOLEAN is
 
205
        -- pragma label_applies_to lt
 
206
    begin
 
207
        return   UNSIGNED(L) < R; -- pragma label lt
 
208
    end;
 
209
 
 
210
    function "<"(L: INTEGER; R: STD_LOGIC_VECTOR) return BOOLEAN is
 
211
        -- pragma label_applies_to lt
 
212
    begin
 
213
        return   L < UNSIGNED(R); -- pragma label lt
 
214
    end;
 
215
 
 
216
    function "<="(L: STD_LOGIC_VECTOR; R: STD_LOGIC_VECTOR) return BOOLEAN is
 
217
       -- pragma label_applies_to leq
 
218
    begin
 
219
        return   UNSIGNED(L) <= UNSIGNED(R); -- pragma label leq
 
220
    end;
 
221
 
 
222
    function "<="(L: STD_LOGIC_VECTOR; R: INTEGER) return BOOLEAN is
 
223
       -- pragma label_applies_to leq
 
224
    begin
 
225
        return   UNSIGNED(L) <= R; -- pragma label leq
 
226
    end;
 
227
 
 
228
    function "<="(L: INTEGER; R: STD_LOGIC_VECTOR) return BOOLEAN is
 
229
       -- pragma label_applies_to leq
 
230
    begin
 
231
        return   L <= UNSIGNED(R); -- pragma label leq
 
232
    end;
 
233
 
 
234
    function ">"(L: STD_LOGIC_VECTOR; R: STD_LOGIC_VECTOR) return BOOLEAN is
 
235
        -- pragma label_applies_to gt
 
236
    begin
 
237
        return   UNSIGNED(L) > UNSIGNED(R); -- pragma label gt
 
238
    end;
 
239
 
 
240
    function ">"(L: STD_LOGIC_VECTOR; R: INTEGER) return BOOLEAN is
 
241
        -- pragma label_applies_to gt
 
242
    begin
 
243
        return   UNSIGNED(L) > R; -- pragma label gt
 
244
    end;
 
245
 
 
246
    function ">"(L: INTEGER; R: STD_LOGIC_VECTOR) return BOOLEAN is
 
247
        -- pragma label_applies_to gt
 
248
    begin
 
249
        return   L > UNSIGNED(R); -- pragma label gt
 
250
    end;
 
251
 
 
252
    function ">="(L: STD_LOGIC_VECTOR; R: STD_LOGIC_VECTOR) return BOOLEAN is
 
253
        -- pragma label_applies_to geq
 
254
    begin
 
255
        return   UNSIGNED(L) >= UNSIGNED(R);  -- pragma label geq
 
256
    end;
 
257
 
 
258
    function ">="(L: STD_LOGIC_VECTOR; R: INTEGER) return BOOLEAN is
 
259
        -- pragma label_applies_to geq
 
260
    begin
 
261
        return   UNSIGNED(L) >= R;  -- pragma label geq
 
262
    end;
 
263
 
 
264
    function ">="(L: INTEGER; R: STD_LOGIC_VECTOR) return BOOLEAN is
 
265
        -- pragma label_applies_to geq
 
266
    begin
 
267
        return   L >= UNSIGNED(R);  -- pragma label geq
 
268
    end;
 
269
 
 
270
    function "="(L: STD_LOGIC_VECTOR; R: STD_LOGIC_VECTOR) return BOOLEAN is
 
271
    begin
 
272
        return   UNSIGNED(L) = UNSIGNED(R);
 
273
    end;
 
274
 
 
275
    function "="(L: STD_LOGIC_VECTOR; R: INTEGER) return BOOLEAN is
 
276
    begin
 
277
        return   UNSIGNED(L) = R;
 
278
    end;
 
279
 
 
280
    function "="(L: INTEGER; R: STD_LOGIC_VECTOR) return BOOLEAN is
 
281
    begin
 
282
        return   L = UNSIGNED(R);
 
283
    end;
 
284
 
 
285
    function "/="(L: STD_LOGIC_VECTOR; R: STD_LOGIC_VECTOR) return BOOLEAN is
 
286
    begin
 
287
        return   UNSIGNED(L) /= UNSIGNED(R);
 
288
    end;
 
289
 
 
290
    function "/="(L: STD_LOGIC_VECTOR; R: INTEGER) return BOOLEAN is
 
291
    begin
 
292
        return   UNSIGNED(L) /= R;
 
293
    end;
 
294
 
 
295
    function "/="(L: INTEGER; R: STD_LOGIC_VECTOR) return BOOLEAN is
 
296
    begin
 
297
        return   L /= UNSIGNED(R);
 
298
    end;
 
299
 
 
300
    function CONV_INTEGER(ARG: STD_LOGIC_VECTOR) return INTEGER is
 
301
        variable result    : UNSIGNED(ARG'range);
 
302
    begin
 
303
        result    := UNSIGNED(ARG);
 
304
        return   CONV_INTEGER(result);
 
305
    end;
 
306
    function SHL(ARG:STD_LOGIC_VECTOR;COUNT: STD_LOGIC_VECTOR) return STD_LOGIC_VECTOR is
 
307
    begin
 
308
       return STD_LOGIC_VECTOR(SHL(UNSIGNED(ARG),UNSIGNED(COUNT)));
 
309
    end;
 
310
 
 
311
    function SHR(ARG:STD_LOGIC_VECTOR;COUNT: STD_LOGIC_VECTOR) return STD_LOGIC_VECTOR is
 
312
    begin
 
313
       return STD_LOGIC_VECTOR(SHR(UNSIGNED(ARG),UNSIGNED(COUNT)));
 
314
    end;
 
315
 
 
316
 
 
317
-- remove this since it is already in std_logic_arith
 
318
    --function CONV_STD_LOGIC_VECTOR(ARG: INTEGER; SIZE: INTEGER) return STD_LOGIC_VECTOR is
 
319
        --variable result1 : UNSIGNED (SIZE-1 downto 0);
 
320
        --variable result2 : STD_LOGIC_VECTOR (SIZE-1 downto 0);
 
321
    --begin
 
322
        --result1 := CONV_UNSIGNED(ARG,SIZE);
 
323
        --return   std_logic_vector(result1);
 
324
    --end;
 
325
 
 
326
 
 
327
end STD_LOGIC_UNSIGNED;
 
328
 
 
329