/ Goto definition
165314
function getDefinitionAtPosition(fileName, position) {
            synchronizeHostData();
            var sourceFile = getValidSourceFile(fileName);
            /// Triple slash reference comments
            var comment = findReferenceInPosition(sourceFile.referencedFiles, position);
            if (comment) {
                var referenceFile = ts.tryResolveScriptReference(program, sourceFile, comment);
                if (referenceFile) {
                    return [getDefinitionInfoForFileReference(comment.fileName, referenceFile.fileName)];
                }
                return undefined;
            }
            // Type reference directives
            var typeReferenceDirective = findReferenceInPosition(sourceFile.typeReferenceDirectives, position);
            if (typeReferenceDirective) {
                var referenceFile = program.getResolvedTypeReferenceDirectives()[typeReferenceDirective.fileName];
                if (referenceFile && referenceFile.resolvedFileName) {
                    return [getDefinitionInfoForFileReference(typeReferenceDirective.fileName, referenceFile.resolvedFileName)];
                }
                return undefined;
            }
            var node = ts.getTouchingPropertyName(sourceFile, position);
            if (node === sourceFile) {
                return undefined;
            }
            // Labels
            if (isJumpStatementTarget(node)) {
                var labelName = node.text;
                var label = getTargetLabel(node.parent, node.text);
                return label ? [createDefinitionInfo(label, ScriptElementKind.label, labelName, /*containerName*/ undefined)] : undefined;
            }
            var typeChecker = program.getTypeChecker();
            var symbol = typeChecker.getSymbolAtLocation(node);
            // Could not find a symbol e.g. node is string or number keyword,
            // or the symbol was an internal symbol and does not have a declaration e.g. undefined symbol
            if (!symbol) {
                return undefined;
            }
            // If this is an alias, and the request came at the declaration location
            // get the aliased symbol instead. This allows for goto def on an import e.g.
            //   import {A, B} from "mod";
            // to jump to the implementation directly.
            if (symbol.flags & 8388608 /* Alias */) {
                var declaration = symbol.declarations[0];
                // Go to the original declaration for cases:
                //
                //   (1) when the aliased symbol was declared in the location(parent).
                //   (2) when the aliased symbol is originating from a named import.
                //
                if (node.kind === 69 /* Identifier */ &&
                    (node.parent === declaration ||
                        (declaration.kind === 234 /* ImportSpecifier */ && declaration.parent && declaration.parent.kind === 233 /* NamedImports */))) {
                    symbol = typeChecker.getAliasedSymbol(symbol);
                }
            }
            // Because name in short-hand property assignment has two different meanings: property name and property value,
            // using go-to-definition at such position should go to the variable declaration of the property value rather than
            // go to the declaration of the property name (in this case stay at the same position). However, if go-to-definition
            // is performed at the location of property access, we would like to go to definition of the property in the short-hand
            // assignment. This case and others are handled by the following code.
            if (node.parent.kind === 254 /* ShorthandPropertyAssignment */) {
                var shorthandSymbol = typeChecker.getShorthandAssignmentValueSymbol(symbol.valueDeclaration);
                if (!shorthandSymbol) {
                    return [];
                }
                var shorthandDeclarations = shorthandSymbol.getDeclarations();
                var shorthandSymbolKind_1 = getSymbolKind(shorthandSymbol, node);
                var shorthandSymbolName_1 = typeChecker.symbolToString(shorthandSymbol);
                var shorthandContainerName_1 = typeChecker.symbolToString(symbol.parent, node);
                return ts.map(shorthandDeclarations, function (declaration) { return createDefinitionInfo(declaration, shorthandSymbolKind_1, shorthandSymbolName_1, shorthandContainerName_1); });
            }
            return getDefinitionFromSymbol(symbol, node);
        }
104348
def goto_step(self, inst: InstanceNode) -> InstanceNode:
        
        return inst.look_up(**self.parse_keys(inst.schema_node))
983750
function _gotoTry (list, ext, callback) {
      if (Tool.isArray(list) && list.length > 0) {
        var ele = list[0];
        _tryLoad(ele.path, ele.key, ext, function (cb) {
          var newLangFileList = list.splice(1);
          _gotoTry(newLangFileList, ext, cb);
        }, callback);
      } else {
        console.warn('[x] language list length is 0 or not a array. TYPE=' + Tool.getType(list));
      }
    }
76251
func (f *FSMContext) Goto(state string, data interface{}, decisions []Decision) Outcome {
	return TransitionOutcome{
		state:     state,
		data:      data,
		decisions: decisions,
	}
}
1263647
private void sawOpcodeLoop(final int seen) {
        try {
            stack.mergeJumps(this);

            switch (state) {
                case SAW_NOTHING:
                    if ((seen == Const.IINC) && (getIntConstant() == 1)) {
                        loopReg = getRegisterOperand();
                        state = State.SAW_IINC;
                    }
                break;

                case SAW_IINC:
                    if ((seen == Const.GOTO) || (seen == Const.GOTO_W)) {
                        int branchTarget = getBranchTarget();
                        int pc = getPC();
                        if (branchTarget < pc) {
                            possibleForLoops.add(new ForLoop(branchTarget, pc, loopReg));
                        }
                    }
                    state = State.SAW_NOTHING;
                break;
            }

            if ((seen == Const.INVOKEINTERFACE) && Values.SLASHED_JAVA_UTIL_LIST.equals(getClassConstantOperand()) && "size".equals(getNameConstantOperand())
                    && SignatureBuilder.SIG_VOID_TO_INT.equals(getSigConstantOperand())) {
                sawListSize = true;
            }
        } finally {
            stack.sawOpcode(this, seen);
        }
    }
54700
function getOS(guesses) {
      return reduce(guesses, function(result, guess) {
        var pattern = guess.pattern || qualify(guess);
        if (!result && (result =
              RegExp('\\b' + pattern + '(?:/[\\d.]+|[ \\w.]*)', 'i').exec(ua)
            )) {
          result = cleanupOS(result, pattern, guess.label || guess);
        }
        return result;
      });
    }
452129
func (app *App) GoTo(formName string, params []string) error {
	log.Println("App goto", formName)
	form, present := app.Forms[formName]
	if present {
		app.CurrentForm = form.Initialize(app.WS)
		err := form.Render(app.WS, app, params)
		if err != nil {
			log.Println("Error on goto", err)
		}
		status.Status.Gotos++
		action.UnblockUI(app.WS)
	} else {
		log.Println("[ERROR] Form not registred", formName)
	}
	return nil
}
1153086
def default_key_map
      tp = source
      source.bind_key(?\M-n.getbyte(0), 'goto_end'){ tp.goto_end } 
      source.bind_key(?\M-p.getbyte(0), 'goto_start'){ tp.goto_start } 
    end
932876
function(context: ParserContext): ?Token {
    if (
      !util.IsFollowsRuleSatisfied(
        context.getTokenWalker(),
        [
          { token: "keyword", values: ["goto"] },
          { token: "operator", values: [":"], optional: true }
        ],
        true
      )
    )
      return null;

    let value = context.reader.read();
    while (!context.reader.isEOF() && !/[\W]/.test(context.reader.peek()))
      value += context.reader.read();

    return context.createToken("label", value);
  }
600806
@Override
    public void sawOpcode(int seen) {
        UserObject uo = null;
        try {
            stack.precomputation(this);

            int pc = getPC();
            if (tryBlocks.get(pc)) {
                ScopeBlock sb = new ScopeBlock(pc, findCatchHandlerFor(pc));
                sb.setTry();
                rootScopeBlock.addChild(sb);
            }

            if (OpcodeUtils.isStore(seen)) {
                sawStore(seen, pc);
            } else if (OpcodeUtils.isLoad(seen)) {
                sawLoad(seen, pc);
            } else if ((seen == Const.INVOKEVIRTUAL) || (seen == Const.INVOKEINTERFACE)) {
                uo = sawInstanceCall(pc);
            } else if ((seen == Const.INVOKESTATIC) || (seen == Const.INVOKESPECIAL)) {
                uo = sawStaticCall();
            } else if (((seen >= Const.IFEQ) && (seen <= Const.GOTO)) || (seen == Const.IFNULL) || (seen == Const.IFNONNULL) || (seen == Const.GOTO_W)) {
                sawBranch(seen, pc);
            } else if (seen == Const.GETFIELD) {
                uo = sawGetField();
            } else if (seen == Const.PUTFIELD) {
                sawPutField(pc);
            } else if (seen == Const.IINC) {
                sawIINC(pc);
            } else if ((seen == Const.TABLESWITCH) || (seen == Const.LOOKUPSWITCH)) {
                sawSwitch(pc);
            } else if (seen == Const.MONITORENTER) {
                sawMonitorEnter(pc);
            } else if (seen == Const.MONITOREXIT) {
                sawMonitorExit(pc);
            }

            sawDup = seen == Const.DUP;
            sawNull = seen == Const.ACONST_NULL;
        } finally {
            TernaryPatcher.pre(stack, seen);
            stack.sawOpcode(this, seen);
            TernaryPatcher.post(stack, seen);
            if ((uo != null) && (stack.getStackDepth() > 0)) {
                OpcodeStack.Item item = stack.getStackItem(0);
                item.setUserValue(uo);
            }
        }
    }
304964
def go_to_line(self):
        

        editor = self.get_current_editor()
        if not editor:
            return False

        line, state = QInputDialog.getInt(self, "Goto Line Number", "Line number:", min=1)
        if not state:
            return False

        LOGGER.debug("> Chosen line number: '{0}'.".format(line))
        return editor.go_to_line(line)
937421
function(obj) {
      if (typeof obj.controller === 'undefined' || typeof obj.action === 'undefined') {
        var error = new Error('You must define a controller and action to redirect to.').stack;
        throw error;
      }

      return '/' + obj.controller + '/' + obj.action;
    }
305406
func (f *FSMContext) Goto(state string, data interface{}, decisions []*swf.Decision) Outcome {
	return Outcome{
		State:     state,
		Data:      data,
		Decisions: decisions,
	}
}
1092592
def p_goto(p):
    
    entry = check_and_make_label(p[2], p.lineno(2))
    if entry is not None:
        p[0] = make_sentence(p[1].upper(), entry)
    else:
        p[0] = None
1278975
func (g *Group) Goto() *Statement {
	// notest
	s := Goto()
	g.items = append(g.items, s)
	return s
}
93717
public final void mINTO() throws RecognitionException {
		try {
			int _type = INTO;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// druidG.g:584:15: ( ( 'INTO' | 'into' ) )
			// druidG.g:584:16: ( 'INTO' | 'into' )
			{
			// druidG.g:584:16: ( 'INTO' | 'into' )
			int alt4=2;
			int LA4_0 = input.LA(1);
			if ( (LA4_0=='I') ) {
				alt4=1;
			}
			else if ( (LA4_0=='i') ) {
				alt4=2;
			}

			else {
				NoViableAltException nvae =
					new NoViableAltException("", 4, 0, input);
				throw nvae;
			}

			switch (alt4) {
				case 1 :
					// druidG.g:584:17: 'INTO'
					{
					match("INTO"); 

					}
					break;
				case 2 :
					// druidG.g:584:24: 'into'
					{
					match("into"); 

					}
					break;

			}

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
942050
def obo(self):
        
        meta = self._obo_meta()
        meta = [meta] if meta else []
        newline = "\n\n" if six.PY3 else "\n\n".encode('utf-8')

        try: # if 'namespace' in self.meta:
            return newline.join( meta + [
                r.obo for r in self.typedefs
            ] + [
                t.obo for t in self
                    if t.id.startswith(self.meta['namespace'][0])
            ])
        except KeyError:
            return newline.join( meta + [
                r.obo for r in self.typedefs
            ] + [
                t.obo for t in self
            ])