?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
grub2: bring back build of aros-side grub2 tools
[AROS.git] / workbench / libs / mesa / src / aros / misc / mesastubsgenerator.cs
blobefad8f16149f77f7d717435a315b5ab43c8c3ddc
1 using System;
2 using System.Collections.Generic;
3 using System.IO;
4
5
6 namespace glstubgenerator
7 {
8 class Argument
9 {
10 public string Type;
11 public string Name;
12 public string Register;
13 }
14
15 class ArgumentList: List<Argument>
16 {
17 }
18
19 class Function
20 {
21 public string ReturnType;
22 public string Name;
23 public ArgumentList Arguments = new ArgumentList();
24
25 public void CalculateRegisters()
26 {
27 int nextdreg = 0;
28 int nextareg = 0;
29
30 foreach(Argument a in Arguments)
31 {
32 if ((a.Type.IndexOf("*") >= 0) || (nextdreg > 7))
33 {
34 if (nextareg > 5)
35 throw new ApplicationException("A6 reached");
36
37 a.Register = string.Format("A{0}", nextareg++);
38 }
39 else
40 a.Register = string.Format("D{0}", nextdreg++);
41 }
42
43 }
44
45 public void CorrectionForArrayArguments()
46 {
47 bool correctioMade = false;
48 foreach(Argument a in Arguments)
49 {
50 int bracketpos = a.Name.IndexOf("[");
51 if (bracketpos >= 0)
52 {
53 /* Change array to pointer */
54 a.Type += " *";
55 a.Name = a.Name.Substring(0, bracketpos);
56 correctioMade = true;
57 }
58 }
59
60 if (correctioMade)
61 Console.WriteLine("Correction for array arguments: {0}", this.Name);
62 }
63
64 public bool ReturnsVoid()
65 {
66 if (ReturnType.Equals("void"))
67 return true;
68 else
69 return false;
70 }
71 }
72
73 class FunctionList : List<Function>
74 {
75 /// <summary>
76 /// Removes entries from this list which have the same name as an entry in other list
77 /// </summary>
78 /// <param name="other">
79 /// A <see cref="FunctionList"/>
80 /// </param>
81 public void RemoveFunctions(FunctionList other)
82 {
83 /* Copy this list to hashtable */
84 Dictionary<string, Function> temp = new Dictionary<string, Function>();
85 FunctionList toBeRemoved = new FunctionList();
86
87 foreach(Function f in this)
88 temp.Add(f.Name, f);
89
90 /* Find duplicates */
91 foreach(Function f in other)
92 if (temp.ContainsKey(f.Name))
93 {
94 Function thisf = temp[f.Name];
95 if (thisf.Arguments.Count != f.Arguments.Count)
96 throw new ApplicationException(string.Format("Same name, different arguments count: {0} {1} {2}",
97 f.Name, f.Arguments.Count, thisf.Arguments.Count));
98 toBeRemoved.Add(thisf);
99 }
100
101 foreach(Function f in toBeRemoved)
102 this.Remove(f);
103 }
104
105 public void RemoveFunctionByName(string functionName)
106 {
107 FunctionList toBeRemoved = new FunctionList();
108
109 foreach(Function f in this)
110 {
111 if (f.Name == functionName)
112 toBeRemoved.Add(f);
113 }
114
115 foreach(Function f in toBeRemoved)
116 {
117 this.Remove(f);
118 }
119 }
120
121 public void RemoveFunctionsExceptFor(FunctionNameDictionary functions)
122 {
123 FunctionList toBeRemoved = new FunctionList();
124
125 foreach(Function f in this)
126 {
127 if (!functions.ContainsKey(f.Name))
128 {
129 toBeRemoved.Add(f);
130 }
131 else
132 {
133 functions.MarkAsMatched(f.Name);
134 }
135 }
136
137 foreach(Function f in toBeRemoved)
138 {
139 this.Remove(f);
140 }
141 }
142
143 public void CorrectionForArrayArguments()
144 {
145 foreach (Function f in this)
146 f.CorrectionForArrayArguments();
147 }
148
149 public void CalculateRegisters()
150 {
151 foreach (Function f in this)
152 f.CalculateRegisters();
153 }
154
155 public void ReorderToMatch(FunctionList requestedOrderOfFunctions)
156 {
157 /* Rather not effective implementation
158 * For each item on ordered list, find it in this list, put to temp list, remove from this list
159 * when finished, copy remaining items on this list to temp list
160 * copy temp list to this list */
161 FunctionList tempList = new FunctionList();
162
163 foreach(Function ordered in requestedOrderOfFunctions)
164 {
165 foreach(Function current in this)
166 {
167 if ((current.Name == ordered.Name) &&
168 current.ReturnType == ordered.ReturnType)
169 {
170 tempList.Add(current);
171 this.Remove(current);
172 break;
173 }
174 }
175 }
176
177 foreach(Function current in this)
178 tempList.Add(current);
179
180 this.Clear();
181
182 this.AddRange(tempList);
183 }
184 }
185
186 class FunctionNameDictionary : Dictionary<string, object>
187 {
188 public void MarkAsMatched(string function)
189 {
190 if (this.ContainsKey(function))
191 this[function] = (object)1;
192 }
193
194 public void WriteUnmatched()
195 {
196 foreach (string function in this.Keys)
197 if (this[function] == null)
198 Console.WriteLine("Unmatched implemented function: {0}", function);
199 }
200 }
201
202
203
204 class GLApiTempParser
205 {
206 /// <summary>
207 /// Path to glapitemp.h file
208 /// </summary>
209 public FunctionNameDictionary Parse(string path)
210 {
211 StreamReader sr = File.OpenText(path);
212 FunctionNameDictionary functions = new FunctionNameDictionary();
213
214 string line = null;
215 int matchpos = -1;
216
217 while ((line = sr.ReadLine()) != null)
218 {
219 if ((matchpos = line.IndexOf("KEYWORD2 NAME(")) >= 0)
220 {
221 int closingbracketpos = line.IndexOf(")", matchpos);
222 string fname = "gl" + line.Substring(matchpos + 14, closingbracketpos - 14 - matchpos);
223
224 if (fname.IndexOf("_dispatch_stub") >= 0)
225 continue; /* Trash not needed */
226
227 if (!functions.ContainsKey(fname))
228 {
229 functions.Add(fname, null);
230 }
231 }
232 }
233
234 return functions;
235 }
236 }
237
238 class GLApiTableParser
239 {
240 /// <summary>
241 /// Path to glapioffsets.h file
242 /// </summary>
243 public FunctionNameDictionary Parse(string path)
244 {
245 StreamReader sr = File.OpenText(path);
246 FunctionNameDictionary functions = new FunctionNameDictionary();
247
248 string line = null;
249
250 while ((line = sr.ReadLine()) != null)
251 {
252 if (line.IndexOf("#define _gloffset_") >= 0)
253 {
254 string part = line.Substring(18, line.Length - 18);
255 string fname = "gl" + (part.Split(' ')[0].Trim());
256 if (!functions.ContainsKey(fname))
257 {
258 functions.Add(fname, null);
259 }
260 }
261 }
262
263 return functions;
264 }
265 }
266
267 class APIHeaderParser
268 {
269 public const string APIENTRY = "APIENTRY";
270 public const string GLAPI = "GLAPI";
271 public const string GLAPIENTRY = "GLAPIENTRY";
272 public const string EGLAPI = "EGLAPI";
273 public const string EGLAPIENTRY = "EGLAPIENTRY";
274 public const string VGAPI = "VG_API_CALL";
275 public const string VGAPIENTRY = "VG_API_ENTRY";
276 public const string VGUAPI = "VGU_API_CALL";
277 public const string VGUAPIENTRY = "VGU_API_ENTRY";
278
279 public string readandnormalize(StreamReader sr)
280 {
281 string s = sr.ReadLine();
282
283 if (s == null) return null;
284
285 s = s.Replace("\n","");
286 s = s.Replace("\t","");
287
288 return s;
289
290 }
291
292 public FunctionList Parse(string pathToHeader, string APIstring, string APIENTRYstring)
293 {
294 FunctionList functions = new FunctionList();
295
296 StreamReader sr = File.OpenText(pathToHeader);
297
298 string line = null;
299 int APIposition = -1;
300 int APIENTRYposition = -1;
301 int openbracketposition = -1;
302 int closebracketpositiong = -1;
303
304 while((line = readandnormalize(sr)) != null)
305 {
306 if (line == string.Empty)
307 continue;
308
309 if (line.IndexOf("#") >= 0)
310 continue;
311
312 /* check tokens */
313 APIposition = line.IndexOf(APIstring);
314
315 if (APIposition < 0)
316 continue;
317
318 /* Check APIENTRY first */
319 APIENTRYposition = line.IndexOf(APIENTRYstring, APIposition);
320
321 if (APIENTRYposition < 0)
322 continue;
323 if (line[APIENTRYposition - 1] != ' ') /* Space before APIENTRY is required */
324 continue;
325
326 openbracketposition = line.IndexOf("(", APIENTRYposition);
327
328 if (openbracketposition < 0)
329 continue;
330
331 closebracketpositiong = line.IndexOf(")", openbracketposition);
332
333 if (closebracketpositiong < 0)
334 {
335 /* read next lines for closing brackets */
336 string nextline = null;
337
338 while((nextline = readandnormalize(sr))!= null)
339 {
340 line += nextline;
341 closebracketpositiong = line.IndexOf(")", openbracketposition);
342 if (closebracketpositiong >= 0)
343 break;
344 }
345 }
346
347 /* create objects */
348 Function f = new Function();
349 f.ReturnType = line.Substring(APIposition + APIstring.Length, APIENTRYposition - APIposition - APIstring.Length).Trim();
350 f.Name = line.Substring(APIENTRYposition + APIENTRYstring.Length, openbracketposition - APIENTRYposition - APIENTRYstring.Length).Trim();
351
352 string argumentsstring = line.Substring(openbracketposition + 1, closebracketpositiong - 1 - openbracketposition);
353
354 string [] arguments = argumentsstring.Split(',');
355
356 char nextargumentname = 'a';
357
358 foreach (string argument in arguments)
359 {
360 /* change * and & so that they are no concatenated with variable name */
361 string innerargument = argument.Replace("*", " * ");
362 innerargument = innerargument.Replace("&", " & ");
363 innerargument = innerargument.Replace(" ", " ");
364 innerargument = innerargument.Replace(" [", "[");
365 innerargument = innerargument.Trim();
366
367 /* Possible situations:
368 * (A) innerargument = "void"
369 * (B) innerargument = "type variable"
370 * (C) innerargument = "type * variable"
371 * (D) innerargument = "type & variable"
372 * (E) innerargumetn = "type"
373 * (F) innerargument = "type *"
374 * (G) innerargument = "type &"
375 */
376
377 string [] argumentparts = innerargument.Split(' ');
378
379 /* Detection for A: only one argument with one argumentpart containing void*/
380 if ((argumentparts.Length == 1) && (arguments.Length == 1) && (argumentparts[0].IndexOf("void") >= 0))
381 continue;
382
383 int lastPositionOfTypeBackwards = 1; /* Means the last element of argumentparts is variable name */
384
385 /* Detection for E, F, G: argument without variable name */
386 if ((argumentparts[argumentparts.Length - 1] == "*") ||
387 (argumentparts[argumentparts.Length - 1] == "&") ||
388 (argumentparts.Length == 1)
389 )
390 {
391 lastPositionOfTypeBackwards = 0; /* Means the last element of argumentparts is type */
392 }
393
394 Argument arg = new Argument();
395 arg.Type = "";
396 for (int i = 0; i < argumentparts.Length - lastPositionOfTypeBackwards; i++)
397 arg.Type = arg.Type + argumentparts[i] + " ";
398 arg.Type = arg.Type.Trim();
399
400 if (lastPositionOfTypeBackwards == 1)
401 arg.Name = argumentparts[argumentparts.Length - 1].Trim();
402 else
403 {
404 /* Autoname for the variable */
405 arg.Name = string.Format("{0}", nextargumentname++);
406 }
407
408 f.Arguments.Add(arg);
409 }
410
411 functions.Add(f);
412
413
414 /*Console.Write("{0} {1} (", f.ReturnType, f.Name);
415 int j;
416 if (f.Arguments.Count > 0)
417 {
418 for (j = 0; j < f.Arguments.Count - 1; j++)
419 Console.Write("{0} {1} ({2}), ", f.Arguments[j].Type, f.Arguments[j].Name, f.Arguments[j].Register);
420 Console.Write("{0} {1} ({2})", f.Arguments[j].Type, f.Arguments[j].Name, f.Arguments[j].Register);
421 }
422 Console.WriteLine(");");*/
423 }
424
425 sr.Close();
426
427
428 return functions;
429 }
430 }
431
432 class ConfParser
433 {
434 public FunctionList Parse(string pathToFile)
435 {
436 FunctionList functions = new FunctionList();
437
438 /* This file might not yet exist */
439 if (!File.Exists(pathToFile))
440 return functions;
441
442 StreamReader sr = File.OpenText(pathToFile);
443
444 string line = null;
445 int spacePosition = -1;
446 int bracketPosition = -1;
447
448 while((line = sr.ReadLine()) != null)
449 {
450 if ((line.IndexOf(" gl") < 0) &&
451 (line.IndexOf(" egl") < 0) &&
452 (line.IndexOf(" vg") < 0))
453 continue;
454
455 bracketPosition = line.IndexOf("(", 0);
456 if (bracketPosition < 0)
457 continue;
458
459 spacePosition = line.LastIndexOf(" ", bracketPosition);
460 if (spacePosition < 0)
461 continue;
462
463 Function f = new Function();
464 f.ReturnType = line.Substring(0, spacePosition).Trim();
465 f.Name = line.Substring(spacePosition + 1, bracketPosition - spacePosition - 1).Trim();
466
467 functions.Add(f);
468 }
469
470 return functions;
471 }
472 }
473 abstract class ArosFileWriter
474 {
475 protected string getDefine(string path)
476 {
477 string define = Path.GetFileName(path);
478 define = define.Replace('.', '_');
479 define = define.ToUpper();
480 return define;
481 }
482
483 public abstract void Write(string path, FunctionList functions);
484 }
485
486 class StubsFileWriter : ArosFileWriter
487 {
488 private bool addRegSaveRest;
489 private string baseName;
490 private string functionPrefix;
491 private int firstFunctionLVO;
492
493 public StubsFileWriter(bool addRegSaveRest, string libraryName, int firstFunctionLVO)
494 {
495 this.addRegSaveRest = addRegSaveRest;
496 this.baseName = libraryName + "Base";
497 this.functionPrefix = libraryName.ToLower();
498 this.functionPrefix = char.ToUpper(this.functionPrefix[0]) + this.functionPrefix.Substring(1);
499 this.firstFunctionLVO = firstFunctionLVO;
500
501 }
502
503 public override void Write (string path, FunctionList functions)
504 {
505 StreamWriter swStubs = new StreamWriter(path, false);
506 int lvo = firstFunctionLVO;
507
508 foreach (Function f in functions)
509 {
510 swStubs.WriteLine("AROS_LH{0}({1}, {2},", f.Arguments.Count, f.ReturnType, f.Name);
511 foreach (Argument a in f.Arguments)
512 {
513 swStubs.WriteLine(" AROS_LHA({0}, {1}, {2}),", a.Type, a.Name, a.Register);
514 }
515 swStubs.WriteLine(" struct Library *, {0}, {1}, {2})", baseName, lvo++ ,functionPrefix);
516 swStubs.WriteLine("{");
517 swStubs.WriteLine(" AROS_LIBFUNC_INIT");
518 swStubs.WriteLine();
519 if (addRegSaveRest)
520 {
521 swStubs.WriteLine(" SAVE_REG");
522 swStubs.WriteLine();
523 swStubs.WriteLine(" PUT_MESABASE_IN_REG");
524 swStubs.WriteLine();
525 }
526 if (!f.ReturnsVoid())
527 {
528 swStubs.Write(" {0} _return = {1}(", f.ReturnType, f.Name);
529 }
530 else
531 {
532
533 swStubs.Write(" {0}(", f.Name);
534 }
535 if (f.Arguments.Count > 0)
536 {
537 int i = 0;
538 for (i = 0; i < f.Arguments.Count - 1; i++)
539 swStubs.Write("{0}, ", f.Arguments[i].Name);
540 swStubs.Write("{0}", f.Arguments[i].Name);
541 }
542 swStubs.WriteLine(");");
543 swStubs.WriteLine();
544 if (addRegSaveRest)
545 {
546 swStubs.WriteLine(" RESTORE_REG");
547 swStubs.WriteLine();
548 }
549 if (!f.ReturnsVoid())
550 {
551 swStubs.WriteLine(" return _return;");
552 swStubs.WriteLine();
553 }
554 swStubs.WriteLine(" AROS_LIBFUNC_EXIT");
555 swStubs.WriteLine("}");
556 swStubs.WriteLine();
557 }
558
559 swStubs.Close();
560
561 }
562 }
563
564 enum CallType
565 {
566 RegCall,
567 StackCall
568 }
569
570 class ConfFileWriter : ArosFileWriter
571 {
572 private CallType calltype;
573
574 public ConfFileWriter(CallType calltype)
575 {
576 this.calltype = calltype;
577 }
578
579 public override void Write (string path, FunctionList functions)
580 {
581 StreamWriter swConf = new StreamWriter(path, false);
582
583 foreach (Function f in functions)
584 {
585 swConf.Write("{0} {1}(", f.ReturnType, f.Name);
586 if (f.Arguments.Count > 0)
587 {
588 int i = 0;
589 for (i = 0; i < f.Arguments.Count - 1; i++)
590 swConf.Write("{0} {1}, ", f.Arguments[i].Type, f.Arguments[i].Name);
591 swConf.Write("{0} {1}", f.Arguments[i].Type, f.Arguments[i].Name);
592 }
593
594 if (calltype == CallType.RegCall)
595 {
596 /* Extend with register specification */
597 swConf.Write(") (");
598
599 if (f.Arguments.Count > 0)
600 {
601 int i = 0;
602 for (i = 0; i < f.Arguments.Count - 1; i++)
603 swConf.Write("{0}, ", f.Arguments[i].Register);
604 swConf.Write("{0}", f.Arguments[i].Register);
605 }
606 }
607
608 swConf.WriteLine(")");
609
610 }
611
612 swConf.Close();
613 }
614
615 }
616
617 class UndefFileWriter : ArosFileWriter
618 {
619 public override void Write (string path, FunctionList functions)
620 {
621 StreamWriter swUndef = new StreamWriter(path, false);
622
623 foreach (Function f in functions)
624 {
625 swUndef.WriteLine("#undef {0}", f.Name);
626 }
627
628 swUndef.Close();
629 }
630 }
631
632 class MangleFileWriter : ArosFileWriter
633 {
634 public override void Write (string path, FunctionList functions)
635 {
636 StreamWriter swMangle = new StreamWriter(path, false);
637
638 string define = getDefine(path);
639
640 swMangle.WriteLine("#ifndef {0}", define);
641 swMangle.WriteLine("#define {0}", define);
642
643 foreach (Function f in functions)
644 {
645 swMangle.WriteLine("#define {0} m{0}", f.Name);
646 }
647
648 swMangle.WriteLine("#endif");
649
650 swMangle.Close();
651 }
652 }
653
654 class MangledHeaderFileWriter : ArosFileWriter
655 {
656 public override void Write (string path, FunctionList functions)
657 {
658 StreamWriter swMangledHeader = new StreamWriter(path, false);
659
660 string define = getDefine(path);
661
662 swMangledHeader.WriteLine("#ifndef {0}", define);
663 swMangledHeader.WriteLine("#define {0}", define);
664
665 foreach (Function f in functions)
666 {
667 swMangledHeader.Write("{0} m{1} (", f.ReturnType, f.Name);
668 if (f.Arguments.Count > 0)
669 {
670 int i = 0;
671 for (i = 0; i < f.Arguments.Count - 1; i++)
672 swMangledHeader.Write("{0} {1}, ", f.Arguments[i].Type, f.Arguments[i].Name);
673 swMangledHeader.Write("{0} {1}", f.Arguments[i].Type, f.Arguments[i].Name);
674 }
675 swMangledHeader.WriteLine(");");
676 }
677
678 swMangledHeader.WriteLine("#endif");
679
680 swMangledHeader.Close();
681 }
682 }
683
684 class MangledImplementationFileWriter : ArosFileWriter
685 {
686 public override void Write (string path, FunctionList functions)
687 {
688 StreamWriter swMangledImplementation = new StreamWriter(path, false);
689
690 foreach (Function f in functions)
691 {
692 swMangledImplementation.Write("{0} m{1} (", f.ReturnType, f.Name);
693 if (f.Arguments.Count > 0)
694 {
695 int i = 0;
696 for (i = 0; i < f.Arguments.Count - 1; i++)
697 swMangledImplementation.Write("{0} {1}, ", f.Arguments[i].Type, f.Arguments[i].Name);
698 swMangledImplementation.Write("{0} {1}", f.Arguments[i].Type, f.Arguments[i].Name);
699 }
700 swMangledImplementation.WriteLine(")");
701 swMangledImplementation.WriteLine("{");
702 if (!f.ReturnsVoid())
703 swMangledImplementation.WriteLine(" {0} _ret;", f.ReturnType);
704
705 if (f.Name.Equals("glEnd"))
706 swMangledImplementation.WriteLine(" /* glBegin/glEnd must be atomic */");
707 else
708 swMangledImplementation.WriteLine(" HOSTGL_PRE");
709 swMangledImplementation.WriteLine(" D(bug(\"[HostGL] TASK: 0x%x, {0}\", FindTask(NULL)));", f.Name);
710
711 if (f.ReturnsVoid())
712 swMangledImplementation.Write(" GLCALL({0}", f.Name);
713 else
714 swMangledImplementation.Write(" _ret = GLCALL({0}", f.Name);
715 if (f.Arguments.Count > 0)
716 {
717 int i = 0;
718 for (i = 0; i < f.Arguments.Count; i++)
719 swMangledImplementation.Write(", {0}", f.Arguments[i].Name);
720 }
721 swMangledImplementation.WriteLine(");");
722
723 swMangledImplementation.WriteLine(" D(bug(\"...exit\\n\"));");
724 if (f.Name.Equals("glBegin"))
725 swMangledImplementation.WriteLine(" /* glBegin/glEnd must be atomic */");
726 else
727 swMangledImplementation.WriteLine(" HOSTGL_POST");
728
729 if (!f.ReturnsVoid())
730 swMangledImplementation.WriteLine(" return _ret;");
731 swMangledImplementation.WriteLine("}");
732 swMangledImplementation.WriteLine();
733 }
734
735 swMangledImplementation.Close();
736 }
737 }
738
739 class GLFUNCFileWriter : ArosFileWriter
740 {
741 public override void Write (string path, FunctionList functions)
742 {
743 StreamWriter swGLFUNC = new StreamWriter(path, false);
744
745 swGLFUNC.WriteLine("struct gl_func {");
746
747 foreach (Function f in functions)
748 {
749 swGLFUNC.Write(" {0} (*{1}) (", f.ReturnType, f.Name);
750 if (f.Arguments.Count > 0)
751 {
752 int i = 0;
753 for (i = 0; i < f.Arguments.Count - 1; i++)
754 swGLFUNC.Write("{0} {1}, ", f.Arguments[i].Type, f.Arguments[i].Name);
755 swGLFUNC.Write("{0} {1}", f.Arguments[i].Type, f.Arguments[i].Name);
756 }
757 swGLFUNC.WriteLine(");");
758 }
759
760 swGLFUNC.WriteLine("};");
761
762 swGLFUNC.WriteLine();swGLFUNC.WriteLine();swGLFUNC.WriteLine();swGLFUNC.WriteLine();
763
764 swGLFUNC.WriteLine("static const char *gl_func_names[] = {");
765 foreach (Function f in functions)
766 {
767 swGLFUNC.WriteLine(" \"{0}\",", f.Name);
768 }
769 swGLFUNC.WriteLine(" NULL");
770 swGLFUNC.WriteLine("};");
771
772 swGLFUNC.Close();
773 }
774 }
775
776 class MainClass
777 {
778 public static void Main(string[] args)
779 {
780 string PATH_TO_MESA = @"/ssd/deadwood/repo-gitorious-aros/AROS/AROS/workbench/libs/mesa/";
781 string OUTPUT_PATH = @"/ssd/deadwood/temp/";
782 CallType eglCallType = CallType.StackCall;
783 CallType vgCallType = CallType.StackCall;
784 CallType gluCallType = CallType.StackCall;
785 CallType glCallType = CallType.StackCall;
786
787
788 GLApiTempParser apiParser = new GLApiTempParser();
789 FunctionNameDictionary implementedFunctions =
790 apiParser.Parse(PATH_TO_MESA + @"/src/mapi/glapi/glapitemp.h");
791
792
793 Console.WriteLine("Implemented functions: {0}", implementedFunctions.Keys.Count);
794
795 /* Parsing part */
796 APIHeaderParser p = new APIHeaderParser();
797
798 FunctionList functionsglh = p.Parse(PATH_TO_MESA + @"/include/GL/gl.h", APIHeaderParser.GLAPI, APIHeaderParser.GLAPIENTRY);
799 FunctionList functionsglhquirk = p.Parse(PATH_TO_MESA + @"/include/GL/gl.h", APIHeaderParser.GLAPI, APIHeaderParser.APIENTRY);
800 functionsglh.AddRange(functionsglhquirk);
801
802 FunctionList functionsglexth = p.Parse(PATH_TO_MESA + @"/include/GL/glext.h", APIHeaderParser.GLAPI, APIHeaderParser.APIENTRY);
803
804
805 ConfParser confParser = new ConfParser();
806 FunctionList orderedExistingFunctions = confParser.Parse(PATH_TO_MESA + @"/src/aros/arosmesa/gl.conf");
807
808 Console.WriteLine("Initial parse results: GL: {0} GLEXT: {1}", functionsglh.Count, functionsglexth.Count);
809
810 functionsglexth.RemoveFunctionsExceptFor(implementedFunctions);
811 functionsglh.RemoveFunctionsExceptFor(implementedFunctions);
812 functionsglexth.RemoveFunctions(functionsglh);
813
814 implementedFunctions.WriteUnmatched();
815
816 Console.WriteLine("After filtering of unimplemented functions: GL: {0} GLEXT: {1}", functionsglh.Count, functionsglexth.Count);
817
818 /* Generation part */
819
820 /* GL */
821 FunctionList functionsGL = new FunctionList();
822
823 Console.WriteLine("After duplicates removal GL: {0}, GLEXT: {1}", functionsglh.Count, functionsglexth.Count);
824 functionsGL.AddRange(functionsglh);
825
826 functionsGL.RemoveFunctionByName("glBlendEquationSeparateATI"); /* Extension found in gl.h instead of glext.h */
827 functionsGL.RemoveFunctionByName("glFramebufferTextureLayerEXT"); /* Extension found in gl.h instead of glext.h */
828 functionsGL.RemoveFunctionByName("glEGLImageTargetTexture2DOES"); /* Extension found in gl.h instead of glext.h */
829 functionsGL.RemoveFunctionByName("glEGLImageTargetRenderbufferStorageOES"); /* Extension found in gl.h instead of glext.h */
830
831 Console.WriteLine("After merging GL {0}", functionsGL.Count);
832
833
834 FunctionList functionsfinal = new FunctionList();
835 functionsfinal.AddRange(functionsGL);
836
837 functionsfinal.CorrectionForArrayArguments();
838 functionsfinal.ReorderToMatch(orderedExistingFunctions);
839
840 if (glCallType == CallType.RegCall)
841 {
842 functionsfinal.CalculateRegisters();
843
844 StubsFileWriter sfw = new StubsFileWriter(false, "Mesa", 35);
845 sfw.Write(OUTPUT_PATH + @"arosmesa_library_api.c", functionsfinal);
846 }
847
848 ConfFileWriter cfw = new ConfFileWriter(glCallType);
849 cfw.Write(OUTPUT_PATH + @"gl.conf", functionsfinal);
850
851 /*MangledImplementationFileWriter glmifw = new MangledImplementationFileWriter();
852 glmifw.Write(OUTPUT_PATH + @"hostgl_gl_api.c", functionsfinal);
853
854 GLFUNCFileWriter glfuncfw = new GLFUNCFileWriter();
855 glfuncfw.Write(OUTPUT_PATH + @"gl_func.ch", functionsfinal);*/
856
857 /* EGL */
858 FunctionList functionseglh = p.Parse(PATH_TO_MESA + @"/include/EGL/egl.h", APIHeaderParser.EGLAPI, APIHeaderParser.EGLAPIENTRY);
859 FunctionList orderedExistingFunctionsEGL = confParser.Parse(PATH_TO_MESA + @"/src/aros/egl/egl.conf");
860
861 FunctionList functionsEGL = new FunctionList();
862
863 functionsEGL.AddRange(functionseglh);
864
865 Console.WriteLine("After merging EGL {0}", functionsEGL.Count);
866
867 functionsfinal.Clear();
868 functionsfinal.AddRange(functionsEGL);
869
870 functionsfinal.CorrectionForArrayArguments();
871
872 functionsfinal.ReorderToMatch(orderedExistingFunctionsEGL);
873
874 if (eglCallType == CallType.RegCall)
875 {
876 functionsfinal.CalculateRegisters();
877
878 StubsFileWriter eglsfw = new StubsFileWriter(false, "EGL", 35);
879 eglsfw.Write(OUTPUT_PATH + @"egl_library_api.c", functionsfinal);
880 }
881
882 ConfFileWriter eglcfw = new ConfFileWriter(eglCallType);
883 eglcfw.Write(OUTPUT_PATH + @"egl.conf", functionsfinal);
884
885
886 /* VG */
887 FunctionList functionsopenvgh = p.Parse(PATH_TO_MESA + @"/include/VG/openvg.h", APIHeaderParser.VGAPI, APIHeaderParser.VGAPIENTRY);
888 FunctionList functionsvguh = p.Parse(PATH_TO_MESA + @"/include/VG/vgu.h", APIHeaderParser.VGUAPI, APIHeaderParser.VGUAPIENTRY);
889
890 FunctionList orderedExistingFunctionsVG = confParser.Parse(PATH_TO_MESA + @"/src/aros/vega/vega.conf");
891
892 FunctionList functionsVG = new FunctionList();
893 functionsVG.AddRange(functionsopenvgh);
894 functionsVG.AddRange(functionsvguh);
895
896 Console.WriteLine("After merging VG {0}", functionsVG.Count);
897
898 functionsfinal.Clear();
899 functionsfinal.AddRange(functionsVG);
900
901 functionsfinal.CorrectionForArrayArguments();
902 functionsfinal.ReorderToMatch(orderedExistingFunctionsVG);
903
904 if (vgCallType == CallType.RegCall)
905 {
906 functionsVG.RemoveFunctionByName("vguComputeWarpQuadToQuad"); /* Too many parameters */
907 functionsfinal.CalculateRegisters();
908
909 StubsFileWriter vgsfw = new StubsFileWriter(false, "Vega", 35);
910 vgsfw.Write(OUTPUT_PATH + @"vega_library_api.c", functionsfinal);
911 }
912
913 ConfFileWriter vgcfw = new ConfFileWriter(vgCallType);
914 vgcfw.Write(OUTPUT_PATH + @"vega.conf", functionsfinal);
915
916
917 /* GLU */
918 FunctionList functionsgluh = p.Parse(PATH_TO_MESA + @"/include/GL/glu.h", APIHeaderParser.GLAPI, APIHeaderParser.GLAPIENTRY);
919
920 FunctionList orderedExistingFunctionsGLU = confParser.Parse(PATH_TO_MESA + @"/src/aros/glu/glu.conf");
921
922 FunctionList functionsGLU = new FunctionList();
923 functionsGLU.AddRange(functionsgluh);
924
925 Console.WriteLine("After merging GLU {0}", functionsGLU.Count);
926
927 functionsfinal.Clear();
928 functionsfinal.AddRange(functionsGLU);
929
930 functionsfinal.CorrectionForArrayArguments();
931 functionsfinal.ReorderToMatch(orderedExistingFunctionsGLU);
932
933 if (gluCallType == CallType.RegCall)
934 {
935 functionsGLU.RemoveFunctionByName("gluUnProject4"); /* Too many parameters */
936 functionsfinal.CalculateRegisters();
937
938 StubsFileWriter glusfw = new StubsFileWriter(false, "GLU", 35);
939 glusfw.Write(OUTPUT_PATH + @"glu_library_api.c", functionsfinal);
940 }
941
942 ConfFileWriter glucfw = new ConfFileWriter(gluCallType);
943 glucfw.Write(OUTPUT_PATH + @"glu.conf", functionsfinal);
944
945 }
946 }
947 }
Mirror of AROS' svn.