public HttpHelper(string token, string deviceRegToken) => InitClient(token, deviceRegToken);
private void analizeCode() { pile.Add("E"); //treeSyntactic = new Tree("E"); treeSyntactic = new TreeAS("E"); this.numberOfToken = 0; while (this.pile.Count > 0) { int pileSize = this.pile.Count(); String lastInPile = this.pile[pileSize - 1]; token tokenR = this.pileTokens[numberOfToken]; String tokenRequired = tokenR.getName(); if (namesNoTerminal.Contains(lastInPile)) { Boolean isError = true; foreach (RowSA row in this.tableSA) { String nameNoTerminal = row.getRow(); String column = row.getCol(); if (column == tokenRequired && nameNoTerminal == lastInPile) { //añadir a la pila el valor pile.RemoveAt(pileSize - 1); String values = row.getVal(); addDiferentsToPile(values); //treeSyntactic.setValues(values); if (this.numberErrors == 0) { treeSyntactic.setNoTerminal(nameNoTerminal, tokenR); } isError = false; break; } } if (isError == true) { if (lastInPile != "Q'") { addError("Error sintactico", tokenR.getRow().ToString()); } pile.RemoveAt(pileSize - 1); } } else { //el ultimo en la pila no es un no terminal if (lastInPile == "reduce") { pile.RemoveAt(pileSize - 1); } else { if (lastInPile == tokenRequired) { if (this.numberErrors == 0) { treeSyntactic.setNode(tokenR); } pile.RemoveAt(pileSize - 1); this.numberOfToken++; } else { pile.RemoveAt(pileSize - 1); addError("Se esperaba: " + lastInPile, tokenR.getRow().ToString()); } } } } this.form1.setTreeAS((object)this.treeSyntactic); if (this.numberErrors == 0) { setPrintAndReadInErrors(); } //CreateTreeFile createtree = new CreateTreeFile(this.treeSyntactic);//this.treeSyntactic //TODO Crear arbol, crear grafico }
/* |---------------------------------------------- | Ejecutando Constructor Heredado |---------------------------------------------- */ public void ejecutarConstructorHeredado(lstValores parametros, elementoEntorno tablaEntorno, token linea) { cuerpoClase.lstConstructoresHeredados.ejecutarConstructorHeredad(parametros, tablaEntorno, linea); }
where !string.IsNullOrEmpty(token) let split = token.Split(':', 2)
public scanner(source source = default, ulong mode = default, bool nlsemi = default, ulong line = default, ulong col = default, bool blank = default, token tok = default, @string lit = default, bool bad = default, LitKind kind = default, Operator op = default, long prec = default) { this.source = source; this.mode = mode; this.nlsemi = nlsemi; this.line = line; this.col = col; this.blank = blank; this.tok = tok; this.lit = lit; this.bad = bad; this.kind = kind; this.op = op; this.prec = prec; }
return(new RepeatingToken(token, mm.min, mm.max));
GetColoredText(token, None);
private bool tokenizer() { token newtoken = new token(); tokens.Clear(); int idCount = 0; foreach (String nLexemes in lexemes) { if (isKeyword(nLexemes)) { newtoken = new token(nLexemes, "Keyword"); tokens.AddLast(newtoken); } else if (isOperator(nLexemes)) { newtoken = new token(nLexemes, "Operator"); tokens.AddLast(newtoken); } else if (isRelop(nLexemes)) { newtoken = new token(nLexemes, "RelOp"); tokens.AddLast(newtoken); } else if (isPunctuation(nLexemes)) { newtoken = new token(nLexemes, "Punctuation"); tokens.AddLast(newtoken); } else if (isNumber(nLexemes)) { newtoken = new token(nLexemes, "NUM"); tokens.AddLast(newtoken); } else if (nLexemes == terminator) { newtoken = new token(nLexemes, "Terminator"); tokens.AddLast(newtoken); } else if (isLiteral(nLexemes)) { newtoken = new token(nLexemes, "Literals"); tokens.AddLast(newtoken); } else if (isId(nLexemes)) { // using System.CodeDom.Compiler; CodeDomProvider provider = CodeDomProvider.CreateProvider("C#"); if (provider.IsValidIdentifier(nLexemes)) { int i = 0; foreach (Identifiers id in identifier) { if (id.identifierName == nLexemes) { newtoken = new token(id.identifierName, id.identifierToken); i = 1; } } if (i == 0) { Identifiers newId = new Identifiers(nLexemes, "ID" + idCount); newtoken = new token(nLexemes, "ID" + idCount); identifier.AddLast(newId); idCount++; } tokens.AddLast(newtoken); } else { MessageBox.Show("Invalid Identifier: " + nLexemes); } } else { toolStripStatusLabel1.Text = "Invalid Token"; } } return(true); }
private static List <token> HandleDirectives(List <token> tokens, Dictionary <string, List <token> > defines, Program.IncludeFileLocator file_locator) { List <token> ret = new List <token>(); if (tokens == null) { return(ret); } for (int i = 0; i < tokens.Count; i++) { token tok = tokens[i]; if (tok.type == token.token_type.preprocessor_directive) { string directive = tok.directive; if (directive == "#include") { HandleInclude(ret, tokens, i, defines, file_locator); } else if (directive == "#if") { HandleIf(ret, tokens, i, defines, file_locator); } else if (directive == "#ifdef") { HandleIfDef(ret, tokens, i, defines, file_locator); } else if (directive == "#define") { HandleDefine(ret, tokens, i, defines, file_locator); } else if (directive == "#error") { HandleError(ret, tokens, i, defines, file_locator); } else if (directive == "#warning") { HandleWarning(ret, tokens, i, defines, file_locator); } else if (directive == "#pragma") { HandlePragma(ret, tokens, i, defines, file_locator); } else if (directive == "#ifndef") { HandleIfndef(ret, tokens, i, defines, file_locator); } else { throw new Exception("Unsupported preprocessor directive: " + tok.value); } } else { if ((tok.type == token.token_type.identifier) && defines.ContainsKey(tok.value)) { ret.AddRange(defines[tok.value]); } else { ret.Add(tok); } } } return(ret); }
private static List <token> Tokenize(string spliced_lines) { /* The tokenizer tries to identify various preprocessor tokens, in a * greedy manner (i.e. it attempts to match the longest possible token * first) */ StringBuilder cur_str = new StringBuilder(); List <token> ret = new List <token>(); int i = 0; while (i < spliced_lines.Length) { if (IsWhitespace(spliced_lines[i])) { if (cur_str.ToString() != "") { string identifier = cur_str.ToString(); if (((identifier[0] == '.') && (IsDigit(identifier[1]))) || (IsDigit(identifier[0]))) { ret.Add(new token { type = token.token_type.number, value = identifier }); } else { ret.Add(new token { type = token.token_type.identifier, value = identifier }); } } cur_str = new StringBuilder(); i++; continue; } List <token> matched_tokens = new List <token>(); foreach (token_match tok_match in tokens) { token tok = MatchToken(spliced_lines, i, tok_match); if (tok != null) { matched_tokens.Add(tok); } } if (matched_tokens.Count > 0) { if (cur_str.ToString() != "") { string identifier = cur_str.ToString(); if (((identifier[0] == '.') && (IsDigit(identifier[1]))) || (IsDigit(identifier[0]))) { ret.Add(new token { type = token.token_type.number, value = identifier }); } else { ret.Add(new token { type = token.token_type.identifier, value = identifier }); } } cur_str = new StringBuilder(); // identify the longest token token largest = null; int largest_length = -1; foreach (token matched_token in matched_tokens) { if (matched_token.value.Length > largest_length) { largest = matched_token; largest_length = matched_token.value.Length; } } ret.Add(largest); i += largest_length; } else { cur_str.Append(spliced_lines[i]); i++; } } return(ret); }
public itemEntorno getDestino(elementoEntorno elementoEntorno, itemValor item) { itemEntorno retorno = null; if (hayErrores()) { return(retorno); } if (item.isTypeObjeto()) { if (lstAtributos.listaAtributos.Count == 2) { if (hijos.Count > 0) /* |---------------------------- | sPunto + valId + LST_CORCHETES_VAL */ { objetoClase tempObjeto = item.getObjeto(); String item1 = lstAtributos.listaAtributos[1].nombretoken; token nombreVar = lstAtributos.getToken(1); if (item1.Equals("valId")) { _LST_CORCHETES_VAL lstCorchetes = (_LST_CORCHETES_VAL)getNodo("LST_CORCHETES_VAL"); return(getEntornoId(lstAtributos.listaAtributos[1].tok, tempObjeto.tablaEntorno.raiz, lstCorchetes.getLstInt(elementoEntorno, nombreVar))); } } else /* |---------------------------- | sPunto + valId */ { objetoClase tempObjeto = item.getObjeto(); String item1 = lstAtributos.listaAtributos[1].nombretoken; token nombreVar = lstAtributos.getToken(1); if (item1.Equals("valId")) { _LST_CORCHETES_VAL lstCorchetes = (_LST_CORCHETES_VAL)getNodo("LST_CORCHETES_VAL"); return(getEntornoId(lstAtributos.listaAtributos[1].tok, tempObjeto.tablaEntorno.raiz, new List <int>())); } } } else if (lstAtributos.listaAtributos.Count == 4) { if (hijos.Count == 2) /* |---------------------------- | sPunto + valId + sAbreParent + LST_VAL + sCierraParent + LST_CORCHETES_VAL */ { tablaSimbolos.tablaErrores.insertErrorSemantic("No se le puede asignar un valor a la expresión metodo" + lstAtributos.getToken(1).val + "()[]", lstAtributos.getToken(1)); } else if (hijos.Count == 1) { if (hijos[0].nombre.Equals("LST_VAL")) /* |---------------------------- | sPunto + valId + sAbreParent + LST_VAL + sCierraParent */ { tablaSimbolos.tablaErrores.insertErrorSemantic("No se le puede asignar un valor a la expresión metodo" + lstAtributos.getToken(1).val + "()", lstAtributos.getToken(1)); } } } } else { tablaSimbolos.tablaErrores.insertErrorSyntax("[objeto.objeto]El atributo/arreglo/metodo al que se quiere acceder no es de tipo objeto", new token()); } return(null); }
public IHttpActionResult ConnectToFacebook(LoginModel user) { if (!_cache.Contains("tokenFB")) { return(BadRequest("First login in facebook")); } dynamic tokenFB = _cache["tokenFB"]; _cache.Remove("tokenFB"); if (!ModelState.IsValid) { return(BadRequest(ModelState)); } string hashedPassword = Auth.HashPassword(user.Password); List <user> users = _db.user.Where(x => x.login == user.Login && x.password == hashedPassword).ToList(); if (users.Count != 1) { return(ResponseMessage(Request.CreateErrorResponse(HttpStatusCode.Unauthorized, "Invalid login or password"))); } FacebookProvider fbProvider = new FacebookProvider(); string tokenValue = tokenFB.access_token; TimeSpan expire = TimeSpan.FromSeconds(Double.Parse(tokenFB.expires_in.ToString())); dynamic userDataFB = fbProvider.GetUserData(tokenValue); string email = userDataFB.email; using (DbContextTransaction dbtransaction = _db.Database.BeginTransaction()) { try { user userFromDB = users.First(); userFromDB.mailFB = email; _db.user.Attach(userFromDB); _db.Entry(userFromDB).State = EntityState.Modified; _db.SaveChanges(); token newToken = new token() { tokenValue = tokenValue, expire = DateTime.Now + expire, type = 1, active = true, userId = userFromDB.id }; _db.token.Add(newToken); _db.SaveChanges(); dbtransaction.Commit(); } catch { dbtransaction.Rollback(); return(ResponseMessage(Request.CreateErrorResponse(HttpStatusCode.Unauthorized, "Connected to Facebook failed!"))); } } return(Ok(tokenFB)); }
static string generateToken() { dbDekkOnlineDataContext db = new dbDekkOnlineDataContext(); DateTime now = DateTime.Now.Date; string username = ConfigurationManager.AppSettings["dekkProUsername"]; string password = ConfigurationManager.AppSettings["dekkProPassword"]; dekkProURL = ConfigurationManager.AppSettings["dekkProUrl"]; var cToken = new token(); var checkTokens = (from tok in db.tokens where tok.tokDate >= now orderby tok.tokId descending select tok); string token = ""; if (checkTokens.Count() > 0) { cToken = checkTokens.FirstOrDefault(); token = cToken.tokData; lastUpdate = cToken.tokStockLastUpdate; lastUpdateCats = cToken.tokCategoriesLastUpdate; lastUpdateBrands = cToken.tokBrandsLastUpdate; } else { cToken = db.tokens.FirstOrDefault(); if (cToken == null) { cToken = new token(); db.tokens.InsertOnSubmit(cToken); } else { lastUpdate = cToken.tokStockLastUpdate; } cToken.tokDate = now; string urlToken = ConfigurationManager.AppSettings["dekkProUrlTokken"];; HttpWebRequest myRT = (HttpWebRequest)WebRequest.Create(urlToken); myRT.ContentType = "application/x-www-form-urlencoded"; var postData = "grant_type=password"; postData += "&username="******"&password="******"POST"; myRT.ContentLength = data.Length; Stream postStream = myRT.GetRequestStream(); postStream.Write(data, 0, data.Length); postStream.Flush(); postStream.Close(); var response = (HttpWebResponse)myRT.GetResponse(); var responseString = new StreamReader(response.GetResponseStream()).ReadToEnd(); token = responseString.Split(',')[0].Split(':')[1].Substring(1).TrimEnd('"'); cToken.tokData = token; db.SubmitChanges(); } return(token); }
var(token, expires) = tokenInfo;
await configuration.RestoreIfNeeded( token, restorer, sdkPackageID, sdkPackageVersion ) #endif , getFiles: getFiles
tokens.WhereAsArray(static (token, state) => IsObjectCreationToken(token, state), state));
public whitespace(token last = default, ctrlSymbol kind = default) { this.last = last; this.kind = kind; }
public void Create(token entity) { _unitOfWork.TokenRepository.Insert(entity); _unitOfWork.Save(); _unitOfWork.Commit(); }
public itemValor getValIdCorchetes(token idVal, elementoEntorno elem, List <int> lstIndex) { itemValor retorno = new itemValor(); retorno.setTypeNulo(); itemEntorno et = elem.getItemValor(idVal.valLower); if (et != null) { if (et.dimension.Count == lstIndex.Count) { int indiceFinal = 1; //validando si no se salió de los indices for (int i = 0; i < et.dimension.Count; i++) { if (lstIndex[i] < et.dimension[i]) { if (i == 0) //inicilizo la lista { indiceFinal = lstIndex[i]; } else { indiceFinal = indiceFinal * et.dimension[i] + lstIndex[i]; } } else { tablaSimbolos.tablaErrores.insertErrorSemantic("El índice está fuera de rango de la matriz: " + idVal.val + " , rango máximo permitido para la dimensión:" + i + " es " + (et.dimension[i] - 1), idVal); return(retorno); } } //validando que no salga del arreglo de adentro if (indiceFinal < et.valor.arrayValores.Count) { return(et.valor.arrayValores[indiceFinal]); } else { tablaSimbolos.tablaErrores.insertErrorSemantic("No se puede acceder a la posición de la matriz: " + idVal.val, idVal); return(retorno); } //println("El indice al que quiero acceder es al indice :" + indiceFinal + " de la matriz :" + idVal.val); } else { tablaSimbolos.tablaErrores.insertErrorSemantic("No coinciden las dimensiones en la matriz: " + idVal.val + " para acceder a ella", idVal); return(retorno); } } else { tablaSimbolos.tablaErrores.insertErrorSemantic("La variable : " + idVal.val + "no se encuentra en el ambito correcto para su acceso, no se ha declarado o no tiene permisos para acceder a ella", idVal); } return(retorno); }
throw new OperationCanceledException(token: cancellationToken);
public itemValor getValCorchetes(token idVal, elementoEntorno elem, List <int> lstIndex, itemValor itemVal) /* |---------------------------- | getValCorchetes *-------------------- * Sireve para los metodos que retornanan arreglos */ { itemValor retorno = new itemValor(); retorno.setTypeNulo(); if (hayErrores()) { return(retorno); } if (itemVal.dimensiones.Count == lstIndex.Count) { int indiceFinal = 1; //validando si no se salió de los indices for (int i = 0; i < itemVal.dimensiones.Count; i++) { if (lstIndex[i] < itemVal.dimensiones[i]) { if (i == 0) //inicilizo la lista { indiceFinal = lstIndex[i]; } else { indiceFinal = indiceFinal * itemVal.dimensiones[i] + lstIndex[i]; } } else { tablaSimbolos.tablaErrores.insertErrorSemantic("El índice está fuera de rango de la matriz: " + idVal.val + " , rango máximo permitido para la dimensión:" + i + " es " + (itemVal.dimensiones[i] - 1), idVal); return(retorno); } } //validando que no salga del arreglo de adentro if (indiceFinal < itemVal.arrayValores.Count) { return(itemVal.arrayValores[indiceFinal]); } else { tablaSimbolos.tablaErrores.insertErrorSemantic("No se puede acceder a la posición de la matriz: " + idVal.val, idVal); return(retorno); } //println("El indice al que quiero acceder es al indice :" + indiceFinal + " de la matriz :" + idVal.val); } else { tablaSimbolos.tablaErrores.insertErrorSemantic("No coinciden las dimensiones en la matriz: " + idVal.val + " para acceder a ella", idVal); return(retorno); } }
if (GetExpressionType(token, compileErrors, variables, methods) == "Error") { return(false);
/* |------------------------------------------------------------------------------------------------------------------- | EJECUCIÓN FINAL |------------------------------------------------------------------------------------------------------------------- | elementoEntorno,es el ambito actual | itemValor es el objeto donde voy a seguir buscandos | solo puedo recibir item de tipo objeto */ public itemValor getValor(elementoEntorno elementoEntorno, itemValor item) { itemValor retorno = new itemValor(); retorno.setTypeVacio(); if (hayErrores()) { return(retorno); } if (item.isTypeObjeto()) { if (lstAtributos.listaAtributos.Count == 2) { if (hijos.Count > 0) /* |---------------------------- | sPunto + valId + LST_CORCHETES_VAL */ { token nombreVar = lstAtributos.getToken(1); nodoModelo nodoLstCor = getNodo("LST_CORCHETES_VAL"); if (nodoLstCor != null) { _LST_CORCHETES_VAL lstCorchetes = (_LST_CORCHETES_VAL)nodoLstCor; List <int> listaEntero = lstCorchetes.getLstInt(elementoEntorno, nombreVar); String item1 = lstAtributos.listaAtributos[1].nombretoken; //mapeando el indice if (item1.Equals("valId")) { objetoClase tempObjeto = item.getObjeto(); if (tempObjeto != null) { return(getValIdCorchetes(lstAtributos.listaAtributos[1].tok, tempObjeto.tablaEntorno.raiz, listaEntero)); //return getValId(lstAtributos.listaAtributos[1].tok, tempObjeto.tablaEntorno.raiz); } else { tablaSimbolos.tablaErrores.insertErrorSemantic("No se pudo parsear el objeto", lstAtributos.listaAtributos[1].tok); return(retorno); } } else { println("sPunto + valId + LST_CORCHETES_VAL -> No viene val id"); } } } else /* |---------------------------- | sPunto + valId */ { String item1 = lstAtributos.listaAtributos[1].nombretoken; if (item1.Equals("valId")) { objetoClase tempObjeto = item.getObjeto(); if (tempObjeto != null) { return(getValId(lstAtributos.listaAtributos[1].tok, tempObjeto.tablaEntorno.raiz)); } else { tablaSimbolos.tablaErrores.insertErrorSemantic("No se pudo parsear el objeto", lstAtributos.listaAtributos[1].tok); return(retorno); } } } } else if (lstAtributos.listaAtributos.Count == 4) { if (hijos.Count == 2) /* |---------------------------- | sPunto + valId + sAbreParent + LST_VAL + sCierraParent + LST_CORCHETES_VAL */ { if (hayErrores()) { return(retorno); } String esteId = lstAtributos.listaAtributos[1].nombretoken; if (esteId.Equals("valId")) { objetoClase tempObjeto = item.getObjeto(); //esto es del metodo nodoModelo nodoTemp = getNodo("LST_VAL"); _LST_VAL lstParametros = (_LST_VAL)nodoTemp; itemValor itemValorRetornoMetodo = tempObjeto.ejecutarMetodoFuncion(lstAtributos.getToken(1), lstParametros.getLstValores(elementoEntorno), tempObjeto.tablaEntorno.raiz); //esto es de la parte del arreglo nodoModelo nodoLstCorchetes = getNodo("LST_CORCHETES_VAL"); _LST_CORCHETES_VAL lstCorchetes = (_LST_CORCHETES_VAL)nodoLstCorchetes; List <int> listaEntero = lstCorchetes.getLstInt(elementoEntorno, lstAtributos.listaAtributos[1].tok); if (itemValorRetornoMetodo.dimensiones.Count == listaEntero.Count) //tienen la misma dimension { return(getValCorchetes(lstAtributos.getToken(1), elementoEntorno, listaEntero, itemValorRetornoMetodo)); } else //no tienen la misma dimensión. { tablaSimbolos.tablaErrores.insertErrorSemantic("El metodo: " + lstAtributos.getToken(1).val + " no devuelve la misma cantidad de dimensiones que a las que se quiere acceder", lstAtributos.getToken(1)); return(retorno); } } else { println(" sPunto + valId + sAbreParent + LST_VAL + sCierraParent + LST_CORCHETES_VAL -> no viene valId"); return(retorno); } } else if (hijos.Count == 1) { if (hijos[0].nombre.Equals("LST_CORCHETES_VAL")) /* |---------------------------- | sPunto + valId + sAbreParent + sCierraParent + LST_CORCHETES_VAL */ { if (hayErrores()) { return(retorno); } String esteId = lstAtributos.listaAtributos[1].nombretoken; if (esteId.Equals("valId")) { objetoClase tempObjeto = item.getObjeto(); //esto es del metodo nodoModelo nodoTemp = getNodo("LST_VAL"); lstValores sinParametros = new lstValores(); //elementoEntorno.este.tablaEntorno.raiz itemValor itemValorRetornoMetodo = tempObjeto.ejecutarMetodoFuncion(lstAtributos.getToken(1), sinParametros, tempObjeto.tablaEntorno.raiz); //esto es de la parte del arreglo nodoModelo nodoLstCorchetes = getNodo("LST_CORCHETES_VAL"); _LST_CORCHETES_VAL lstCorchetes = (_LST_CORCHETES_VAL)nodoLstCorchetes; List <int> listaEntero = lstCorchetes.getLstInt(elementoEntorno, lstAtributos.listaAtributos[1].tok); if (itemValorRetornoMetodo.dimensiones.Count == listaEntero.Count) //tienen la misma dimension { return(getValCorchetes(lstAtributos.getToken(1), elementoEntorno, listaEntero, itemValorRetornoMetodo)); } else //no tienen la misma dimensión. { tablaSimbolos.tablaErrores.insertErrorSemantic("El metodo: " + lstAtributos.getToken(1).val + " no devuelve la misma cantidad de dimensiones que a las que se quiere acceder", lstAtributos.getToken(1)); return(retorno); } } else { println(" sPunto + valId + sAbreParent + LST_VAL + sCierraParent + LST_CORCHETES_VAL -> no viene valId"); return(retorno); } } else if (hijos[0].nombre.Equals("LST_VAL")) /* |---------------------------- | sPunto + valId + sAbreParent + LST_VAL + sCierraParent */ { #region cuerpo String esteId = lstAtributos.listaAtributos[1].nombretoken; objetoClase tempObjeto = item.getObjeto(); if (esteId.Equals("valId")) { nodoModelo nodoTemp = getNodo("LST_VAL"); _LST_VAL lstParametros = (_LST_VAL)nodoTemp; itemValor reto = tempObjeto.ejecutarMetodoFuncion(lstAtributos.getToken(1), lstParametros.getLstValores(elementoEntorno), tempObjeto.tablaEntorno.raiz); reto.nombrePregunta = item.nombrePregunta; return(reto); } else { println("sPunto + valId + sAbreParent + LST_VAL + sCierraParent "); } #endregion } } else if (hijos.Count == 0) /* |---------------------------- | sPunto + valId + sAbreParent + sCierraParent */ { #region cuerpo String esteId = lstAtributos.listaAtributos[1].nombretoken; objetoClase tempObjeto = item.getObjeto(); println("el nombre del objeto es " + tempObjeto.cuerpoClase.nombreClase.val); if (esteId.Equals("valId")) { nodoModelo nodoTemp = getNodo("LST_VAL"); lstValores sinParametros = new lstValores(); return(tempObjeto.ejecutarMetodoFuncion(lstAtributos.getToken(1), sinParametros, tempObjeto.tablaEntorno.raiz)); } else { println("sPunto + valId + sAbreParent + sCierraParent "); } #endregion } } } else { tablaSimbolos.tablaErrores.insertErrorSyntax("[objeto.objeto]El atributo/arreglo/metodo al que se quiere acceder no es de tipo objeto", new token()); } return(retorno); }
public opAritmetica(nodoModelo hijo1, nodoModelo hijo2, tablaSimbolos tabla, token signo) : base(hijo1, hijo2, tabla, signo) { }
return(Sort(array, progress, token, Compare(sortOrder)));
string refreshToken = default, string scope = default, DateTime expiration = default) => new AuthorizationInfo( token: token ?? Token,
select(token, replacements);
//------------------------------------------------- // machine_config - constructor //------------------------------------------------- public machine_config(game_driver gamedrv, emu_options options) { m_minimum_quantum = attotime.zero; m_gamedrv = gamedrv; m_options = options; m_root_device = null; m_default_layouts = new Dictionary <string, internal_layout>(); //([] (char const *a, char const *b) { return 0 > std::strcmp(a, b); }) m_current_device = null; // add the root device device_add("root", gamedrv.type, 0); // intialize slot devices - make sure that any required devices have been allocated foreach (device_slot_interface slot in new slot_interface_iterator(root_device())) { device_t owner = slot.device(); string slot_option_name = owner.tag().Substring(1); // + 1; // figure out which device goes into this slot bool has_option = options.has_slot_option(slot_option_name); string selval; bool is_default; if (!has_option) { // The only time we should be getting here is when emuopts.cpp is invoking // us to evaluate slot/image options, and the internal state of emuopts.cpp has // not caught up yet selval = slot.default_option(); is_default = true; } else { slot_option opt = options.slot_option(slot_option_name); selval = opt.value().c_str(); is_default = !opt.specified(); } if (!string.IsNullOrEmpty(selval)) { // TODO: make this thing more self-contained so it can apply itself - shouldn't need to know all this here device_slot_interface.slot_option option = slot.option(selval); if ((option != null) && (is_default || option.selectable())) { // create the device using (token tok = begin_configuration(owner)) { device_t new_dev = device_add(option.name(), option.devtype(), option.clock()); slot.set_card_device(new_dev); string default_bios = option.default_bios(); if (!string.IsNullOrEmpty(default_bios)) { new_dev.set_default_bios_tag(default_bios); } var additions = option.machine_config(); if (additions != null) { additions(this, new_dev); } input_device_default [] input_device_defaults = option.input_device_defaults(); if (input_device_defaults != null) { new_dev.set_input_default(input_device_defaults); } } } else { throw new emu_fatalerror("Unknown slot option '{0}' in slot '{1}'", selval, owner.tag().Substring(1)); } } } // then notify all devices that their configuration is complete foreach (device_t device in new device_iterator(root_device())) { if (!device.configured()) { device.config_complete(); } } }
public And(nodoModelo hijo1, nodoModelo hijo2, tablaSimbolos tabla, token signo) : base(hijo1, hijo2, tabla, signo) { }
public token nextToken() { if (stop) return current = new token(-1, -1, true, "eof", "eof"); if (pos == file.Length) { stop = true; return current = new token(startCol, startRow, true, lexeme, stanje); } if (file[pos] == '\n') { col = 1; row++; pos++; return nextToken(); } if (file[pos] == ' ' || file[pos] == '\t' || file[pos] == '\r') { pos++; col++; return nextToken(); } if (abeceda.IndexOf(file[pos]) == -1) throw new Exception("Napaka v datoteki, znak ni del abecede"); String produkcija = pravila[stanje][abeceda.IndexOf(file[pos])]; if (produkcija == "~" && končna.IndexOf(stanje) == -1) {//produkcije ni v tabeli, stanje pa ni končno throw new Exception("Napaka v datoteki, nisem našel končne produkcije"); } if ((produkcija == "~" || pos == file.Length) && končna.IndexOf(stanje) != -1) {//produkcije ni v tabeli, stanje je pa končno, vrnemo token. String oldLexeme = lexeme; String oldStanje = stanje; stanje = "start"; lexeme = ""; int oldCol = startCol, oldRow = startRow; startCol = col; startRow = row; //int oldPos = pos; //pos++; //col++; return current = new token(oldCol, oldRow, false, oldLexeme, oldStanje); } //produkcija je veljavna lexeme += file[pos]; stanje = produkcija; pos++; col++; return nextToken(); }
private static uint length(this token t) { return(uint32((t - matchType) >> (int)(lengthShift))); }