├── Assembler.cpp
├── README.md
├── input.txt
├── output_binary.txt
└── output_hexa.txt


/Assembler.cpp:
--------------------------------------------------------------------------------
  1 | #include <bits/stdc++.h>
  2 | #include <sstream>
  3 | #include <string>
  4 | 
  5 | using namespace std;
  6 | 
  7 | 
  8 | void BinarytoHex(string binnum,ofstream &out)
  9 | {
 10 |     char hexa[1000];
 11 |     string app="";
 12 |     int temp;
 13 |     long int i=0,j=0;
 14 | 
 15 |     while(binnum[i]){
 16 |         binnum[i] = binnum[i] -48;
 17 |         ++i;
 18 |     }
 19 |     --i;
 20 |     while(i-2>=0){
 21 |         temp =  binnum[i-3] *8 + binnum[i-2] *4 +  binnum[i-1] *2 + binnum[i] ;
 22 |         if(temp > 9)
 23 |             hexa[j++] = temp + 55;
 24 |         else
 25 |             hexa[j++] = temp + 48;
 26 |         i=i-4;
 27 |     }
 28 |     if(i ==1)
 29 |         hexa[j] = binnum[i-1] *2 + binnum[i] + 48 ;
 30 |     else if(i==0)
 31 |         hexa[j] =  binnum[i] + 48 ;
 32 |     else
 33 |         --j;
 34 | 
 35 |     while(j>=0){
 36 |         app += hexa[j--];
 37 |     }
 38 |     out<<app<<endl;
 39 | }
 40 | 
 41 | ///Convert decimalToBinary
 42 | string  decimalToBinary_four(int n)
 43 | {
 44 |     std::string binary = std::bitset<4>(n).to_string();
 45 | 
 46 |     return binary;
 47 | }
 48 | 
 49 | string  decimalToBinary_ten(int n)
 50 | {
 51 |     std::string binary = std::bitset<10>(n).to_string();
 52 | 
 53 |     return binary;
 54 | }
 55 | 
 56 | int main()
 57 | {
 58 | 
 59 |     string binary,bin;
 60 |     ifstream input;
 61 |     input.open("input.txt");
 62 |     ofstream output;
 63 |     output.open("output_binary.txt");
 64 |     ofstream output2;
 65 |     output2.open("output_hexa.txt");
 66 | 
 67 |     string op, rs, rt, rd, j,cons ;
 68 |     string instruction,fil;
 69 | 
 70 |     string opn, rsn, rtn, rdn ;
 71 | 
 72 |     string R[2][13];
 73 |     int temp=1;
 74 | 
 75 |     R[0][0] = "ADD";
 76 |     R[1][0] = "0000";
 77 | 
 78 |     R[0][1] = "SUB";
 79 |     R[1][1] = "0001";
 80 | 
 81 |     R[0][2] = "SRL";
 82 |     R[1][2] = "0010";
 83 | 
 84 |     R[0][3] = "SLL";
 85 |     R[1][3] = "0011";
 86 | 
 87 |     R[0][4] = "AND";
 88 |     R[1][4] = "0100";
 89 | 
 90 |     R[0][5] = "OR";
 91 |     R[1][5] = "0101";
 92 | 
 93 |     R[0][6] = "XOR";
 94 |     R[1][6] = "0110";
 95 | 
 96 |     R[0][7] = "ADDI";
 97 |     R[1][7] = "0111";
 98 | 
 99 |     R[0][8] = "LW";
100 |     R[1][8] = "1000";
101 | 
102 |     R[0][9] = "SW";
103 |     R[1][9] = "1001";
104 | 
105 |     R[0][10] = "BEQ";
106 |     R[1][10] = "1010";
107 | 
108 |     R[0][11] = "BNE";
109 |     R[1][11] = "1011";
110 | 
111 |     R[0][12] = "J";
112 |     R[1][12] = "1100";
113 | 
114 | 
115 |     string registers[2][8];
116 | 
117 | 
118 |     registers[0][0] = "$zero";
119 |     registers[1][0] = "000";
120 | 
121 |     registers[0][1] = "$t0";
122 |     registers[1][1] = "001";
123 | 
124 |     registers[0][2] = "$t1";
125 |     registers[1][2] = "010";
126 | 
127 |     registers[0][3] = "$t2";
128 |     registers[1][3] = "011";
129 | 
130 |     registers[0][4] = "$t3";
131 |     registers[1][4] = "100";
132 | 
133 |     registers[0][5] = "$s0";
134 |     registers[1][5] = "101";
135 | 
136 |     registers[0][6] = "$s1";
137 |     registers[1][6] = "110";
138 | 
139 |     registers[0][7] = "$s2";
140 |     registers[1][7] = "111";
141 | 
142 |     int i;
143 | 
144 |     while(input>>instruction)
145 |     {
146 | 
147 |         for( i=0; i<13; i++)
148 |         {
149 |             if(instruction == R[0][i])
150 |             {
151 |                 op = R[1][i];
152 |                 break;
153 |             }
154 |         }
155 | 
156 |         if(i==13)
157 |         {
158 |             cout<<"Instruction not found!"<<endl;
159 |         }
160 | 
161 | 
162 |         if(op=="0000"||op=="0001"||op=="0100"||op=="0101"||op=="0110") ///ADD+SUB+AND+OR+XOR
163 |         {
164 |             string rs,rd,rt;
165 | 
166 |             input>>rd>>rs>>rt;
167 | 
168 |             rd.erase(rd.begin()+rd.length()-1, rd.end());
169 |             rs.erase(rs.begin()+rs.length()-1, rs.end());
170 | 
171 |             int count = 0;
172 |             for(int i=0; i<8; i++)
173 |             {
174 |                 if(count==3)
175 |                 {
176 |                     break;
177 |                 }
178 |                 if(rd==registers[0][i])
179 |                 {
180 |                     rdn = registers[1][i];
181 | 
182 |                     if(rdn=="000")
183 |                     {
184 |                         cout<<"Zero can't be used"<<endl;
185 |                         temp=0;
186 | 
187 |                         break;
188 |                     }
189 |                     count++;
190 |                 }
191 |                 if(rs==registers[0][i])
192 |                 {
193 |                     rsn = registers[1][i];
194 |                     count++;
195 |                 }
196 |                 if(rt==registers[0][i])
197 |                 {
198 |                     rtn = registers[1][i];
199 |                     count++;
200 |                 }
201 |             }
202 | 
203 |             if(temp)
204 |             {
205 |                 string shbin ="0";
206 | 
207 |                 binary = op+rdn+rsn+rtn+shbin;
208 |                 BinarytoHex(binary,output2);
209 | 
210 |                 output<<op<<rdn<<rsn<<rtn<<shbin<<endl;
211 |             }
212 |             else
213 |             {
214 |                 output<<endl;
215 |             }
216 |             temp=1;
217 |         }
218 | 
219 |         else if(op=="0111")      ///ADDI
220 |         {
221 |             string shstr;
222 |             stringstream shstrtemp;
223 |             int sh;
224 |             string shbin;
225 |             input>>rd>>rs>>sh;
226 |             if(sh>15)
227 |             {
228 |                 cout<<"Invalid Address"<<endl;
229 |                 temp=0;
230 |             }
231 |             if(sh<0)
232 |             {
233 |                 cout<<"Invalid Address"<<endl;
234 |                 temp=0;
235 |             }
236 |             else
237 |             {
238 |                 shbin=decimalToBinary_four(sh);
239 |             }
240 |             rd.erase(rd.begin()+rd.length()-1, rd.end());
241 |             rs.erase(rs.begin()+rs.length()-1, rs.end());
242 |             int count = 0;
243 | 
244 |             for(int i=0; i<8; i++)
245 |             {
246 |                 if(count==2)
247 |                 {
248 |                     break;
249 |                 }
250 |                 if(rd==registers[0][i])
251 |                 {
252 |                     rdn = registers[1][i];
253 |                     if((rdn=="000" && op=="0111"))
254 |                     {
255 |                         cout<<"Zero can't be used"<<endl;
256 |                         temp=0;
257 |                         break;
258 |                     }
259 |                     count++;
260 |                 }
261 | 
262 |                 if(rs==registers[0][i])
263 |                 {
264 |                     rsn = registers[1][i];
265 |                     count++;
266 |                 }
267 |             }
268 | 
269 |             j ="000";
270 | 
271 |             if(temp)
272 |             {
273 |                 binary = op+rdn+rsn+shbin;
274 |                 output<<op<<rdn<<rsn<<shbin<<endl;
275 | 
276 |                 BinarytoHex(binary,output2);
277 |             }
278 |             else
279 |             {
280 |                 output<<endl;
281 |             }
282 | 
283 |             temp=1;
284 |         }
285 | 
286 | 
287 | 
288 |         else if(op=="0010" || op=="0011")      ///SRL+SLL
289 |         {
290 |             string shstr;
291 |             stringstream shstrtemp;
292 |             int sh;
293 |             string shbin;
294 |             input>>rd>>rs>>sh;
295 |             if(sh>1)
296 |             {
297 |                 cout<<"Invalid Address"<<endl;
298 |                 temp=0;
299 |             }
300 |             if(sh<0)
301 |             {
302 |                 cout<<"Invalid Address"<<endl;
303 |                 temp=0;
304 |             }
305 |             else
306 |             {
307 |                 shbin=decimalToBinary_four(sh);
308 |             }
309 |             rd.erase(rd.begin()+rd.length()-1, rd.end());
310 |             rs.erase(rs.begin()+rs.length()-1, rs.end());
311 |             int count = 0;
312 | 
313 |             for(int i=0; i<8; i++)
314 |             {
315 |                 if(count==2)
316 |                 {
317 |                     break;
318 |                 }
319 |                 if(rd==registers[0][i])
320 |                 {
321 |                     rdn = registers[1][i];
322 |                     if((rdn=="000" && op=="0010") || (rdn=="000" && op=="0011"))
323 |                     {
324 |                         cout<<"Zero can't be used"<<endl;
325 |                         temp=0;
326 |                         break;
327 |                     }
328 |                     count++;
329 |                 }
330 | 
331 |                 if(rs==registers[0][i])
332 |                 {
333 |                     rsn = registers[1][i];
334 |                     count++;
335 |                 }
336 |             }
337 | 
338 | 
339 |             if(temp)
340 |             {
341 |                 binary = op+rdn+rsn+shbin;
342 |                 output<<op<<rdn<<rsn<<shbin<<endl;
343 | 
344 |                 BinarytoHex(binary,output2);
345 |             }
346 |             else
347 |             {
348 |                 output<<endl;
349 |             }
350 | 
351 |             temp=1;
352 |         }
353 | 
354 | 
355 |         else if(op=="1010" || op =="1011")      ///BEQ+BNE
356 |         {
357 |             string shstr;
358 |             stringstream shstrtemp;
359 |             int sh;
360 |             string shbin;
361 |             input>>rd>>rs>>sh;
362 | 
363 |             if( sh<0)
364 |             {
365 |                 cout<<"Invalid Address"<<endl;
366 |                 temp=0;
367 |             }
368 |             if(sh>15)
369 |             {
370 |                 cout<<"Invalid Address"<<endl;
371 |                 temp=0;
372 |             }
373 | 
374 |             else
375 |             {
376 |                 shbin=decimalToBinary_four(sh);
377 | 
378 |             }
379 |             rd.erase(rd.begin()+rd.length()-1, rd.end());
380 |             rs.erase(rs.begin()+rs.length()-1, rs.end());
381 | 
382 | 
383 |             int count = 0;
384 | 
385 |             for(int i=0; i<8; i++)
386 |             {
387 |                 if(count==2)
388 |                 {
389 |                     break;
390 |                 }
391 |                 if(rd==registers[0][i])
392 |                 {
393 |                     rdn = registers[1][i];
394 |                     if((rdn=="000" && op=="1010") || (rdn =="000" && op == "1011"))
395 |                     {
396 |                         cout<<"Zero can't be used"<<endl;
397 |                         temp=0;
398 |                         break;
399 |                     }
400 |                     count++;
401 |                 }
402 | 
403 |                 if(rs==registers[0][i])
404 |                 {
405 |                     rsn = registers[1][i];
406 |                     count++;
407 |                 }
408 |             }
409 | 
410 | 
411 |             j ="000";
412 | 
413 |             if(temp)
414 |             {
415 | 
416 |                 binary = op+rdn+rsn+shbin;
417 |                 output <<op<<rdn<<rsn<<shbin<<endl;
418 | 
419 |                 BinarytoHex(binary,output2);
420 |             }
421 |             else
422 |             {
423 |                 output<<endl;
424 |             }
425 | 
426 |             temp=1;
427 |         }
428 | 
429 |         else if(op=="1000"||op=="1001")       ///LW+SW
430 |         {
431 |             registers[0][0] = "$zero";
432 | 
433 |             string rdin, rsin;
434 |             string immediate, source;
435 |             input>>rdin>>source;
436 |             for(int i=0; i<source.length(); i++)
437 |             {
438 |                 if(source[i]=='$')
439 |                 {
440 |                     rsin = rsin+source[i]+source[i+1]+source[i+2];
441 |                     break;
442 |                 }
443 |             }
444 |             for(int i=0; i<source.length(); i++)
445 |             {
446 |                 if(source[i]=='(')
447 |                     break;
448 |                 immediate = immediate+source[i];
449 |             }
450 |             rdin.erase(rdin.begin()+rdin.length()-1, rdin.end());
451 |             int value = atoi(immediate.c_str());
452 |                 //value*=2;
453 | 
454 |             int count = 0;
455 | 
456 |             for(int i=0; i<8; i++)
457 |             {
458 |                 if(count==3)
459 |                 {
460 |                     break;
461 |                 }
462 |                 if(rdin==registers[0][i])
463 |                 {
464 |                     rdn = registers[1][i];
465 |                     if(rdn=="000")
466 |                     {
467 |                         cout<<"Zero can't be used"<<endl;
468 |                         temp=0;
469 |                         break;
470 |                     }
471 |                     count++;
472 |                 }
473 |                 if(rsin==registers[0][i])
474 |                 {
475 |                     rsn = registers[1][i];
476 |                     count++;
477 |                 }
478 | 
479 |             }
480 | 
481 |             if(value>=0 && value <16)
482 |             {
483 |                 string shbin=decimalToBinary_four(value);
484 | 
485 |                 immediate =shbin;
486 | 
487 |                 if(temp)
488 |                 {
489 |                     output<<op<<rdn<<rsn<<immediate<<endl;
490 |                     binary =op+rdn+rsn+immediate;
491 |                     BinarytoHex(binary,output2);
492 |                 }
493 |                 else
494 |                 {
495 |                     output<<endl;
496 |                 }
497 | 
498 |             }
499 |             else
500 |             {
501 |                 cout<<"Invalid Offset!"<<endl;
502 |                 output<<endl;
503 |             }
504 | 
505 |             temp=1;
506 |             registers[0][0] = "$zero";
507 | 
508 |         }
509 | 
510 |         else if(op=="1100")       ///j
511 |         {
512 |             string shstr;
513 |             stringstream shstrtemp;
514 |             int sh,temp=1;
515 |             string shbin;
516 | 
517 | 
518 |             input>>sh;
519 |             if(sh<0)
520 |             {
521 |                 cout<<"Invalid address"<<endl;
522 |                 temp=0;
523 | 
524 |             }
525 |             if(sh>1024)
526 |             {
527 |                 cout<<"Invalid address"<<endl;
528 |                 temp=0;
529 | 
530 |             }
531 |             else
532 |             {
533 |                 shbin=decimalToBinary_ten(sh);
534 |             }
535 |             rd.erase(rd.begin()+rd.length()-1, rd.end());
536 |             rs.erase(rs.begin()+rs.length()-1, rs.end());
537 | 
538 |             if(temp)
539 |             {
540 |                 output<<op<<shbin<< endl;
541 | 
542 |                 binary=op+shbin;
543 | 
544 |                 BinarytoHex(binary,output2);
545 |             }
546 |             else
547 |             {
548 |                 output<<endl;
549 |             }
550 | 
551 |             temp=1;
552 |         }
553 |     }
554 | 
555 |     cout<<"Successfully converted to binary as well as hexadecimal"<<endl;
556 | 
557 |     return 0;
558 | }
559 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | ## RISC Assembler
2 | This is risc assembler using C++ which convert instruction to machine code.


--------------------------------------------------------------------------------
/input.txt:
--------------------------------------------------------------------------------
 1 | ADD $t0, $t1, $s2
 2 | SUB $s2, $t3, $t1
 3 | SRL $t1, $s2, 1
 4 | SLL $t3, $t1, 1
 5 | AND $t0, $t2, $s2
 6 | OR $t1, $s2, $s1
 7 | XOR $t3, $t2, $t1
 8 | ADDI $t2, $s1, 7
 9 | BEQ $t0, $t1, 12
10 | BNE $t2, $s2, 2
11 | SW $s0, 7($t0)
12 | LW $t2, 2($t3)
13 | J 2
14 | 


--------------------------------------------------------------------------------
/output_binary.txt:
--------------------------------------------------------------------------------
 1 | 00000010101110
 2 | 00011111000100
 3 | 00100101110001
 4 | 00111000100001
 5 | 01000010111110
 6 | 01010101111100
 7 | 01101000110100
 8 | 01110111100111
 9 | 10100010101100
10 | 10110111110010
11 | 10011010010111
12 | 10000111000010
13 | 11000000000010
14 | 


--------------------------------------------------------------------------------
/output_hexa.txt:
--------------------------------------------------------------------------------
 1 | 00AE
 2 | 07C4
 3 | 0971
 4 | 0E21
 5 | 10BE
 6 | 157C
 7 | 1A34
 8 | 1DE7
 9 | 28AC
10 | 2DF2
11 | 2697
12 | 21C2
13 | 3002
14 | 


--------------------------------------------------------------------------------