static bool
ParseLine(Airspaces &airspace_database, TCHAR *line,
TempAirspaceType &temp_area)
{
const TCHAR *value;
// Strip comments
TCHAR *comment = _tcschr(line, _T('*'));
if (comment != nullptr)
*comment = _T('\0');
// Only return expected lines
switch (line[0]) {
case _T('D'):
case _T('d'):
switch (line[1]) {
case _T('P'):
case _T('p'):
value = ValueAfterSpace(line + 2);
if (value == nullptr)
break;
{
GeoPoint temp_point;
if (!ReadCoords(value, temp_point))
return false;
temp_area.points.push_back(temp_point);
break;
}
case _T('C'):
case _T('c'):
temp_area.radius = Units::ToSysUnit(fixed(_tcstod(&line[2], nullptr)),
Unit::NAUTICAL_MILES);
temp_area.AddCircle(airspace_database);
temp_area.Reset();
break;
case _T('A'):
case _T('a'):
ParseArcBearings(line, temp_area);
break;
case _T('B'):
case _T('b'):
return ParseArcPoints(line, temp_area);
default:
return true;
}
break;
case _T('V'):
case _T('v'):
// Need to set these while in count mode, or DB/DA will crash
if ((value = StringAfterPrefixCI(SkipSpaces(line + 1), _T("X="))) != nullptr) {
if (!ReadCoords(value, temp_area.center))
return false;
} else if (StringAfterPrefixCI(SkipSpaces(line + 1), _T("D=-"))) {
temp_area.rotation = -1;
} else if (StringAfterPrefixCI(SkipSpaces(line + 1), _T("D=+"))) {
temp_area.rotation = +1;
}
break;
case _T('A'):
case _T('a'):
switch (line[1]) {
case _T('C'):
case _T('c'):
value = ValueAfterSpace(line + 2);
if (value == nullptr)
break;
temp_area.AddPolygon(airspace_database);
temp_area.Reset();
temp_area.type = ParseType(value);
break;
case _T('N'):
case _T('n'):
value = ValueAfterSpace(line + 2);
if (value != nullptr)
temp_area.name = value;
break;
case _T('L'):
case _T('l'):
value = ValueAfterSpace(line + 2);
if (value != nullptr)
ReadAltitude(value, temp_area.base);
break;
case _T('H'):
case _T('h'):
value = ValueAfterSpace(line + 2);
if (value != nullptr)
ReadAltitude(value, temp_area.top);
break;
case _T('R'):
case _T('r'):
value = ValueAfterSpace(line + 2);
if (value != nullptr)
temp_area.radio = value;
break;
default:
return true;
}
break;
}
return true;
}
void EditorConfig::ParseConfig(const String &filePath)
{
ClearConfig();
YamlParser *parser = YamlParser::Create(filePath);
if(parser)
{
YamlNode *rootNode = parser->GetRootNode();
if(rootNode)
{
Vector<YamlNode*> &yamlNodes = rootNode->AsVector();
int32 propertiesCount = yamlNodes.size();
for(int32 i = 0; i < propertiesCount; ++i)
{
YamlNode *propertyNode = yamlNodes[i];
if(propertyNode)
{
YamlNode *nameNode = propertyNode->Get("name");
YamlNode *typeNode = propertyNode->Get("type");
YamlNode *defaultNode = propertyNode->Get("default");
if(nameNode && typeNode)
{
String nameStr = nameNode->AsString();
String typeStr = typeNode->AsString();
int32 type = ParseType(typeStr);
if(type)
{
bool isOk = true;
for(uint32 n = 0; n < propertyNames.size(); ++n)
{
if(propertyNames[n] == nameStr)
{
isOk = false;
Logger::Error("EditorConfig::ParseConfig %s ERROR property %d property %s already exists", filePath.c_str(), i, nameStr.c_str());
break;
}
}
if(isOk)
{
properties[nameStr] = new PropertyDescription();
properties[nameStr]->name = nameStr;
properties[nameStr]->type = type;
switch(type)
{
case PT_BOOL:
{
bool defaultValue = false;
if(defaultNode)
{
defaultValue = defaultNode->AsBool();
}
properties[nameStr]->defaultValue.SetBool(defaultValue);
}
break;
case PT_INT:
{
int32 defaultValue = 0;
if(defaultNode)
{
defaultValue = defaultNode->AsInt();
}
properties[nameStr]->defaultValue.SetInt32(defaultValue);
}
break;
case PT_STRING:
{
String defaultValue;
if(defaultNode)
{
defaultValue = defaultNode->AsString();
}
properties[nameStr]->defaultValue.SetString(defaultValue);
}
break;
case PT_FLOAT:
{
float32 defaultValue = 0.0f;
if(defaultNode)
{
defaultValue = defaultNode->AsFloat();
}
properties[nameStr]->defaultValue.SetFloat(defaultValue);
}
break;
case PT_COMBOBOX:
{
int32 defaultValue = 0;
if(defaultNode)
{
defaultValue = defaultNode->AsInt();
}
properties[nameStr]->defaultValue.SetInt32(defaultValue);
YamlNode *comboNode = propertyNode->Get("list");
if(comboNode)
{
Vector<YamlNode*> comboValueNodes = comboNode->AsVector();
int32 comboValuesCount = comboValueNodes.size();
for(int32 i = 0; i < comboValuesCount; ++i)
{
properties[nameStr]->comboValues.push_back(comboValueNodes[i]->AsString());
}
}
}
break;
case PT_COLOR_LIST:
{
int32 defaultValue = 0;
if(defaultNode)
{
defaultValue = defaultNode->AsInt();
}
properties[nameStr]->defaultValue.SetInt32(defaultValue);
YamlNode *colorListNode = propertyNode->Get("list");
if(colorListNode)
{
Vector<YamlNode*> colorListNodes = colorListNode->AsVector();
int32 colorListValuesCount = colorListNodes.size();
for(int32 i = 0; i < colorListValuesCount; ++i)
{
YamlNode* colorNode = colorListNodes[i];
if(!colorNode || colorNode->GetCount() != 4)
continue;
Color color(colorNode->Get(0)->AsFloat()/255.f,
colorNode->Get(1)->AsFloat()/255.f,
colorNode->Get(2)->AsFloat()/255.f,
colorNode->Get(3)->AsFloat()/255.f);
properties[nameStr]->colorListValues.push_back(color);
}
}
}
break;
}
propertyNames.push_back(nameStr);
} //isOk
}
else
{
Logger::Error("EditorConfig::ParseConfig %s ERROR property %d unknown type %s", filePath.c_str(), i, typeStr.c_str());
}
}
else
{
Logger::Error("EditorConfig::ParseConfig %s ERROR property %d type or name is missing", filePath.c_str(), i);
}
}
else
{
Logger::Error("EditorConfig::ParseConfig %s ERROR property %d is missing", filePath.c_str(), i);
}
}
}
// else file is empty - ok, no custom properties
parser->Release();
}
// else file not found - ok, no custom properties
}
CVariant CDBusUtil::ParseType(DBusMessageIter *itr)
{
CVariant value;
const char * string = NULL;
dbus_int32_t int32 = 0;
dbus_uint32_t uint32 = 0;
dbus_int64_t int64 = 0;
dbus_uint64_t uint64 = 0;
dbus_bool_t boolean = false;
double doublev = 0;
int type = dbus_message_iter_get_arg_type(itr);
switch (type)
{
case DBUS_TYPE_OBJECT_PATH:
case DBUS_TYPE_STRING:
dbus_message_iter_get_basic(itr, &string);
value = string;
break;
case DBUS_TYPE_UINT32:
dbus_message_iter_get_basic(itr, &uint32);
value = (uint64_t)uint32;
break;
case DBUS_TYPE_BYTE:
case DBUS_TYPE_INT32:
dbus_message_iter_get_basic(itr, &int32);
value = (int64_t)int32;
break;
case DBUS_TYPE_UINT64:
dbus_message_iter_get_basic(itr, &uint64);
value = (uint64_t)uint64;
break;
case DBUS_TYPE_INT64:
dbus_message_iter_get_basic(itr, &int64);
value = (int64_t)int64;
break;
case DBUS_TYPE_BOOLEAN:
dbus_message_iter_get_basic(itr, &boolean);
value = (bool)boolean;
break;
case DBUS_TYPE_DOUBLE:
dbus_message_iter_get_basic(itr, &doublev);
value = (double)doublev;
break;
case DBUS_TYPE_ARRAY:
DBusMessageIter array;
dbus_message_iter_recurse(itr, &array);
value = CVariant::VariantTypeArray;
do
{
CVariant item = ParseType(&array);
if (!item.isNull())
value.push_back(item);
} while (dbus_message_iter_next(&array));
break;
}
return value;
}
static
int
W16PrintfCore(
PPRINTF_BUFFER pBuffer,
int bMSCompat,
const wchar16_t* pwszFormat,
va_list args
)
{
size_t sLen = 0;
const wchar16_t* pwszPos = pwszFormat;
const wchar16_t* pwszTokenStart = pwszFormat;
unsigned int dwFlags = 0;
unsigned int dwLengthModifier = 0;
unsigned int dwType = 0;
size_t sWidth = 0;
ssize_t iPrecision = -1;
// Enough room for all supported fixed sized types
char szArgBuffer[100];
wchar_t wszArgBuffer[1];
wchar16_t w16szArgBuffer[100];
// Enough room for all supported format specifiers
char szFormatBuffer[20];
char *pszFormatBufferPos = NULL;
while (*pwszPos)
{
if (*pwszPos == '%')
{
pBuffer->pfnWriteWc16s(
pBuffer,
pwszTokenStart,
pwszPos - pwszTokenStart);
pwszPos++;
// Put the format specifier (% included) into a multibyte
// string incase regular printf needs to be called
pszFormatBufferPos = szFormatBuffer;
*pszFormatBufferPos++ = '%';
pwszTokenStart = pwszPos;
dwFlags = ParseFlags(&pwszPos);
// update multibyte format
// subtract for % * . * null
if (pwszPos - pwszTokenStart > sizeof(szFormatBuffer) - 5)
{
errno = ENOMEM;
return -1;
}
sLen = wc16stombs(
pszFormatBufferPos,
pwszTokenStart,
pwszPos - pwszTokenStart);
if (sLen == (size_t)-1)
{
return -1;
}
pszFormatBufferPos += sLen;
if (*pwszPos == '*')
{
pwszPos++;
sWidth = va_arg(args, size_t);
}
else
{
sWidth = (size_t)wc16stoull(pwszPos, &pwszPos, 10);
}
*pszFormatBufferPos++ = '*';
iPrecision = -1;
if (*pwszPos == '.')
{
pwszPos++;
if (*pwszPos == '*')
{
pwszPos++;
iPrecision = va_arg(args, ssize_t);
}
else if (*pwszPos != '-')
{
iPrecision = (ssize_t)wc16stoull(pwszPos, &pwszPos, 10);
}
}
*pszFormatBufferPos++ = '.';
*pszFormatBufferPos++ = '*';
pwszTokenStart = pwszPos;
dwLengthModifier = ParseLengthModifier(&pwszPos);
dwType = ParseType(&pwszPos, &dwType);
if (pszFormatBufferPos - szFormatBuffer +
pwszPos - pwszTokenStart > sizeof(szFormatBuffer) - 1)
{
errno = ENOMEM;
return -1;
}
sLen = wc16stombs(
pszFormatBufferPos,
pwszTokenStart,
pwszPos - pwszTokenStart);
if (sLen == (size_t)-1)
{
return -1;
}
pszFormatBufferPos += sLen;
*pszFormatBufferPos = 0;
if (bMSCompat && (dwType == TYPE_STRING || dwType == TYPE_CHAR))
{
if (dwLengthModifier == LENGTH_LONG)
{
dwLengthModifier = LENGTH_W16CHAR_T;
}
else if (dwLengthModifier == LENGTH_SHORT)
{
dwLengthModifier = LENGTH_CHAR;
}
else
{
if (dwFlags & FLAG_UPPER_CASE)
{
dwLengthModifier = LENGTH_CHAR;
}
else
{
dwLengthModifier = LENGTH_W16CHAR_T;
}
}
}
switch (dwType)
{
case TYPE_OCTAL:
case TYPE_UNSIGNED_INTEGER:
case TYPE_HEX:
case TYPE_INTEGER:
if (dwLengthModifier == LENGTH_LONG_LONG)
{
long long llArg = va_arg(args, long long);
sLen = snprintf(
szArgBuffer,
sizeof(szArgBuffer),
szFormatBuffer,
sWidth,
iPrecision,
llArg);
}
else
{
long lArg = va_arg(args, long);
sLen = snprintf(
szArgBuffer,
sizeof(szArgBuffer),
szFormatBuffer,
sWidth,
iPrecision,
lArg);
}
if (sLen > sizeof(szArgBuffer) || (ssize_t) sLen < 0)
{
errno = ENOMEM;
return -1;
}
pBuffer->pfnWriteMbs(pBuffer, szArgBuffer, sLen);
break;
case TYPE_DOUBLE:
case TYPE_AUTO_DOUBLE:
case TYPE_HEX_DOUBLE:
case TYPE_SCIENTIFIC:
if (dwLengthModifier == LENGTH_LONG_DOUBLE)
{
long double ldArg = va_arg(args, long double);
sLen = snprintf(
szArgBuffer,
sizeof(szArgBuffer),
szFormatBuffer,
sWidth,
iPrecision,
ldArg);
}
ExprNode* Parser :: ParseFactor(){
ExprNode *root = nullptr;
Token *token = scan.Get();
if(isEq(token, _SEPARATION, ";"))
return 0;
switch (token->Type){
case _INTEGER:
root = new IntNode(token);
break;
case _FLOAT:
root = new FloatNode(token);
break;
case _IDENTIFIER:
{
Symbol *sym = symStack->find_symbol(token->Value);
if(!sym && parsingFunc)
sym = parsingFunc->params->find_symbol(token->Value);
string exc = "Identifier \"" + token->Value + "\" not defined";
errorIf(!sym, exc.c_str(), token);
errorIf(!dynamic_cast<VarSymbol*>(sym) && !dynamic_cast<FuncSymbol*>(sym), "Unknown symbol", token);
errorIf(!sym, "Identifier is undefined", token);
root = new IdentifierNode(token, dynamic_cast<VarSymbol*>(sym));
if (dynamic_cast<PointerSymbol*>(sym->getType()))
root = new PointerNode(root);
if(isEq(scan.GetNext() ,_SEPARATION ,"("))
root = ParseFuncCall(root);
//scan.Next();
return root;
}
case _CHAR:
root = new CharNode(token);
break;
case _STRING:
root = new StringNode(token);
root->SetIndex(++index);
stringConsts.push_back(dynamic_cast<StringNode*>(root));
break;
case _KEYWORD:
{
string kw = token->Value;
if(kw == "printf" || kw == "scanf"){
errorIf( scan.GetNext()->Value != "(", "Open bracket expected", token);
scan.Next();
StringNode *format = dynamic_cast<StringNode*>(ParseExpr(priorityTable[","] + 1));
errorIf(!format, "Expected string format", token);
IONode *node = new IONode(dynamic_cast<Token*>(token), format);
if(scan.Get()->Value == ","){
scan.Next();
while(true){
ExprNode *arg = ParseExpr(priorityTable[","] + 1);
errorIf (!arg, "Argument expected", token);
node->addArg(arg);
if(scan.Get()->Value == ")")
break;
if(scan.Get()->Value == ",")
scan.Next();
}
}
scan.Next();
root = node;
}
else if(kw == "char" || kw == "int" || kw == "float"){
// scan.Next();
SymbolType* type = ParseType();
errorIf(isEq(scan.Get(), _SEPARATION, "("), "Expected open bracket '('", token);
scan.Next();
root = new CastNode(token, ParseExpr(), type);
// errorIf((isEq(scan.GetNext(), _SEPARATION, ")") && !scan.isEnd()), "Expected closing bracket", token);
}
else
throw MyException("You can use keywords just such as char, int and float in expressions");
}
break;
case _OPERATION:
if (token->Value == "*"){
scan.Next();
auto temp = ParseExpr(priorityTable["--"]);
// if (dynamic_cast<PointerNode*>(temp))
// root = dynamic_cast<PointerNode*>(temp)->name;
// root = temp;
// else
root = new PointerNode(temp);
}else
if(unary[token->Value]){
scan.Next();
root = new UnOpNode(token, ParseExpr(priorityTable["--"]));
} else
throw MyException("Wrong expression", token);
break;
case _SEPARATION :
if(isEq(scan.Get(), _SEPARATION, "(")){
scan.Next();
root = ParseExpr();
if(dynamic_cast<CastNode*>(root)){
return root;
}
if(!isEq(scan.Get(), _SEPARATION, ")"))
throw MyException("Expected closing bracket");
}
else
throw MyException("Wrong expression", token);
break;
}
if (!(token->Type == _OPERATION && unary[token->Value]) && token->Value != "printf" && token->Value != "scanf")
scan.Next();
root->getType();
return root;
}
SymProc* Parser::ProcFunc(bool isFunc)
{
t = sc.GetNextToken();
SymType* Type = NULL;
SymProc* sub = NULL;
if (t.GetType() != identifier)
throw Error("incorrect procedure name", t);
SymTable* argTable = NULL;
vector<string>* argNames = new vector<string>;
_Table::iterator it = table->find(t.GetValue());
string name = t.GetValue();
t = sc.GetNextToken();
argTable = ParseArguments(argNames);
TableStack.PushTable(argTable);
if (isFunc)
{
if (t.GetValue() != ":")
throw Error("type expected", t);
Type = ParseType(false);
t = sc.GetNextToken();
}
t = RequireToken(";", "\";\" expected");
if (it != table->end())
{
if (!(it->second->IsProc()) || !(((SymProc*)it->second)->IsForward()))
throw Error("incorrect procedure definition", t);
SymTable* argTableF = ((SymProc*)it->second)->GetArgTable();
vector<string>* argNamesF = ((SymProc*)it->second)->GetArgNames();
for (size_t i=0; i<argNames->size(); ++i)
{
if ((*argNames)[i] != (*argNamesF)[i] ||
!SymComp(argTable->find((*argNames)[i])->second , argTableF->find((*argNamesF)[i])->second))
throw Error("Header does not match previouse definition", t);
}
if (isFunc)
sub = ParseProcDecl(name, argNames, argTable, true, Type);
else
sub = ParseProcDecl(name, argNames, argTable, false, Type);
t = RequireToken(";", "\";\" expected");
}
else
{
if (t.GetValue() == "forward")
{
t = sc.GetNextToken();
if (t.GetValue() != ";")
throw Error("\";\" expected", t);
if (isFunc)
{
sub = new SymFunc(name, argNames, argTable, NULL, true, NULL);
((SymFunc*)sub)->SetType(Type);
}
else
sub = new SymProc(name, argNames, argTable, NULL, true);
sub->print(os, false);
table->insert(pair<string, SymProc*> (name, sub));
TableStack.PopTable();
}
else
{
sub = ParseProcDecl(name, argNames, argTable, isFunc, Type);
if (isFunc)
((SymFunc*)sub)->SetType(Type);
sub->GetBody()->print(os, 0);
}
t = sc.GetNextToken();
}
return sub;
}
ExprNode* Parser :: ParseDeclaration(SymbolType* sym_type){
if (isEq(scan.Get(), _SEPARATION, ";")){
scan.Next();
return nullptr;
}
SymbolType* t_symbol;
if (!sym_type) {
t_symbol = ParseType();
}else
t_symbol = sym_type;
VarSymbol* var = nullptr;
BinOpNode *node = nullptr;
while(true){
Token *token;
token = scan.Get();
if(isEq(token, _SEPARATION, ";" )&& (t_symbol->isStruct() || dynamic_cast<TypedefSymbol*>(t_symbol)))
break;
if (isEq(scan.Get(), _SEPARATION,"("))
var = ParseComplexDeclaration(t_symbol);
else
var = ParseIdentifier(t_symbol);
if(symStack->tables.back()->find_symbol(var->name) == 0)
symStack->add_symbol(var);
if(isEq(scan.Get(), _OPERATION, "=")){
Token *asgn = scan.Get();
scan.Next();
ExprNode* Assing_operand = ParseExpr(priorityTable[","] + 1);
node = new BinOpNode(asgn, new IdentifierNode(token, var), Assing_operand);
if(dynamic_cast<ConstSymbolType*> (var->getType()))
errorIf(!var->getType()->getType()->canConvertTo(node->right->getType()),"Cannot perform conversion",scan.Get() );
else
node->getType();
blocks.top()->AddStatement(node);
}
if(isEq(scan.Get() ,_SEPARATION, ";") || isEq(scan.Get() ,_SEPARATION, "{"))
break;
errorIf(!isEq(scan.Get(), _OPERATION, ","), "Comma Expected");
scan.Next();
}
if(isEq (scan.Get(),_SEPARATION,"{")){
FuncSymbol *func = dynamic_cast<FuncSymbol*>(var->type);
errorIf(!func, "Unexpected brace", scan.Get());
errorIf((symStack->tables.size() != 1), "Can not define the function in the block", scan.Get());
parsingFunc = func;
func->body = ParseBlock();
parsingFunc = 0;
CheckReturn(func);
if(func->name == "main")
main_func = func;
scan.Next();
}
else
scan.Next();
return node;
}
static bool
ParseLine(Airspaces &airspace_database, const TCHAR *line,
TempAirspaceType &temp_area)
{
const TCHAR *value;
// Only return expected lines
switch (line[0]) {
case _T('A'):
case _T('a'):
switch (line[1]) {
case _T('C'):
case _T('c'):
value = value_after_space(line + 2);
if (value == NULL)
break;
if (!temp_area.Waiting)
temp_area.AddPolygon(airspace_database);
temp_area.reset();
temp_area.Type = ParseType(value);
temp_area.Waiting = false;
break;
case _T('N'):
case _T('n'):
value = value_after_space(line + 2);
if (value != NULL)
temp_area.Name = value;
break;
case _T('L'):
case _T('l'):
value = value_after_space(line + 2);
if (value != NULL)
ReadAltitude(value, &temp_area.Base);
break;
case _T('H'):
case _T('h'):
value = value_after_space(line + 2);
if (value != NULL)
ReadAltitude(value, &temp_area.Top);
break;
default:
return true;
}
break;
case _T('D'):
case _T('d'):
switch (line[1]) {
case _T('A'):
case _T('a'):
CalculateSector(line, temp_area);
break;
case _T('B'):
case _T('b'):
CalculateArc(line, temp_area);
break;
case _T('C'):
case _T('c'):
temp_area.Radius = Units::ToSysUnit(fixed(_tcstod(&line[2], NULL)),
unNauticalMiles);
temp_area.AddCircle(airspace_database);
temp_area.reset();
break;
case _T('P'):
case _T('p'):
value = value_after_space(line + 2);
if (value == NULL)
break;
{
GeoPoint TempPoint;
if (!ReadCoords(value, TempPoint))
return false;
temp_area.points.push_back(TempPoint);
break;
}
default:
return true;
}
break;
case _T('V'):
case _T('v'):
// Need to set these while in count mode, or DB/DA will crash
if (string_after_prefix_ci(&line[2], _T("X="))) {
if (!ReadCoords(&line[4],temp_area.Center))
return false;
} else if (string_after_prefix_ci(&line[2], _T("D=-"))) {
temp_area.Rotation = -1;
} else if (string_after_prefix_ci(&line[2], _T("D=+"))) {
temp_area.Rotation = +1;
}
}
return true;
}
DeclaracionFuncion* Sintactico::ParseFunctionDeclaration()
{
if ( proximo_token.GetTipo() == kw_procedimiento )
{
proximo_token = analizador_lexico->ObtenerSiguienteToken();
if ( proximo_token.GetTipo() == id )
{
string nom_procedimiento = proximo_token.GetLexema();
proximo_token = analizador_lexico->ObtenerSiguienteToken();
InformacionSemantica::GetInstance()->SetContexto(nom_procedimiento);
InformacionInterpretacion::GetInstance()->SetContexto(nom_procedimiento);
list<Parametro*> lista_params = ParseProcedureParam();
ListaVariables* lista_vars = ParseVariableDeclarations();
Sentencia* cuerpo_funcion = ParseCompoundStatement();
//PENDIENTE: Verificar si es correcto
list<Parametro*>::iterator it = lista_params.begin();
for ( ; it != lista_params.end() ; it++ )
{
lista_vars->insert((*it)->GetNombre(),(*it)->GetTipo() );
}
InformacionInterpretacion::GetInstance()->InicializarVariables(nom_procedimiento,lista_vars);
return new DeclaracionFuncion(nom_procedimiento,lista_params,cuerpo_funcion,NULL);
}
else
throw SyntaxException("No se encontro un id valido",analizador_lexico->GetLineaActual());
}
else if ( proximo_token.GetTipo() == kw_funcion )
{
proximo_token = analizador_lexico->ObtenerSiguienteToken();
if ( proximo_token.GetTipo() == id )
{
string nom_funcion = proximo_token.GetLexema();
proximo_token = analizador_lexico->ObtenerSiguienteToken();
list<Parametro*>lista_params = ParseFunctionParam();
Tipo* t = ParseType();
if ( proximo_token.GetTipo() == punt_puntocoma )
{
proximo_token = analizador_lexico->ObtenerSiguienteToken();
InformacionSemantica::GetInstance()->SetContexto( nom_funcion );
InformacionInterpretacion::GetInstance()->SetContexto(nom_funcion);
ListaVariables* lista_vars = ParseVariableDeclarations();
Sentencia* cuerpo_funcion = ParseCompoundStatement();
list<Parametro*>::iterator it = lista_params.begin();
for ( ; it != lista_params.end() ; it++ )
{
lista_vars->insert((*it)->GetNombre(),(*it)->GetTipo() );
}
InformacionSemantica::GetInstance()->InsertarVarEnContexto(nom_funcion,nom_funcion,t);
//lista_vars->insert(nom_funcion,t);
InformacionInterpretacion::GetInstance()->InicializarVariables(nom_funcion,lista_vars);
return new DeclaracionFuncion(nom_funcion,lista_params,cuerpo_funcion,t);
}
else
throw SyntaxException("Falta un punto y coma",analizador_lexico->GetLineaActual());
}
else
throw SyntaxException("Falta el id",analizador_lexico->GetLineaActual());
}
else
throw SyntaxException("Se esperaba una declaracion de funcion o procedimiento",analizador_lexico->GetLineaActual());
//InformacionInterpretacion::GetInstance()->SetContexto("@GLOBAL");
}
Tipo* Sintactico::ParseType()
{
switch ( proximo_token.GetTipo() )
{
case id:
{
string nom_tipo = proximo_token.GetLexema();
proximo_token = analizador_lexico->ObtenerSiguienteToken();
map<string,Tipo*>tablaTipos = InformacionSemantica::GetInstance()->GetTablaTipos();
map<string,Tipo*>::iterator it;
it = tablaTipos.find(nom_tipo);
if ( it == tablaTipos.end() )
throw SemanticException("El tipo " +nom_tipo+" no esta definido");
return it->second;
}
case kw_array:
proximo_token = analizador_lexico->ObtenerSiguienteToken();
if ( proximo_token.GetTipo() == punt_corchizq )
{
proximo_token = analizador_lexico->ObtenerSiguienteToken();
list<LimitesRango*> dim_list = ParseDimensionList();
if ( proximo_token.GetTipo() == punt_corchder )
{
proximo_token = analizador_lexico->ObtenerSiguienteToken();
if ( proximo_token.GetTipo() == kw_of )
{
proximo_token = analizador_lexico->ObtenerSiguienteToken();
Tipo* t = ParseType();
return new Arreglo(dim_list,t);
}
else
throw SyntaxException("No se encontro la kw OF",analizador_lexico->GetLineaActual());
}
else
throw SyntaxException("No se encontro el token de corchete derecho",analizador_lexico->GetLineaActual());
}
else
throw SyntaxException("No se encontro el token de corchete izquierdo",analizador_lexico->GetLineaActual());
break;
case kw_record:
{
proximo_token = analizador_lexico->ObtenerSiguienteToken();
ListaVariables* lista_var = ParseVariableDeclarationList();
if ( proximo_token.GetTipo() == kw_end )
proximo_token = analizador_lexico->ObtenerSiguienteToken();
else
throw SyntaxException("No se encontro la kw END",analizador_lexico->GetLineaActual());
return new Registro(lista_var);
}
case kw_entero:
{
proximo_token = analizador_lexico->ObtenerSiguienteToken();
map<string,Tipo*>tablaTipos = InformacionSemantica::GetInstance()->GetTablaTipos();
map<string,Tipo*>::iterator it;
it = tablaTipos.find("INTEGER");
return it->second;
}
case kw_real:
{
proximo_token = analizador_lexico->ObtenerSiguienteToken();
map<string,Tipo*>tablaTipos = InformacionSemantica::GetInstance()->GetTablaTipos();
map<string,Tipo*>::iterator it;
it = tablaTipos.find("REAL");
return it->second;
}
case kw_string:
{
proximo_token = analizador_lexico->ObtenerSiguienteToken();
map<string,Tipo*>tablaTipos = InformacionSemantica::GetInstance()->GetTablaTipos();
map<string,Tipo*>::iterator it;
it = tablaTipos.find("STRING");
return it->second;
}
case kw_bool:
{
proximo_token = analizador_lexico->ObtenerSiguienteToken();
map<string,Tipo*>tablaTipos = InformacionSemantica::GetInstance()->GetTablaTipos();
map<string,Tipo*>::iterator it;
it = tablaTipos.find("BOOLEAN");
return it->second;
}
case kw_char:
{
proximo_token = analizador_lexico->ObtenerSiguienteToken();
map<string,Tipo*>tablaTipos = InformacionSemantica::GetInstance()->GetTablaTipos();
map<string,Tipo*>::iterator it;
it = tablaTipos.find("CHAR");
return it->second;
}
default:
throw SyntaxException("Token de tipo invalido",analizador_lexico->GetLineaActual());
}//FIN switch
}
asCScriptNode *asCParser::ParseParameterList()
{
asCScriptNode *node = new asCScriptNode(snParameterList);
sToken t1;
GetToken(&t1);
if( t1.type != ttOpenParanthesis )
{
Error(ExpectedToken("("), &t1);
return node;
}
node->UpdateSourcePos(t1.pos, t1.length);
GetToken(&t1);
if( t1.type == ttCloseParanthesis )
{
node->UpdateSourcePos(t1.pos, t1.length);
// Statement block is finished
return node;
}
else
{
RewindTo(&t1);
for(;;)
{
// Parse data type
node->AddChildLast(ParseType(true));
if( isSyntaxError ) return node;
node->AddChildLast(ParseTypeMod(true));
if( isSyntaxError ) return node;
// Parse identifier
GetToken(&t1);
if( t1.type == ttIdentifier )
{
RewindTo(&t1);
node->AddChildLast(ParseIdentifier());
if( isSyntaxError ) return node;
GetToken(&t1);
}
// Check if list continues
if( t1.type == ttCloseParanthesis )
{
node->UpdateSourcePos(t1.pos, t1.length);
return node;
}
else if( t1.type == ttListSeparator )
continue;
else
{
Error(ExpectedTokens(")", ","), &t1);
return node;
}
}
}
return 0;
}
