CSharp to LowLevel

  • C#

Es gibt 10 Antworten in diesem Thema. Der letzte Beitrag () ist von Facebamm.

    CSharp to LowLevel

    Hallo,

    Die Hauptfrage ist, wie würdet ihr das angehen?

    Was ist mein Ziel?
    Mein Ziel ist es eine neue Programmiersprache bzw. angepasstes CSharp für mehr Low-Level access und features zu "schreiben".
    Was stört mich momentan an CSharp?

    Spoiler anzeigen
    naja, mittlerweile arbeite ich viel mit CSharp auf geräten mit den ich gern viel mehr machen würdem zum Beispiel mit einem Raspberry Pi 4 (Hier raus entstand auch alles).
    ... Mir feht da einfach das low level .. in manchen fällen wurde ich gern assembler ausführen, was in CSharp seh schwer ist umzusetzen.

    Hier mal wie sowas aussehen könnte(windows)
    Spoiler anzeigen

    C#-Quellcode

    1. static class PFunction
    2. {
    4. public static void* LoadMemoryFunction(byte[] funcSrc)
    5. {
    6. int srcLen = (funcSrc.Length * sizeof(byte));
    7. byte* pFunc = (byte*) Marshal.AllocHGlobal(srcLen); // wurde ich jetzt auch nicht mehr so machen
    8. Buffer.MemoryCopy(Unsafe.AsPointer(ref funcSrc[0]), pFunc, srcLen , srcLen);
    9. VirtualProtectEx(Process.GetCurrentProcess().Handle, pFunc, (UIntPtr)srcLen, 0x40, out _);
    11. return pFunc;
    12. }
    14. [DllImport("kernel32.dll")]
    15. static extern bool VirtualProtectEx(IntPtr hProcess,
    16. void* lpAddress,
    17. UIntPtr dwSize,
    18. uint flNewProtect,
    19. out uint lpflOldProtect);
    20. }
    21. // weiß nicht mal mehr ob das noch geht
    22. private static readonly byte[] asmCode =
    23. {
    24. 0x89, 0xD0, 0x44, 0x29, 0xC0,
    25. 0x89, 0xC1, 0xC1, 0xF9, 0x1F, 0x21,
    26. 0xC1, 0x89, 0xD0, 0x29, 0xC8, 0xC3
    27. };
    29. private byte* asmCodeBuffer;
    31. private delegate* <int, int, int> MinMaxASM;
    32. private delegate* <int, int, int> MinMax;
    34. public void Init()
    35. {
    37. MinMaxASM = (delegate* <int, int, int>) PFunction.LoadMemoryFunction(asmCode);
    38. MinMax = &MinMax2;
    39. }


    - oder einfach paar nop's als timing ist recht "aufwending"
    Spoiler anzeigen

    C#-Quellcode

    1. public delegate void TimerInvoker();
    2. public static TimerInvoker CreateNopTimer(int cycleCount)
    3. {
    4. DynamicMethod delayN = new DynamicMethod(
    5. $"Delay{cycleCount}",
    6. null,
    7. null,
    8. typeof(Timer).Module);
    10. ILGenerator il = delayN.GetILGenerator();
    11. for (int i = 0; i < cycleCount; i++)
    12. {
    13. il.Emit(OpCodes.Nop);
    14. }
    15. il.Emit(OpCodes.Ret);
    17. return (TimerInvoker)delayN.CreateDelegate(typeof(TimerInvoker));
    18. }

    - oder warum muss ich bei einer IF-Abfrage immer ein bool haben, warum nicht 0 := 0 und >0 := 1?
    Hier beim auslesen vom status im speicher
    Spoiler anzeigen

    C#-Quellcode

    1. public unsafe bool GetValueBool(){
    2. return (*_levRegisterOffset & _levValueMask) == _levValueMask;
    3. }

    Warum die abfrage ob das identisch ist um einen bool zu erhalten?

    - oder warum kann ich kein datentyp gaben der ab den 3 Bit schreibt, sonder nur in byte steps [FiedOffset(byteoffset)].

    - dann fehlen mir die macros
    Spoiler anzeigen

    C#-Quellcode

    1. // quellcode ist noch beim übersetzen von Cpp to CSharp, also nicht wundern wegen dem sizeof(struct v4l2_streamparm)
    2. /// <summary>_IOWR('V', 15, struct v4l2_buffer)</summary>
    3. public const uint VIDIOC_QBUF = (_IOWR << (int) _IOC_DIRSHIFT)
    4. | ((uint) 'V' << (int) _IOC_TYPESHIFT)
    5. | (15U << (int) _IOC_NRSHIFT)
    6. | ((uint) sizeof(struct v4l2_buffer) << (int) _IOC_SIZESHIFT);
    8. /// <summary>_IOWR('V', 17, struct v4l2_buffer)</summary>
    9. public const uint VIDIOC_DQBUF = (_IOWR << (int) _IOC_DIRSHIFT)
    10. | ((uint) 'V' << (int) _IOC_TYPESHIFT)
    11. | (17U << (int) _IOC_NRSHIFT)
    12. | ((uint) sizeof(struct v4l2_buffer) << (int) _IOC_SIZESHIFT);
    14. /// <summary>_IOW('V', 18, int)</summary>
    15. public const uint VIDIOC_STREAMON = (_IOW << (int) _IOC_DIRSHIFT)
    16. | ((uint) 'V' << (int) _IOC_TYPESHIFT)
    17. | (18U << (int) _IOC_NRSHIFT)
    18. | ((uint) sizeof(int) << (int) _IOC_SIZESHIFT);
    20. /// <summary>_IOW('V', 19, int)</summary>
    21. public const uint VIDIOC_STREAMOFF = (_IOW << (int) _IOC_DIRSHIFT)
    22. | ((uint) 'V' << (int) _IOC_TYPESHIFT)
    23. | (19U << (int) _IOC_NRSHIFT)
    24. | ((uint) sizeof(int) << (int) _IOC_SIZESHIFT);
    26. /// <summary>_IOWR('V', 21, struct v4l2_streamparm)</summary>
    27. public const uint VIDIOC_G_PARM = (_IOWR << (int) _IOC_DIRSHIFT)
    28. | ((uint) 'V' << (int) _IOC_TYPESHIFT)
    29. | (21U << (int) _IOC_NRSHIFT)
    30. | ((uint) sizeof(struct v4l2_streamparm) << (int) _IOC_SIZESHIFT);
    31. /// <summary>_IOWR('V', 22, struct v4l2_streamparm)</summary>
    32. public const uint VIDIOC_S_PARM = (_IOWR << (int) _IOC_DIRSHIFT)
    33. | ((uint) 'V' << (int) _IOC_TYPESHIFT)
    34. | (22U << (int) _IOC_NRSHIFT)
    35. | ((uint) sizeof(struct v4l2_streamparm) << (int) _IOC_SIZESHIFT);
    36. /// <summary>_IOR('V', 23, v4l2_std_id)</summary>
    37. public const uint VIDIOC_G_STD = (_IOR << (int) _IOC_DIRSHIFT)
    38. | ((uint) 'V' << (int) _IOC_TYPESHIFT)
    39. | (23U << (int) _IOC_NRSHIFT)
    40. | ((uint) sizeof(v4l2_std_id) << (int) _IOC_SIZESHIFT);
    42. /// <summary>_IOW('V', 24, v4l2_std_id)</summary>
    43. public const uint VIDIOC_S_STD = (_IOW << (int) _IOC_DIRSHIFT)
    44. | ((uint) 'V' << (int) _IOC_TYPESHIFT)
    45. | (24U << (int) _IOC_NRSHIFT)
    46. | ((uint) sizeof(v4l2_std_id) << (int) _IOC_SIZESHIFT);



    Dann stört es mich, das ich keine Context freien Methoden schreiben kann.
    Also ich brauch immer eine Klasse.
    Ich weiß ich kann using static xyz; nutzen, aber das ist doch nicht sinn der sache.

    Ich weiß das es für VS ein plugin gibt mit dem direkt il geschrieben werden kann, aber selbst das ist nicht so schön. (Mein empfinden)


    Was ich damit sagen will: Immer wird gesagt, man kann kein OS in CSharp schreiben (Was schon probiert wurde und auch ziemlich gut klappte, soweit ich weiß) und das find ich eig traurig,
    denn ich find CSharp eine wunderschöne sprache, denn sie liest sich (für mich) wie ein Buch und ich find auch den Style sehr schön in CSharp.

    Kurz um drum: Mir fehlen Feature ... und die Code-Gen Ka*** macht es nicht besser. Ist schön aber jedes mal Visual Studio neustarten nach einer änderung macht kein Spaß :thumbdown:
    PS: ReSharper ist da nicht besser.


    So wie würdet ihr das angehen?
    - Eigenen parser mit lexer, gramma und was da nicht dazu gehört (nicht compiler, der muss eh neu geschrieben werden)
    - Den kram von Roslyn nutzen, der sehr aufwending geschreiben ist und erst studiert werden muss?
    - Microsoft.CodeAnalysis.CSharp- Nuget nutzen, damit ich mir lexing und parsing spare und "nur noch" die nodes analysieren muss?
    - oder ganz anders?


    MfG

    Facebamm

    Ich kann dir nicht folgen?
    Eine neue Sprache angelehnt an C#? Oder Erweiterungen wie Nuget-Pakete?

    Was ist für dich LowLevel? LowLevel als Einstiegshürde? Als Hardwarenah?

    Was passt dir jetzt an Visual Studio nicht?
    Reicht VS-Code?
    Die deutsche Sprache ist Freeware, du kannst sie benutzen, ohne dafür zu bezahlen. Sie ist aber nicht Open Source, also darfst du sie nicht verändern, wie es dir gerade passt.

    Eher gesagt ich will die ganze .Net Runtime los werden. Also wie C oder Cpp nur ohne den Linker kram und der komischen Sprachen.

    Zudem möchte ich sprachspezifische Features hinzufügen wie:
    - asm-inline
    - macros
    - BitPos, also FiedOffset bloß für bits und das ohne getter, setter und masking
    - Circular shift <<<, >>>
    - if-abfragen bei den ich direkt nen wert rein geben kann und es nur geprüft wird ob der wert >0 := true und 0 := false

    Aber dazu muss brauch ich nen eigenen Compiler
    Und meine erster schritt ist dahin gehen der Lexer, Parser etc.

    Nun ist die Frage wie ich das am besten angehe.
    Dazu hab ich mir verschiedene gedanken gemacht wie ich das machen könnte um erstmal einen Parser zu bekommen:
    - Eigenen parser mit lexer, gramma und was da nicht dazu gehört (nicht compiler, der muss eh neu geschrieben werden)
    - Den kram von Roslyn nutzen, der sehr aufwending geschreiben ist und erst studiert werden muss?
    - Microsoft.CodeAnalysis.CSharp- Nuget nutzen, damit ich mir lexing und parsing spare und "nur noch" die nodes analysieren muss?
    - oder ganz anders?

    BTW. der Parser muss nicht in Cpp oder C geschrieben werden, kann das ganze auch in CSharp machen, aber das was am ende rauskommen soll, sollte unabhängig von der .Net Runtime sein.

    Das ist ja ein absolutes Mammutprojekt, das wird dich viele Jahre kosten denke ich.
    Da ist es vermutlich besser sich eine ganz neue Sprache zu suchen, wenn dich wirklich so viel an dem managed in C# stört? Ist halt absichtlich keine LowLevel-Sprache. Es gibt ja noch Unmengen alternativen.
    Aber vielleicht kannst du ja mal schauen was Unity da gemacht hat. Die haben ja auch einen IL2Cpp gemacht um den C# code nach C++ und dann native zu kompilieren:

    IL2CPP
    LLILC Reader

    Fakiz schrieb:

    UWP Apps werden zu Nativen Code kompiliert Stichwort .Net Native.

    Darum geht es hier aber nicht!

    und Btw.: Universal Windows Platform (UWP) apps[1] (formerly Windows Store apps and Metro-style apps)[2] are applications that can be used across all compatible Microsoft Windows devices, including personal computers (PCs), tablets, smartphones, Xbox One, Microsoft HoloLens, and Internet of Things. - wiki

    Was mit ATMega Chips?
    Wo sind da die Feature?

    So wie ich das sehe ist das Kernstück deiner Anwendung die Entwicklung der Kompliler, Syntax und Schlüßelwörter existieren weitestgehend. Wenn du einmal ganz unscheniert .Net Native (Stichwort .Net Nativ nicht UWP) in deine bevorzugte Suchmaschine eingibst stolperst du zwangsläufig über den MS DevBlog zum .Net Native Kompiler. Dort erklärt MS anschaulich wie dieser Funktioniert und welche Bestandteile dieser hat. Das sollte neben dem lernen einer Assembler Sprache ein guter Anfang sein.

    Okay, ... hast du für mich einen direkten link, denn meine Suchmaschine bringt mir diese Beiträge nicht


    Es wäre schon cool, wenn ich da auch einiges "klauen" könnte, so muss ich nicht alles neu schreiben.

    Edit:
    bzw.

    Hier mal mein Lexer :D btw ... ist noch nicht alles drin was ich haben will :w
    was mich auch stört ist, das ich immer den Source mit gebe

    Wird irgendwann noch auf git kommen das ganze :D

    LexerLevel1.cs
    Spoiler anzeigen

    C#-Quellcode

    1. namespace CNative;
    3. using System.Collections.Concurrent;
    4. using System.Runtime.CompilerServices;
    5. using static LexerNodeType;
    7. internal enum LexerNodeType
    8. {
    9. Space,
    10. Word,
    11. Number,
    12. Symbol
    13. }
    15. internal struct LexerNode
    16. {
    17. public readonly LexerNodeType Type;
    18. public readonly int Start;
    19. public readonly int End;
    21. public LexerNode(LexerNodeType type, int start, int end)
    22. {
    23. Type = type;
    24. Start = start;
    25. End = end;
    26. }
    27. }
    29. internal class LexerLevel1
    30. {
    31. private string _src;
    32. private ConcurrentQueue<LexerNode> _queue;
    34. public LexerLevel1(
    35. string src,
    36. ref ConcurrentQueue<LexerNode> level1LexerQueue)
    37. {
    38. _src = src;
    39. _queue = level1LexerQueue;
    40. }
    42. public async Task AnalyseAsync(CancellationTokenSource cts, CancellationToken ct)
    43. {
    44. await Task.Run(() =>
    45. {
    46. ReadOnlySpan<char> sourceCode = _src.ToCharArray();
    47. int i = 0;
    49. while (!cts.IsCancellationRequested && i < sourceCode.Length)
    50. {
    51. Unsafe.SkipInit(out LexerNode node);
    53. if (IsSpace(sourceCode, in i, ref node)
    54. || IsDigit(_src, in i, ref node)
    55. || IsWord(_src, in i, ref node))
    56. {
    57. _queue.Enqueue(node);
    58. }
    59. else
    60. {
    61. node = new LexerNode(Symbol, i, i + 1);
    62. _queue.Enqueue(node);
    63. }
    65. i = node.End;
    66. }
    68. if (!ct.IsCancellationRequested)
    69. {
    70. cts.Cancel();
    71. }
    73. }, ct);
    74. }
    76. private static bool IsSpace(ReadOnlySpan<char> src, in int i, ref LexerNode node) {
    77. if (src[i] is ' ' or '\t' or '\r' or '\n')
    78. {
    79. node = new LexerNode(Space, i, i + 1);
    80. return true;
    81. }
    83. return false;
    84. }
    86. private static bool IsDigit(ReadOnlySpan<char> src, in int i, ref LexerNode node) {
    87. if(src[i] is >= '0' and <= '9')
    88. {
    89. int end = i + 1;
    90. while (end < src.Length && src[end] is >= '0' and <= '9')
    91. {
    92. end++;
    93. }
    95. node = new LexerNode(Number, i, end);
    96. return true;
    97. }
    99. return false;
    100. }
    102. private static bool IsWord(ReadOnlySpan<char> src, in int i, ref LexerNode node)
    103. {
    104. if (src[i] is (>= 'A' and <= 'Z') or (>= 'a' and <= 'z'))
    105. {
    106. int end = i + 1;
    107. while (end < src.Length && src[end] is (>= 'A' and <= 'Z') or (>= 'a' and <= 'z'))
    108. {
    109. end++;
    110. }
    112. node = new LexerNode(Word, i, end);
    113. return true;
    114. }
    116. return false;
    117. }
    118. }

    LexerLevel2.cs
    Spoiler anzeigen

    Quellcode

    1. namespace CNative;
    3. using System.Collections.Concurrent;
    4. using System.Diagnostics;
    5. using static LexerTokenType;
    7. public enum LexerTokenType
    8. {
    9. // keyword
    10. /// <summary> byte </summary>
    11. Byte,
    12. /// <summary> bool </summary>
    13. Bool,
    14. /// <summary> class </summary>
    15. Class,
    16. /// <summary> char </summary>
    17. Char,
    18. /// <summary> do </summary>
    19. Do,
    20. /// <summary> double </summary>
    21. Double,
    22. /// <summary> enum </summary>
    23. Enum,
    24. /// <summary> false </summary>
    25. False,
    26. /// <summary> for </summary>
    27. For,
    28. /// <summary> foreach </summary>
    29. Foreach,
    30. /// <summary> float </summary>
    31. Float,
    32. /// <summary> get </summary>
    33. Get,
    34. /// <summary> interface </summary>
    35. Interface,
    36. /// <summary> if </summary>
    37. If,
    38. /// <summary> null </summary>
    39. Null,
    40. /// <summary> public </summary>
    41. Public,
    42. /// <summary> private </summary>
    43. Private,
    44. /// <summary> return </summary>
    45. Return,
    46. /// <summary> set </summary>
    47. Set,
    48. /// <summary> struct </summary>
    49. Struct,
    50. /// <summary> sbyte </summary>
    51. SByte,
    52. /// <summary> stackalloc </summary>
    53. Stackalloc,
    54. /// <summary> static </summary>
    55. Static,
    56. /// <summary> true </summary>
    57. True,
    58. /// <summary> this </summary>
    59. This,
    60. /// <summary> ushort </summary>
    61. UShort,
    62. /// <summary> uint </summary>
    63. UInt,
    64. /// <summary> ulong </summary>
    65. Ulong,
    66. /// <summary> using </summary>
    67. Using,
    68. /// <summary> var </summary>
    69. Var,
    70. /// <summary> void </summary>
    71. Void,
    72. /// <summary> while </summary>
    73. While,
    74. /// <summary> #define </summary>
    75. Define,
    76. /// <summary> [_A-Za-z][_A-Za-z0-9]* </summary>
    77. Identifier,
    78. /// <summary> \s </summary>
    79. Space,
    80. /// <summary> \t </summary>
    81. Tab,
    82. /// <summary> \n or \r\n </summary>
    83. Newline,
    84. // IsCompareOperator
    85. /// <summary> &lt;= </summary>
    86. LessThen,
    87. /// <summary> >= </summary>
    88. GreaterThen,
    89. /// <summary> == </summary>
    90. EqualsThen,
    91. /// <summary> != </summary>
    92. NotEqualsThen,
    93. // Assign
    94. /// <summary> = </summary>
    95. Assign,
    96. // BinaryAssign
    97. /// <summary> &= </summary>
    98. AndEquals,
    99. /// <summary> |= </summary>
    100. OrEquals,
    101. /// <summary> ^= </summary>
    102. XorEquals,
    103. /// <summary> ~= </summary>
    104. InvertEquals,
    105. // MathmaticalAssign
    106. /// <summary> += </summary>
    107. PlusEquals,
    108. /// <summary> -= </summary>
    109. MinusEquals,
    110. /// <summary> *= </summary>
    111. MultiplicationEquals,
    112. /// <summary> **= </summary>
    113. PowerEquals,
    114. /// <summary> /= </summary>
    115. DivisionEquals,
    116. /// <summary> &= </summary>
    117. ModuloEquals,
    118. // BinaryOperator
    119. /// <summary> ~ </summary>
    120. Invert,
    121. /// <summary> ^ </summary>
    122. Xor,
    123. /// <summary> | </summary>
    124. Or,
    125. /// <summary> & </summary>
    126. And,
    127. // MathmaticalOperator
    128. /// <summary> + </summary>
    129. Plus,
    130. /// <summary> - </summary>
    131. Minus,
    132. /// <summary> * </summary>
    133. Multiplication,
    134. /// <summary> ** </summary>
    135. Power,
    136. /// <summary> / </summary>
    137. Division,
    138. /// <summary> % </summary>
    139. Modulo,
    140. // Symbols
    141. /// <summary> . </summary>
    142. Dot,
    143. /// <summary> , </summary>
    144. Comma,
    145. /// <summary> ' </summary>
    146. SingleQuotationMark,
    147. /// <summary> " </summary>
    148. DoubleQuotationMark,
    149. /// <summary> : </summary>
    150. Colon,
    151. /// <summary> ; </summary>
    152. Semicolon,
    153. /// <summary> ! </summary>
    154. ExclamationMark,
    155. /// <summary> ( </summary>
    156. OpenParenthesis,
    157. /// <summary> ) </summary>
    158. CloseParenthesis,
    159. /// <summary> [ </summary>
    160. OpenBrackets,
    161. /// <summary> ] </summary>
    162. CloseBrackets,
    163. /// <summary> { </summary>
    164. OpenBraces,
    165. /// <summary> } </summary>
    166. CloseBraces,
    167. /// <summary> [0-9]+ </summary>
    168. Numbers,
    169. /// <summary> //[^$]* </summary>
    170. SingleLineComment,
    171. /// <summary> /* </summary>
    172. InlineCommentStart,
    173. /// <summary> */ </summary>
    174. InlineCommentEnd,
    176. Unknown = -1
    177. }
    179. [DebuggerDisplay("Type = {Type}")]
    180. internal struct LexerToken
    181. {
    182. public readonly LexerTokenType Type;
    183. public readonly int Start;
    184. public readonly int End;
    186. public LexerToken(LexerTokenType type, int start, int end)
    187. {
    188. Type = type;
    189. Start = start;
    190. End = end;
    191. }
    192. }
    194. internal class LexerLevel2
    195. {
    196. private string _src;
    198. private ConcurrentQueue<LexerNode> _level1Queue;
    199. private ConcurrentQueue<LexerToken> _level2Queue;
    201. public LexerLevel2(
    202. string src,
    203. ref ConcurrentQueue<LexerNode> level1LexerQueue,
    204. ref ConcurrentQueue<LexerToken> level2LexerQueue)
    205. {
    206. _src = src;
    208. _level1Queue = level1LexerQueue;
    209. _level2Queue = level2LexerQueue;
    210. }
    212. public async Task AnalyseAsync(CancellationToken ct = default)
    213. {
    214. await Task.Run(() =>
    215. {
    216. int end;
    217. LexerTokenType type;
    219. ReadOnlySpan<char> src = _src.ToCharArray();
    221. while (!ct.IsCancellationRequested || _level1Queue.Count > 0)
    222. {
    223. // TODO: out params and if's
    224. LexerNode node = GetNextLvl1Node();
    225. switch (node.Type)
    226. {
    227. case LexerNodeType.Space:
    228. if (IsSpace(src, node.Start, out end, out type))
    229. {
    230. AddLevel2Token(node.Start, node.End, type);
    231. }
    232. else
    233. {
    234. AddLevel2Token(node.Start, node.End, Unknown);
    235. }
    236. break;
    237. case LexerNodeType.Word:
    238. if (IsKeyword(src, node.Start, out end, out type) && node.End == end)
    239. {
    240. AddLevel2Token(node.Start, node.End, type);
    241. }
    242. else
    243. {
    244. AddLevel2Token(node.Start, node.End, Unknown);
    245. }
    246. break;
    247. case LexerNodeType.Number:
    248. AddLevel2Token(node.Start, node.End, Numbers);
    249. break;
    250. case LexerNodeType.Symbol:
    251. if (IsSymbol(src, node.Start, out end, out type))
    252. {
    253. // skip next symbol
    254. int delta = end - node.End;
    255. while (delta > 0)
    256. {
    257. GetNextLvl1Node();
    258. delta--;
    259. }
    260. // end skip
    261. AddLevel2Token(node.Start, end, type);
    262. }
    263. else
    264. {
    265. AddLevel2Token(node.Start, node.End, Unknown);
    266. }
    267. break;
    268. default:
    269. throw new NotSupportedException(node.Type.ToString());
    270. }
    271. }
    272. }, ct);
    273. }
    275. private LexerNode GetNextLvl1Node()
    276. {
    277. // TODO:
    278. LexerNode node;
    279. while(!_level1Queue.TryDequeue(out node))
    280. { }
    281. return node;
    282. }
    284. private void AddLevel2Token(int start, int end, LexerTokenType type)
    285. {
    286. _level2Queue.Enqueue(new LexerToken(type, start, end));
    287. }
    289. public static bool IsKeyword(ReadOnlySpan<char> src, int i, out int end, out LexerTokenType type)
    290. {
    291. switch (src[i])
    292. {
    293. case 'b': // byte, bool
    294. return IsByteOrBool(src, i, out end, out type);
    295. case 'c': // class, char
    296. return IsClassOrChar(src, i, out end, out type);
    297. case 'd': // do...while, double
    298. return IsDoOrDouble(src, i, out end, out type);
    299. case 'e': // enum
    300. return IsEnum(src, i, out end, out type);
    301. case 'f': // false, for, foreach, float
    302. return IsFalseOrForOrForeachOrFloat(src, i, out end, out type);
    303. case 'g': // get
    304. return IsGet(src, i, out end, out type);
    305. case 'i': // interface, if
    306. return IsInterfaceOrIf(src, i, out end, out type);
    307. case 'n': // null
    308. return IsNull(src, i, out end, out type);
    309. case 'p': // public, private
    310. return IsPublicOrPrivate(src, i, out end, out type);
    311. case 'r': // return
    312. return IsReturn(src, i, out end, out type);
    313. case 's': // struct, sbyte, stackalloc, static
    314. return IsSetOrStructOrStackallocOrStaticOrSByte(src, i, out end, out type);
    315. case 't': // true, this
    316. return IsTrueOrThis(src, i, out end, out type);
    317. case 'u': // ushort, uint, ulong, using [union]
    318. return IsUsingOrUShortOrUIntOrULong(src, i, out end, out type);
    319. case 'v': // var, void
    320. return IsVarOrVoid(src, i, out end, out type);
    321. case 'w': // while
    322. return IsWhile(src, i, out end, out type);
    323. case '#': // #define
    324. return IsPragma(src, i, out end, out type);
    325. default:
    326. end = 0;
    327. type = Unknown;
    328. return false;
    329. }
    330. }
    331. private static bool IsByteOrBool(ReadOnlySpan<char> src, int i, out int end, out LexerTokenType type)
    332. {
    333. i++;
    334. switch (src[i])
    335. {
    336. case 'y': // byte
    337. if (src[i + 1] is 't' && src[i + 2] is 'e')
    338. {
    339. end = i + 3;
    340. type = Byte;
    341. return true;
    342. }
    343. break;
    344. case 'o': // bool
    345. if (src[i + 1] is 'o' && src[i + 2] is 'l')
    346. {
    347. end = i + 3;
    348. type = Bool;
    349. return true;
    350. }
    351. break;
    352. }
    354. end = 0;
    355. type = Unknown;
    356. return false;
    357. }
    358. private static bool IsClassOrChar(ReadOnlySpan<char> src, int i, out int end, out LexerTokenType type)
    359. {
    360. i++;
    361. switch (src[i])
    362. {
    363. case 'l': // Class
    364. if (src[i + 1] is 'a' && src[i + 2] is 's' && src[i + 3] is 's')
    365. {
    366. end = i + 4;
    367. type = Class;
    368. return true;
    369. }
    370. break;
    371. case 'h': // Char
    372. if (src[i + 1] is 'a' && src[i + 2] is 'r')
    373. {
    374. end = i + 3;
    375. type = Char;
    376. return true;
    377. }
    378. break;
    379. }
    381. end = 0;
    382. type = Unknown;
    383. return false;
    384. }
    385. private static bool IsDoOrDouble(ReadOnlySpan<char> src, int i, out int end, out LexerTokenType type)
    386. {
    387. i++;
    388. if (src[i] is 'o') // do
    389. {
    390. if(src[i + 1] is 'u' && src[i + 2] is 'b' && src[i + 3] is 'l' && src[i + 4] is 'e')
    391. {
    392. end = i + 5;
    393. type = Double;
    394. return true;
    395. }
    396. end = i + 1;
    397. type = Do;
    398. return true;
    399. }
    401. end = 0;
    402. type = Unknown;
    403. return false;
    404. }
    405. private static bool IsEnum(ReadOnlySpan<char> src, int i, out int end, out LexerTokenType type)
    406. {
    407. i++;
    408. if (src[i] is 'n' && src[i + 1] is 'u' && src[i + 2] is 'm') // enum
    409. {
    410. end = i + 3;
    411. type = Enum;
    412. return true;
    413. }
    415. end = 0;
    416. type = Unknown;
    417. return false;
    418. }
    419. private static bool IsFalseOrForOrForeachOrFloat(ReadOnlySpan<char> src, int i, out int end, out LexerTokenType type)
    420. {
    421. i++;
    422. switch (src[i])
    423. {
    424. case 'a': // false
    425. if (src[i + 1] is 'l' && src[i + 2] is 's' && src[i + 3] is 'e')
    426. {
    427. end = i + 4;
    428. type = False;
    429. return true;
    430. }
    431. break;
    432. case 'o': // for or foreach
    433. if (src[i + 1] is 'r')
    434. {
    435. if (src[i + 2] is 'e' && src[i + 3] is 'a' && src[i + 4] is 'c' && src[i + 5] is 'h') // foreach
    436. {
    437. end = i + 6;
    438. type = Foreach;
    439. return true;
    440. }
    442. // for
    443. end = i + 2;
    444. type = For;
    445. return true;
    446. }
    447. break;
    448. case 'l': // float
    449. if(src[i + 1] is 'o' && src[i + 2] is 'a' && src[i + 3] is 't')
    450. {
    451. end = i + 4;
    452. type = Float;
    453. return true;
    454. }
    455. break;
    456. }
    458. end = 0;
    459. type = Unknown;
    460. return false;
    461. }
    462. private static bool IsGet(ReadOnlySpan<char> src, int i, out int end, out LexerTokenType type)
    463. {
    464. i++;
    465. if (src[i] is 'e' && src[i + 1] is 't') // get
    466. {
    467. end = i + 2;
    468. type = Get;
    469. return true;
    470. }
    472. end = 0;
    473. type = Unknown;
    474. return false;
    475. }
    476. private static bool IsInterfaceOrIf(ReadOnlySpan<char> src, int i, out int end, out LexerTokenType type)
    477. {
    478. i++;
    479. switch (src[i])
    480. {
    481. case 'n': // interface
    482. if (src[i + 1] is 't' && src[i + 2] is 'e' && src[i + 3] is 'r' && src[i + 4] is 'f' && src[i + 5] is 'a' && src[i + 6] is 'c' && src[i + 7] is 'e')
    483. {
    484. end = i + 8;
    485. type = Interface;
    486. return true;
    487. }
    488. break;
    489. case 'f': // if
    490. if (src[i] is 'f')
    491. {
    492. end = i + 1;
    493. type = If;
    494. return true;
    495. }
    496. break;
    497. }
    499. end = 0;
    500. type = Unknown;
    501. return false;
    502. }
    503. private static bool IsNull(ReadOnlySpan<char> src, int i, out int end, out LexerTokenType type)
    504. {
    505. i++;
    506. if (src[i] is 'u' && src[i + 1] is 'l' && src[i + 2] is 'l') // null
    507. {
    508. end = i + 3;
    509. type = Null;
    510. return true;
    511. }
    513. end = 0;
    514. type = Unknown;
    515. return false;
    516. }
    517. private static bool IsPublicOrPrivate(ReadOnlySpan<char> src, int i, out int end, out LexerTokenType type)
    518. {
    519. i++;
    520. switch (src[i])
    521. {
    522. case 'u': // public
    523. if (src[i + 1] is 'b' && src[i + 2] is 'l' && src[i + 3] is 'i' && src[i + 4] is 'c')
    524. {
    525. end = i + 5;
    526. type = Public;
    527. return true;
    528. }
    529. break;
    530. case 'r': // private
    531. if (src[i + 1] is 'i' && src[i + 2] is 'v' && src[i + 3] is 'a' && src[i + 4] is 't' && src[i + 5] is 'e')
    532. {
    533. end = i + 6;
    534. type = Private;
    535. return true;
    536. }
    537. break;
    538. }
    540. end = 0;
    541. type = Unknown;
    542. return false;
    543. }
    544. private static bool IsReturn(ReadOnlySpan<char> src, int i, out int end, out LexerTokenType type)
    545. {
    546. i++;
    547. if (src[i] is 'e' && src[i + 1] is 't' && src[i + 2] is 'u' && src[i + 3] is 'r' && src[i + 4] is 'n') // return
    548. {
    549. end = i + 5;
    550. type = Return;
    551. return true;
    552. }
    554. end = 0;
    555. type = Unknown;
    556. return false;
    557. }
    558. private static bool IsSetOrStructOrStackallocOrStaticOrSByte(ReadOnlySpan<char> src, int i, out int end, out LexerTokenType type)
    559. {
    560. i++;
    561. switch (src[i])
    562. {
    563. case 'e': // set
    564. if (src[i + 1] is 't')
    565. {
    566. end = i + 2;
    567. type = Set;
    568. return true;
    569. }
    570. break;
    571. case 't': // struct, stackalloc, static
    572. switch (src[i + 1])
    573. {
    574. case 'a': // stackalloc, static
    575. switch (src[i + 2])
    576. {
    577. case 'c': // stackalloc
    578. if (src[i + 3] is 'k' && src[i + 4] is 'a' && src[i + 5] is 'l' && src[i + 6] is 'l' && src[i + 7] is 'o' && src[i + 8] is 'c')
    579. {
    580. end = i + 9;
    581. type = Stackalloc;
    582. return true;
    583. }
    584. break;
    585. case 't': // static
    586. if (src[i + 3] is 'i' && src[i + 4] is 'c')
    587. {
    588. end = i + 5;
    589. type = Static;
    590. return true;
    591. }
    592. break;
    593. }
    594. break;
    595. case 'r': // struct
    596. if (src[i + 1] is 'u' && src[i + 2] is 'c' && src[i + 3] is 't') // Struct
    597. {
    598. end = i + 4;
    599. type = Struct;
    600. return true;
    601. }
    602. break;
    603. }
    604. break;
    605. case 'b': // Sbyte
    606. if (src[i + 1] is 'y' && src[i + 2] is 't' && src[i + 3] is 'e') // Sbyte
    607. {
    608. end = i + 4;
    609. type = SByte;
    610. return true;
    611. }
    612. break;
    613. }
    615. end = 0;
    616. type = Unknown;
    617. return false;
    618. }
    619. private static bool IsTrueOrThis(ReadOnlySpan<char> src, int i, out int end, out LexerTokenType type)
    620. {
    621. i++;
    622. switch (src[i])
    623. {
    624. case 'r': // true
    625. if (src[i + 1] is 'u' && src[i + 2] is 'e')
    626. {
    627. end = i + 3;
    628. type = True;
    629. return true;
    630. }
    631. break;
    632. case 'h': // this
    633. if(src[i + 1] is 'i' && src[i + 2] is 's')
    634. {
    635. end = i + 3;
    636. type = This;
    637. return true;
    638. }
    639. break;
    640. }
    642. end = 0;
    643. type = Unknown;
    644. return false;
    645. }
    646. private static bool IsUsingOrUShortOrUIntOrULong(ReadOnlySpan<char> src, int i, out int end, out LexerTokenType type)
    647. {
    648. i++;
    649. switch (src[i])
    650. {
    651. case 's': // using, ushort
    652. switch (src[i + 1])
    653. {
    654. case 'i': // using
    655. if (src[i + 2] is 'n' && src[i + 3] is 'g') // using
    656. {
    657. end = i + 4;
    658. type = Using;
    659. return true;
    660. }
    661. break;
    662. case 'h': // ushort
    663. if (src[i + 2] is 'o' && src[i + 3] is 'r' && src[i + 4] is 't') // ushort
    664. {
    665. end = i + 5;
    666. type = UShort;
    667. return true;
    668. }
    669. break;
    670. }
    671. break;
    672. case 'i': // uint
    673. if (src[i + 1] is 'n' && src[i + 2] is 't') // uint
    674. {
    675. end = i + 3;
    676. type = UInt;
    677. return true;
    678. }
    679. break;
    680. case 'l': // ulong
    681. if (src[i + 1] is 'o' && src[i + 2] is 'n' && src[i + 3] is 'g') // ulong
    682. {
    683. end = i + 4;
    684. type = Ulong;
    685. return true;
    686. }
    687. break;
    688. }
    690. end = 0;
    691. type = Unknown;
    692. return false;
    693. }
    694. private static bool IsVarOrVoid(ReadOnlySpan<char> src, int i, out int end, out LexerTokenType type)
    695. {
    696. i++;
    697. switch (src[i])
    698. {
    699. case 'a':// var
    700. if (src[i + 1] is 'r')
    701. {
    702. end = i + 2;
    703. type = Var;
    704. return true;
    705. }
    706. break;
    707. case 'o': // void
    708. if (src[i + 1] is 'i' && src[i + 2] is 't')
    709. {
    710. end = i + 3;
    711. type = Void;
    712. return true;
    713. }
    714. break;
    715. }
    717. end = 0;
    718. type = Unknown;
    719. return false;
    720. }
    721. private static bool IsWhile(ReadOnlySpan<char> src, int i, out int end, out LexerTokenType type)
    722. {
    723. i++;
    724. if (src[i] is 'h' && src[i + 1] is 'i' && src[i + 2] is 'l' && src[i + 3] is 'e') // while
    725. {
    726. end = i + 4;
    727. type = While;
    728. return true;
    729. }
    731. end = 0;
    732. type = Unknown;
    733. return false;
    734. }
    735. private static bool IsPragma(ReadOnlySpan<char> src, int i, out int end, out LexerTokenType type)
    736. {
    737. i++;
    738. if (src[i] is 'p' && src[i + 1] is 'r' && src[i + 2] is 'a' && src[i + 3] is 'g' && src[i + 4] is 'm' && src[i + 5] is 'a') // pragma
    739. {
    740. end = i + 6;
    741. type = Define;
    742. return true;
    743. }
    745. end = 0;
    746. type = Unknown;
    747. return false;
    748. }
    750. private static bool IsSpace(ReadOnlySpan<char> src, int i, out int end, out LexerTokenType type)
    751. {
    752. return IsSpaceOrTab(src, i, out end, out type) || IsNewline(src, i, out end, out type);
    753. }
    754. private static bool IsSpaceOrTab(ReadOnlySpan<char> src, int i, out int end, out LexerTokenType type)
    755. {
    756. switch (src[i])
    757. {
    758. case ' ':
    759. end = i + 1;
    760. type = Space;
    761. return true;
    762. case '\t':
    763. end = i + 1;
    764. type = Tab;
    765. return true;
    766. }
    768. end = 0;
    769. type = Unknown;
    770. return false;
    771. }
    772. private static bool IsNewline(ReadOnlySpan<char> src, int i, out int end, out LexerTokenType type)
    773. {
    774. switch (src[i])
    775. {
    776. case '\r':
    777. if (src[i + 1] is '\n')
    778. {
    779. end = i + 2;
    780. type = Newline;
    781. return true;
    782. }
    783. break;
    784. case '\n':
    785. end = i + 1;
    786. type = Newline;
    787. return true;
    788. }
    790. end = 0;
    791. type = Unknown;
    792. return false;
    793. }
    795. private static bool IsSymbol(ReadOnlySpan<char> src, int i, out int end, out LexerTokenType type)
    796. {
    797. switch (src[i])
    798. {
    799. case '.':
    800. end = i + 1;
    801. type = Dot;
    802. return true;
    803. case ',':
    804. end = i + 1;
    805. type = Comma;
    806. return true;
    807. case '\'':
    808. end = i + 1;
    809. type = SingleQuotationMark;
    810. return true;
    811. case '"':
    812. end = i + 1;
    813. type = DoubleQuotationMark;
    814. return true;
    815. case ':':
    816. end = i + 1;
    817. type = Colon;
    818. return true;
    819. case ';':
    820. end = i + 1;
    821. type = Semicolon;
    822. return true;
    823. case '!':
    824. end = i + 1;
    825. type = ExclamationMark;
    826. return true;
    827. case '(':
    828. end = i + 1;
    829. type = OpenParenthesis;
    830. return true;
    831. case ')':
    832. end = i + 1;
    833. type = CloseParenthesis;
    834. return true;
    835. case '[':
    836. end = i + 1;
    837. type = OpenBrackets;
    838. return true;
    839. case ']':
    840. end = i + 1;
    841. type = CloseBrackets;
    842. return true;
    843. case '{':
    844. end = i + 1;
    845. type = OpenBraces;
    846. return true;
    847. case '}':
    848. end = i + 1;
    849. type = CloseBraces;
    850. return true;
    851. }
    853. // if all false then end became 0 and type unknown
    854. return IsAssignOperator(src, i, out end, out type)
    855. || IsOperator(src, i, out end, out type)
    856. || IsCompareOperator(src, i, out end, out type);
    857. }
    859. private static bool IsAssignOperator(ReadOnlySpan<char> src, int i, out int end, out LexerTokenType type)
    860. {
    861. if (IsBinaryAssign(src, i, out end, out type) || IsMathmaticalAssign(src, i, out end, out type))
    862. {
    863. return true;
    864. }
    865. else if (src[i] is '=')
    866. {
    867. end = i + 1;
    868. type = Assign;
    869. return true;
    870. }
    872. end = 0;
    873. type = Unknown;
    874. return false;
    875. }
    876. private static bool IsBinaryAssign(ReadOnlySpan<char> src, int i, out int end, out LexerTokenType type)
    877. {
    878. if (src[i + 1] is '=')
    879. {
    880. switch (src[i])
    881. {
    882. case '&':
    883. end = i + 2;
    884. type = AndEquals;
    885. return true;
    886. case '|':
    887. end = i + 2;
    888. type = OrEquals;
    889. return true;
    890. case '^':
    891. end = i + 2;
    892. type = XorEquals;
    893. return true;
    894. case '~':
    895. end = i + 2;
    896. type = InvertEquals;
    897. return true;
    898. }
    899. }
    901. end = 0;
    902. type = Unknown;
    903. return false;
    904. }
    905. private static bool IsMathmaticalAssign(ReadOnlySpan<char> src, int i, out int end, out LexerTokenType type)
    906. {
    907. switch (src[i + 1])
    908. {
    909. case '=':
    910. switch (src[i])
    911. {
    912. case '+':
    913. end = i + 2;
    914. type = PlusEquals;
    915. return true;
    916. case '-':
    917. end = i + 2;
    918. type = MinusEquals;
    919. return true;
    920. case '*':
    921. end = i + 2;
    922. type = MultiplicationEquals;
    923. return true;
    924. case '/':
    925. end = i + 2;
    926. type = DivisionEquals;
    927. return true;
    928. case '%':
    929. end = i + 2;
    930. type = ModuloEquals;
    931. return true;
    932. }
    933. break;
    934. case '*':
    935. if (src[i] is '*' && src[i + 2] is '=')
    936. {
    937. end = i + 3;
    938. type = PowerEquals;
    939. return true;
    940. }
    941. break;
    942. }
    944. end = 0;
    945. type = Unknown;
    946. return false;
    947. }
    949. private static bool IsOperator(ReadOnlySpan<char> src, int i, out int end, out LexerTokenType type)
    950. {
    951. return IsBinaryOperator(src, i, out end, out type)
    952. || IsMathmaticalOperatorOrComment(src, i, out end, out type);
    954. }
    955. private static bool IsBinaryOperator(ReadOnlySpan<char> src, int i, out int end, out LexerTokenType type)
    956. {
    957. switch (src[i])
    958. {
    959. case '~':
    960. end = i + 1;
    961. type = Invert;
    962. return true;
    963. case '^':
    964. end = i + 1;
    965. type = Xor;
    966. return true;
    967. case '|':
    968. end = i + 1;
    969. type = Or;
    970. return true;
    971. case '&':
    972. end = i + 1;
    973. type = And;
    974. return true;
    975. }
    977. end = 0;
    978. type = Unknown;
    979. return false;
    980. }
    981. private static bool IsMathmaticalOperatorOrComment(ReadOnlySpan<char> src, int i, out int end, out LexerTokenType type)
    982. {
    983. switch (src[i])
    984. {
    985. case '+':
    986. end = i + 1;
    987. type = Plus;
    988. return true;
    989. case '-':
    990. end = i + 1;
    991. type = Minus;
    992. return true;
    993. case '*':
    994. switch (src[i + 1])
    995. {
    996. case '*': // power
    997. end = i + 2;
    998. type = Power;
    999. return true;
    1000. case '/': // comment
    1001. end = i + 2;
    1002. type = InlineCommentEnd;
    1003. return true;
    1004. }
    1005. end = i + 1;
    1006. type = Multiplication;
    1007. return true;
    1008. case '/':
    1009. switch (src[i + 1])
    1010. {
    1011. case '*': // inline comment
    1012. end = i + 2;
    1013. type = InlineCommentStart;
    1014. return true;
    1015. case '/': // comment
    1016. end = i + 2;
    1017. type = SingleLineComment;
    1018. return true;
    1019. }
    1020. end = i + 1;
    1021. type = Division;
    1022. return true;
    1023. case '%':
    1024. end = i + 1;
    1025. type = Modulo;
    1026. return true;
    1027. }
    1029. end = 0;
    1030. type = Unknown;
    1031. return false;
    1032. }
    1034. private static bool IsCompareOperator(ReadOnlySpan<char> src, int i, out int end, out LexerTokenType type)
    1035. {
    1037. if (src[i + 1] is '=')
    1038. {
    1039. switch (src[i])
    1040. {
    1041. case '<':
    1042. end = i + 2;
    1043. type = LessThen;
    1044. return true;
    1045. case '>':
    1046. end = i + 2;
    1047. type = GreaterThen;
    1048. return true;
    1049. case '=':
    1050. end = i + 2;
    1051. type = EqualsThen;
    1052. return true;
    1053. case '!':
    1054. end = i + 2;
    1055. type = NotEqualsThen;
    1056. return true;
    1057. }
    1058. }
    1060. end = 0;
    1061. type = Unknown;
    1062. return false;
    1063. }
    1065. // todo remove into the parser
    1066. private static bool IsIdentifier(ReadOnlySpan<char> src, int i, out int end, out LexerTokenType type)
    1067. {
    1068. // starts with [A-Za-z]
    1069. if (src[i] is '_' or (>= 'A' and <= 'Z') or (>= 'a' and <= 'z'))
    1070. {
    1071. i++;
    1072. // followed by [A-Za-z0-9_]*
    1073. while (i < src.Length && src[i] is '_' or (>= 'A' and <= 'Z') or (>= 'a' and <= 'z') or (>= '0' and <= '9'))
    1074. {
    1075. i++;
    1076. }
    1077. end = i;
    1078. type = Unknown;
    1079. return true;
    1080. }
    1082. end = 0;
    1083. type = Unknown;
    1084. return false;
    1085. }
    1086. }

    Lexer.cs
    Spoiler anzeigen

    C#-Quellcode

    1. using System.Collections.Concurrent;
    3. namespace CNative;
    5. internal class Lexer
    6. {
    7. private string _src;
    8. public ConcurrentQueue<LexerNode> level1LexerQueue;
    9. public ConcurrentQueue<LexerToken> level2LexerQueue;
    10. public Lexer(string src)
    11. {
    12. _src = src;
    13. }
    15. public async Task AnalyseAsync()
    16. {
    17. level1LexerQueue = new ConcurrentQueue<LexerNode>();
    18. level2LexerQueue = new ConcurrentQueue<LexerToken>();
    20. LexerLevel1 level1 = new LexerLevel1(_src, ref level1LexerQueue);
    21. LexerLevel2 level2 = new LexerLevel2(_src, ref level1LexerQueue, ref level2LexerQueue);
    23. CancellationTokenSource cts = new CancellationTokenSource();
    25. Task level1Task = level1.AnalyseAsync(cts, cts.Token);
    26. Task level2Task = level2.AnalyseAsync(cts.Token);
    28. await level1Task;
    29. await level2Task;
    30. }
    32. private static bool IsAlphabetic(ReadOnlySpan<char> src, int i, out int end)
    33. {
    34. if(src[i] is (>= 'A' and <= 'Z') or (>= 'a' and <= 'z'))
    35. {
    36. end = i + 1;
    37. return true;
    38. }
    40. end = 0;
    41. return false;
    42. }
    43. private static bool IsNumericLiteral(ReadOnlySpan<char> src, int i, out int end)
    44. {
    45. if (src[i] is >= '0' and <= '9')
    46. {
    47. end = i + 1;
    48. return true;
    49. }
    51. end = 0;
    52. return false;
    53. }
    54. }

    Example
    Spoiler anzeigen

    C#-Quellcode

    1. using CNative;
    3. Console.WriteLine("Hello, World!");
    5. string example = @"public static double[,] Transpose(this double[,] self)
    6. {
    7. double[,] trans = new double[self.Cols(), self.Rows()];
    9. for (int row = 0; row < self.Rows(); row++)
    10. {
    11. for (int col = 0; col < self.Cols(); col++)
    12. {
    13. trans[col, row] = self[row, col];
    14. }
    15. }
    17. return trans;
    18. }";
    20. Lexer lexer = new Lexer(example);
    21. await lexer.AnalyseAsync();
    23. ; // break me

Facebook
Telefonspende