public void ReorderToMatch(FunctionList requestedOrderOfFunctions) { /* Rather not effective implementation * For each item on ordered list, find it in this list, put to temp list, remove from this list * when finished, copy remaining items on this list to temp list * copy temp list to this list */ FunctionList tempList = new FunctionList(); foreach (Function ordered in requestedOrderOfFunctions) { foreach (Function current in this) { if ((current.Name == ordered.Name) && current.ReturnType == ordered.ReturnType) { tempList.Add(current); this.Remove(current); break; } } } foreach (Function current in this) { tempList.Add(current); } this.Clear(); this.AddRange(tempList); }
/// <summary> /// Removes entries from this list which have the same name as an entry in other list /// </summary> /// <param name="other"> /// A <see cref="FunctionList"/> /// </param> public void RemoveFunctions(FunctionList other) { /* Copy this list to hashtable */ Dictionary <string, Function> temp = new Dictionary <string, Function>(); FunctionList toBeRemoved = new FunctionList(); foreach (Function f in this) { temp.Add(f.Name, f); } /* Find duplicates */ foreach (Function f in other) { if (temp.ContainsKey(f.Name)) { Function thisf = temp[f.Name]; if (thisf.Arguments.Count != f.Arguments.Count) { throw new ApplicationException(string.Format("Same name, different arguments count: {0} {1} {2}", f.Name, f.Arguments.Count, thisf.Arguments.Count)); } toBeRemoved.Add(thisf); } } foreach (Function f in toBeRemoved) { this.Remove(f); } }
public override void Write(string path, FunctionList functions) { StreamWriter swGLFUNC = new StreamWriter(path, false); swGLFUNC.WriteLine("struct gl_func {"); foreach (Function f in functions) { swGLFUNC.Write(" {0} (*{1}) (", f.ReturnType, f.Name); if (f.Arguments.Count > 0) { int i = 0; for (i = 0; i < f.Arguments.Count - 1; i++) { swGLFUNC.Write("{0} {1}, ", f.Arguments[i].Type, f.Arguments[i].Name); } swGLFUNC.Write("{0} {1}", f.Arguments[i].Type, f.Arguments[i].Name); } swGLFUNC.WriteLine(");"); } swGLFUNC.WriteLine("};"); swGLFUNC.WriteLine(); swGLFUNC.WriteLine(); swGLFUNC.WriteLine(); swGLFUNC.WriteLine(); swGLFUNC.WriteLine("static const char *gl_func_names[] = {"); foreach (Function f in functions) { swGLFUNC.WriteLine(" \"{0}\",", f.Name); } swGLFUNC.WriteLine(" NULL"); swGLFUNC.WriteLine("};"); swGLFUNC.Close(); }
public override void Write(string path, FunctionList functions) { StreamWriter swMangledHeader = new StreamWriter(path, false); string define = getDefine(path); swMangledHeader.WriteLine("#ifndef {0}", define); swMangledHeader.WriteLine("#define {0}", define); foreach (Function f in functions) { swMangledHeader.Write("{0} m{1} (", f.ReturnType, f.Name); if (f.Arguments.Count > 0) { int i = 0; for (i = 0; i < f.Arguments.Count - 1; i++) { swMangledHeader.Write("{0} {1}, ", f.Arguments[i].Type, f.Arguments[i].Name); } swMangledHeader.Write("{0} {1}", f.Arguments[i].Type, f.Arguments[i].Name); } swMangledHeader.WriteLine(");"); } swMangledHeader.WriteLine("#endif"); swMangledHeader.Close(); }
public override void Write(string path, FunctionList functions) { StreamWriter swStubs = new StreamWriter(path, false); int lvo = firstFunctionLVO; foreach (Function f in functions) { swStubs.WriteLine("AROS_LH{0}({1}, {2},", f.Arguments.Count, f.ReturnType, f.Name); foreach (Argument a in f.Arguments) { swStubs.WriteLine(" AROS_LHA({0}, {1}, {2}),", a.Type, a.Name, a.Register); } swStubs.WriteLine(" struct Library *, {0}, {1}, {2})", baseName, lvo++, functionPrefix); swStubs.WriteLine("{"); swStubs.WriteLine(" AROS_LIBFUNC_INIT"); swStubs.WriteLine(); if (addRegSaveRest) { swStubs.WriteLine(" SAVE_REG"); swStubs.WriteLine(); swStubs.WriteLine(" PUT_MESABASE_IN_REG"); swStubs.WriteLine(); } if (!f.ReturnsVoid()) { swStubs.Write(" {0} _return = {1}(", f.ReturnType, f.Name); } else { swStubs.Write(" {0}(", f.Name); } if (f.Arguments.Count > 0) { int i = 0; for (i = 0; i < f.Arguments.Count - 1; i++) { swStubs.Write("{0}, ", f.Arguments[i].Name); } swStubs.Write("{0}", f.Arguments[i].Name); } swStubs.WriteLine(");"); swStubs.WriteLine(); if (addRegSaveRest) { swStubs.WriteLine(" RESTORE_REG"); swStubs.WriteLine(); } if (!f.ReturnsVoid()) { swStubs.WriteLine(" return _return;"); swStubs.WriteLine(); } swStubs.WriteLine(" AROS_LIBFUNC_EXIT"); swStubs.WriteLine("}"); swStubs.WriteLine(); } swStubs.Close(); }
public override void Write(string path, FunctionList functions) { StreamWriter swUndef = new StreamWriter(path, false); foreach (Function f in functions) { swUndef.WriteLine("#undef {0}", f.Name); } swUndef.Close(); }
public FunctionList Parse(string pathToFile) { FunctionList functions = new FunctionList(); /* This file might not yet exist */ if (!File.Exists(pathToFile)) { return(functions); } StreamReader sr = File.OpenText(pathToFile); string line = null; int spacePosition = -1; int bracketPosition = -1; while ((line = sr.ReadLine()) != null) { if ((line.IndexOf(" gl") < 0) && (line.IndexOf(" egl") < 0) && (line.IndexOf(" vg") < 0)) { continue; } bracketPosition = line.IndexOf("(", 0); if (bracketPosition < 0) { continue; } spacePosition = line.LastIndexOf(" ", bracketPosition); if (spacePosition < 0) { continue; } Function f = new Function(); f.ReturnType = line.Substring(0, spacePosition).Trim(); f.Name = line.Substring(spacePosition + 1, bracketPosition - spacePosition - 1).Trim(); functions.Add(f); } return(functions); }
public void RemoveFunctionByName(string functionName) { FunctionList toBeRemoved = new FunctionList(); foreach (Function f in this) { if (f.Name == functionName) { toBeRemoved.Add(f); } } foreach (Function f in toBeRemoved) { this.Remove(f); } }
public override void Write(string path, FunctionList functions) { StreamWriter swMangle = new StreamWriter(path, false); string define = getDefine(path); swMangle.WriteLine("#ifndef {0}", define); swMangle.WriteLine("#define {0}", define); foreach (Function f in functions) { swMangle.WriteLine("#define {0} m{0}", f.Name); } swMangle.WriteLine("#endif"); swMangle.Close(); }
public void RemoveFunctionsExceptFor(FunctionNameDictionary functions) { FunctionList toBeRemoved = new FunctionList(); foreach (Function f in this) { if (!functions.ContainsKey(f.Name)) { toBeRemoved.Add(f); } else { functions.MarkAsMatched(f.Name); } } foreach (Function f in toBeRemoved) { this.Remove(f); } }
public override void Write(string path, FunctionList functions) { StreamWriter swConf = new StreamWriter(path, false); foreach (Function f in functions) { swConf.Write("{0} {1}(", f.ReturnType, f.Name); if (f.Arguments.Count > 0) { int i = 0; for (i = 0; i < f.Arguments.Count - 1; i++) { swConf.Write("{0} {1}, ", f.Arguments[i].Type, f.Arguments[i].Name); } swConf.Write("{0} {1}", f.Arguments[i].Type, f.Arguments[i].Name); } if (calltype == CallType.RegCall) { /* Extend with register specification */ swConf.Write(") ("); if (f.Arguments.Count > 0) { int i = 0; for (i = 0; i < f.Arguments.Count - 1; i++) { swConf.Write("{0}, ", f.Arguments[i].Register); } swConf.Write("{0}", f.Arguments[i].Register); } } swConf.WriteLine(")"); } swConf.Close(); }
public static void Main(string[] args) { string PATH_TO_MESA = @"/ssd/deadwood/repo-gitorious-aros/AROS/AROS/workbench/libs/mesa/"; string OUTPUT_PATH = @"/ssd/deadwood/temp/"; CallType eglCallType = CallType.StackCall; CallType vgCallType = CallType.StackCall; CallType gluCallType = CallType.StackCall; CallType glCallType = CallType.StackCall; GLApiTempParser apiParser = new GLApiTempParser(); FunctionNameDictionary implementedFunctions = apiParser.Parse(PATH_TO_MESA + @"/src/mapi/glapi/glapitemp.h"); Console.WriteLine("Implemented functions: {0}", implementedFunctions.Keys.Count); /* Parsing part */ APIHeaderParser p = new APIHeaderParser(); FunctionList functionsglh = p.Parse(PATH_TO_MESA + @"/include/GL/gl.h", APIHeaderParser.GLAPI, APIHeaderParser.GLAPIENTRY); FunctionList functionsglhquirk = p.Parse(PATH_TO_MESA + @"/include/GL/gl.h", APIHeaderParser.GLAPI, APIHeaderParser.APIENTRY); functionsglh.AddRange(functionsglhquirk); FunctionList functionsglexth = p.Parse(PATH_TO_MESA + @"/include/GL/glext.h", APIHeaderParser.GLAPI, APIHeaderParser.APIENTRY); ConfParser confParser = new ConfParser(); FunctionList orderedExistingFunctions = confParser.Parse(PATH_TO_MESA + @"/src/aros/arosmesa/gl.conf"); Console.WriteLine("Initial parse results: GL: {0} GLEXT: {1}", functionsglh.Count, functionsglexth.Count); functionsglexth.RemoveFunctionsExceptFor(implementedFunctions); functionsglh.RemoveFunctionsExceptFor(implementedFunctions); functionsglexth.RemoveFunctions(functionsglh); implementedFunctions.WriteUnmatched(); Console.WriteLine("After filtering of unimplemented functions: GL: {0} GLEXT: {1}", functionsglh.Count, functionsglexth.Count); /* Generation part */ /* GL */ FunctionList functionsGL = new FunctionList(); Console.WriteLine("After duplicates removal GL: {0}, GLEXT: {1}", functionsglh.Count, functionsglexth.Count); functionsGL.AddRange(functionsglh); functionsGL.RemoveFunctionByName("glBlendEquationSeparateATI"); /* Extension found in gl.h instead of glext.h */ functionsGL.RemoveFunctionByName("glFramebufferTextureLayerEXT"); /* Extension found in gl.h instead of glext.h */ functionsGL.RemoveFunctionByName("glEGLImageTargetTexture2DOES"); /* Extension found in gl.h instead of glext.h */ functionsGL.RemoveFunctionByName("glEGLImageTargetRenderbufferStorageOES"); /* Extension found in gl.h instead of glext.h */ Console.WriteLine("After merging GL {0}", functionsGL.Count); FunctionList functionsfinal = new FunctionList(); functionsfinal.AddRange(functionsGL); functionsfinal.CorrectionForArrayArguments(); functionsfinal.ReorderToMatch(orderedExistingFunctions); if (glCallType == CallType.RegCall) { functionsfinal.CalculateRegisters(); StubsFileWriter sfw = new StubsFileWriter(false, "Mesa", 35); sfw.Write(OUTPUT_PATH + @"arosmesa_library_api.c", functionsfinal); } ConfFileWriter cfw = new ConfFileWriter(glCallType); cfw.Write(OUTPUT_PATH + @"gl.conf", functionsfinal); /*MangledImplementationFileWriter glmifw = new MangledImplementationFileWriter(); * glmifw.Write(OUTPUT_PATH + @"hostgl_gl_api.c", functionsfinal); * * GLFUNCFileWriter glfuncfw = new GLFUNCFileWriter(); * glfuncfw.Write(OUTPUT_PATH + @"gl_func.ch", functionsfinal);*/ /* EGL */ FunctionList functionseglh = p.Parse(PATH_TO_MESA + @"/include/EGL/egl.h", APIHeaderParser.EGLAPI, APIHeaderParser.EGLAPIENTRY); FunctionList orderedExistingFunctionsEGL = confParser.Parse(PATH_TO_MESA + @"/src/aros/egl/egl.conf"); FunctionList functionsEGL = new FunctionList(); functionsEGL.AddRange(functionseglh); Console.WriteLine("After merging EGL {0}", functionsEGL.Count); functionsfinal.Clear(); functionsfinal.AddRange(functionsEGL); functionsfinal.CorrectionForArrayArguments(); functionsfinal.ReorderToMatch(orderedExistingFunctionsEGL); if (eglCallType == CallType.RegCall) { functionsfinal.CalculateRegisters(); StubsFileWriter eglsfw = new StubsFileWriter(false, "EGL", 35); eglsfw.Write(OUTPUT_PATH + @"egl_library_api.c", functionsfinal); } ConfFileWriter eglcfw = new ConfFileWriter(eglCallType); eglcfw.Write(OUTPUT_PATH + @"egl.conf", functionsfinal); /* VG */ FunctionList functionsopenvgh = p.Parse(PATH_TO_MESA + @"/include/VG/openvg.h", APIHeaderParser.VGAPI, APIHeaderParser.VGAPIENTRY); FunctionList functionsvguh = p.Parse(PATH_TO_MESA + @"/include/VG/vgu.h", APIHeaderParser.VGUAPI, APIHeaderParser.VGUAPIENTRY); FunctionList orderedExistingFunctionsVG = confParser.Parse(PATH_TO_MESA + @"/src/aros/vega/vega.conf"); FunctionList functionsVG = new FunctionList(); functionsVG.AddRange(functionsopenvgh); functionsVG.AddRange(functionsvguh); Console.WriteLine("After merging VG {0}", functionsVG.Count); functionsfinal.Clear(); functionsfinal.AddRange(functionsVG); functionsfinal.CorrectionForArrayArguments(); functionsfinal.ReorderToMatch(orderedExistingFunctionsVG); if (vgCallType == CallType.RegCall) { functionsVG.RemoveFunctionByName("vguComputeWarpQuadToQuad"); /* Too many parameters */ functionsfinal.CalculateRegisters(); StubsFileWriter vgsfw = new StubsFileWriter(false, "Vega", 35); vgsfw.Write(OUTPUT_PATH + @"vega_library_api.c", functionsfinal); } ConfFileWriter vgcfw = new ConfFileWriter(vgCallType); vgcfw.Write(OUTPUT_PATH + @"vega.conf", functionsfinal); /* GLU */ FunctionList functionsgluh = p.Parse(PATH_TO_MESA + @"/include/GL/glu.h", APIHeaderParser.GLAPI, APIHeaderParser.GLAPIENTRY); FunctionList orderedExistingFunctionsGLU = confParser.Parse(PATH_TO_MESA + @"/src/aros/glu/glu.conf"); FunctionList functionsGLU = new FunctionList(); functionsGLU.AddRange(functionsgluh); Console.WriteLine("After merging GLU {0}", functionsGLU.Count); functionsfinal.Clear(); functionsfinal.AddRange(functionsGLU); functionsfinal.CorrectionForArrayArguments(); functionsfinal.ReorderToMatch(orderedExistingFunctionsGLU); if (gluCallType == CallType.RegCall) { functionsGLU.RemoveFunctionByName("gluUnProject4"); /* Too many parameters */ functionsfinal.CalculateRegisters(); StubsFileWriter glusfw = new StubsFileWriter(false, "GLU", 35); glusfw.Write(OUTPUT_PATH + @"glu_library_api.c", functionsfinal); } ConfFileWriter glucfw = new ConfFileWriter(gluCallType); glucfw.Write(OUTPUT_PATH + @"glu.conf", functionsfinal); }
public override void Write(string path, FunctionList functions) { StreamWriter swMangledImplementation = new StreamWriter(path, false); foreach (Function f in functions) { swMangledImplementation.Write("{0} m{1} (", f.ReturnType, f.Name); if (f.Arguments.Count > 0) { int i = 0; for (i = 0; i < f.Arguments.Count - 1; i++) { swMangledImplementation.Write("{0} {1}, ", f.Arguments[i].Type, f.Arguments[i].Name); } swMangledImplementation.Write("{0} {1}", f.Arguments[i].Type, f.Arguments[i].Name); } swMangledImplementation.WriteLine(")"); swMangledImplementation.WriteLine("{"); if (!f.ReturnsVoid()) { swMangledImplementation.WriteLine(" {0} _ret;", f.ReturnType); } if (f.Name.Equals("glEnd")) { swMangledImplementation.WriteLine(" /* glBegin/glEnd must be atomic */"); } else { swMangledImplementation.WriteLine(" HOSTGL_PRE"); } swMangledImplementation.WriteLine(" D(bug(\"[HostGL] TASK: 0x%x, {0}\", FindTask(NULL)));", f.Name); if (f.ReturnsVoid()) { swMangledImplementation.Write(" GLCALL({0}", f.Name); } else { swMangledImplementation.Write(" _ret = GLCALL({0}", f.Name); } if (f.Arguments.Count > 0) { int i = 0; for (i = 0; i < f.Arguments.Count; i++) { swMangledImplementation.Write(", {0}", f.Arguments[i].Name); } } swMangledImplementation.WriteLine(");"); swMangledImplementation.WriteLine(" D(bug(\"...exit\\n\"));"); if (f.Name.Equals("glBegin")) { swMangledImplementation.WriteLine(" /* glBegin/glEnd must be atomic */"); } else { swMangledImplementation.WriteLine(" HOSTGL_POST"); } if (!f.ReturnsVoid()) { swMangledImplementation.WriteLine(" return _ret;"); } swMangledImplementation.WriteLine("}"); swMangledImplementation.WriteLine(); } swMangledImplementation.Close(); }
public abstract void Write(string path, FunctionList functions);
public FunctionList Parse(string pathToHeader, string APIstring, string APIENTRYstring) { FunctionList functions = new FunctionList(); StreamReader sr = File.OpenText(pathToHeader); string line = null; int APIposition = -1; int APIENTRYposition = -1; int openbracketposition = -1; int closebracketpositiong = -1; while ((line = readandnormalize(sr)) != null) { if (line == string.Empty) { continue; } if (line.IndexOf("#") >= 0) { continue; } /* check tokens */ APIposition = line.IndexOf(APIstring); if (APIposition < 0) { continue; } /* Check APIENTRY first */ APIENTRYposition = line.IndexOf(APIENTRYstring, APIposition); if (APIENTRYposition < 0) { continue; } if (line[APIENTRYposition - 1] != ' ') /* Space before APIENTRY is required */ { continue; } openbracketposition = line.IndexOf("(", APIENTRYposition); if (openbracketposition < 0) { continue; } closebracketpositiong = line.IndexOf(")", openbracketposition); if (closebracketpositiong < 0) { /* read next lines for closing brackets */ string nextline = null; while ((nextline = readandnormalize(sr)) != null) { line += nextline; closebracketpositiong = line.IndexOf(")", openbracketposition); if (closebracketpositiong >= 0) { break; } } } /* create objects */ Function f = new Function(); f.ReturnType = line.Substring(APIposition + APIstring.Length, APIENTRYposition - APIposition - APIstring.Length).Trim(); f.Name = line.Substring(APIENTRYposition + APIENTRYstring.Length, openbracketposition - APIENTRYposition - APIENTRYstring.Length).Trim(); string argumentsstring = line.Substring(openbracketposition + 1, closebracketpositiong - 1 - openbracketposition); string [] arguments = argumentsstring.Split(','); char nextargumentname = 'a'; foreach (string argument in arguments) { /* change * and & so that they are no concatenated with variable name */ string innerargument = argument.Replace("*", " * "); innerargument = innerargument.Replace("&", " & "); innerargument = innerargument.Replace(" ", " "); innerargument = innerargument.Replace(" [", "["); innerargument = innerargument.Trim(); /* Possible situations: * (A) innerargument = "void" * (B) innerargument = "type variable" * (C) innerargument = "type * variable" * (D) innerargument = "type & variable" * (E) innerargumetn = "type" * (F) innerargument = "type *" * (G) innerargument = "type &" */ string [] argumentparts = innerargument.Split(' '); /* Detection for A: only one argument with one argumentpart containing void*/ if ((argumentparts.Length == 1) && (arguments.Length == 1) && (argumentparts[0].IndexOf("void") >= 0)) { continue; } int lastPositionOfTypeBackwards = 1; /* Means the last element of argumentparts is variable name */ /* Detection for E, F, G: argument without variable name */ if ((argumentparts[argumentparts.Length - 1] == "*") || (argumentparts[argumentparts.Length - 1] == "&") || (argumentparts.Length == 1) ) { lastPositionOfTypeBackwards = 0; /* Means the last element of argumentparts is type */ } Argument arg = new Argument(); arg.Type = ""; for (int i = 0; i < argumentparts.Length - lastPositionOfTypeBackwards; i++) { arg.Type = arg.Type + argumentparts[i] + " "; } arg.Type = arg.Type.Trim(); if (lastPositionOfTypeBackwards == 1) { arg.Name = argumentparts[argumentparts.Length - 1].Trim(); } else { /* Autoname for the variable */ arg.Name = string.Format("{0}", nextargumentname++); } f.Arguments.Add(arg); } functions.Add(f); /*Console.Write("{0} {1} (", f.ReturnType, f.Name); * int j; * if (f.Arguments.Count > 0) * { * for (j = 0; j < f.Arguments.Count - 1; j++) * Console.Write("{0} {1} ({2}), ", f.Arguments[j].Type, f.Arguments[j].Name, f.Arguments[j].Register); * Console.Write("{0} {1} ({2})", f.Arguments[j].Type, f.Arguments[j].Name, f.Arguments[j].Register); * } * Console.WriteLine(");");*/ } sr.Close(); return(functions); }