1 | #include <content_xml.hpp>
|
2 | #include <Parser.hpp>
|
3 | #include <stdint.h>
|
4 | #include <stdlib.h>
|
5 | #include <string.h>
|
6 |
|
7 | using namespace std;
|
8 |
|
9 | extern volatile uint32_t Memory[1024];
|
10 |
|
11 |
|
12 | void ParserChar(char *ptr, uint16_t Len){
|
13 | //...
|
14 | }
|
15 |
|
16 | void ParserMem(uint32_t *ptr){
|
17 | //...
|
18 | }
|
19 |
|
20 |
|
21 | uint8_t StartParserXml(char *ptr, uint16_t Len){
|
22 | //...
|
23 | return 1;
|
24 | }
|
25 |
|
26 | uint8_t StartParserByte(uint32_t *ptr){
|
27 | //...
|
28 | return 1;
|
29 | }
|
30 |
|
31 | ClContent_xml** contentAdd(uint16_t inkrement){
|
32 | //...
|
33 | }
|
34 |
|
35 | uint8_t StartCheckXml(void){
|
36 | //...
|
37 | return 1;
|
38 | }
|
39 |
|
40 | uint8_t StartGenerateByte(uint32_t* ptr, uint16_t MaxLen){
|
41 | //...
|
42 | return 1;
|
43 | }
|
44 |
|
45 | uint32_t getByte(uint16_t i){
|
46 | //...
|
47 | return Value;
|
48 | }
|
49 |
|
50 | uint8_t NumData(char* ptr){
|
51 | //...
|
52 | return Nummer;
|
53 | }
|
54 |
|
55 | uint8_t IsNumeric(char* ptr){
|
56 | //...
|
57 | return 0;
|
58 | }
|
59 |
|
60 | uint8_t strToU8(char* ptr){
|
61 | //...
|
62 | return Val;
|
63 | }
|
64 |
|
65 | uint16_t strToU16(char* ptr){
|
66 | //...
|
67 | }
|
68 |
|
69 | uint32_t strToU32(char* ptr){
|
70 | //...
|
71 | return Val;
|
72 | }
|
73 |
|
74 | uint32_t strXToU32(char* ptr){
|
75 | //...
|
76 | return Val;
|
77 | }
|
78 |
|
79 | uint16_t* strToU16Array(char* ptr){
|
80 | uint16_t Val = 0;
|
81 | uint8_t Num = 0;
|
82 | uint8_t st = 0;
|
83 | uint16_t *Array, *LArray;
|
84 | char *Sptr;
|
85 | Sptr = ptr;
|
86 |
|
87 | // Anzahl der Zahlen ermitteln
|
88 | do{
|
89 | switch(*ptr){
|
90 | case '0':
|
91 | case '1':
|
92 | case '2':
|
93 | case '3':
|
94 | case '4':
|
95 | case '5':
|
96 | case '6':
|
97 | case '7':
|
98 | case '8':
|
99 | case '9':
|
100 | if((st & 0x02) == 0x00){
|
101 | Num++;
|
102 | st |= 0x02;
|
103 | }
|
104 | break;
|
105 | case ' ':
|
106 | case ',':
|
107 | if((st & 0x02) == 0x02){
|
108 | st = (st & ~0x02);
|
109 | }
|
110 | break;
|
111 | default:
|
112 | st |= 0x01;
|
113 | break;
|
114 | }
|
115 | ptr++;
|
116 | }while((st & 0x01) == 0);
|
117 |
|
118 | Array = new uint16_t[Num];
|
119 | LArray = Array;
|
120 |
|
121 | for(uint8_t i = 0; i < Num; i++){
|
122 | while((*Sptr == ' ') || (*Sptr == ',')){
|
123 | Sptr++;
|
124 | }
|
125 |
|
126 | *LArray = strToU16(Sptr);
|
127 |
|
128 | //printf("\n%i, Wert: %i, Adresse: 0x%x", i, *LArray, LArray);
|
129 |
|
130 | while(IsNumeric(Sptr)){
|
131 | Sptr++;
|
132 | }
|
133 | LArray++;
|
134 | }
|
135 | return Array;
|
136 | }
|
137 |
|
138 | uint32_t* strToU32Array(char* ptr, uint8_t Num){
|
139 | uint32_t Val = 0;
|
140 | uint8_t st = 0;
|
141 | uint32_t *Array, *LArray;
|
142 | char *Sptr;
|
143 | Sptr = ptr;
|
144 |
|
145 | Array = new uint32_t[Num];
|
146 | LArray = Array;
|
147 |
|
148 | for(uint8_t i = 0; i < Num; i++){
|
149 | // Leerzeichen ignurieren
|
150 | while(*ptr == ' '){
|
151 | ptr++;
|
152 | }
|
153 | if(1 == IsNumeric(ptr)){
|
154 | *LArray = strToU32(ptr);
|
155 | LArray++;
|
156 | do{
|
157 | ptr++;
|
158 | }while(1 == IsNumeric(ptr));
|
159 | }
|
160 | else{
|
161 | return Array;
|
162 | }
|
163 | }
|
164 | return Array;
|
165 | }
|
166 |
|
167 | uint32_t* strXToU32Array(char* ptr, uint8_t Num){
|
168 | uint32_t Val = 0;
|
169 | uint8_t st = 0;
|
170 | uint32_t *Array, *LArray;
|
171 |
|
172 | Array = new uint32_t[Num];
|
173 | LArray = Array;
|
174 |
|
175 | for(uint8_t i = 0; i < Num; i++){
|
176 | // Leerzeichen ignurieren
|
177 | while((*ptr == ' ') || (*ptr == ',')){
|
178 | ptr++;
|
179 | }
|
180 |
|
181 | if((1 == IsNumeric(ptr))){
|
182 | *LArray = strXToU32(ptr);
|
183 | LArray++;
|
184 | do{
|
185 | ptr++;
|
186 | }while((1 == IsNumeric(ptr)) || (*ptr == 'x') || (*ptr == 'X'));
|
187 | }
|
188 | else{
|
189 | return Array;
|
190 | }
|
191 | }
|
192 | return Array;
|
193 | }
|
194 |
|
195 | uint16_t setByteU8(uint8_t Value, uint16_t Inkrement){
|
196 | //...
|
197 | return Inkrement + 1;
|
198 | }
|
199 |
|
200 | uint16_t setByteU16(uint16_t Value, uint16_t Inkrement){
|
201 | //...
|
202 | return Inkrement + 2;
|
203 | }
|
204 |
|
205 | uint16_t setByteU32(uint32_t Value, uint16_t Inkrement){
|
206 | //...
|
207 | return Inkrement + 4;
|
208 | }
|
209 |
|
210 | uint16_t setByte(void){
|
211 | // MemByte in das Flash schreiben
|
212 | return 0;
|
213 | }
|
